操纵符详解，超详细的先容操纵符的作用与功能和注意事项
1.操纵符分类算术操纵符
位移操纵符
位操纵符
赋值操纵符
单目操纵符
关系操纵符
逻辑操纵符
条件操纵符
逗号操纵符
下标引用、函数调用和布局体成员操纵符
2.算术操纵符
+ - * / %
[*]除%操纵符外，其他的4个操纵符都是可以作用于整数和浮点数。即取模的操纵符的两头必须都是整数。
[*]对于/操纵符假如两个操纵数都为整数，实行整数除法。而有浮点数实行的就是浮点数除法
[*]%操纵符的两个操纵符必须为整数。返回的是整数之后的余数
步调当中的二进制位
步调的最底层都是二进制位，在C语言中也不例外。数与数的运算都是以二进制位运算的，以正整数15为例，它的二进制表达为：00000000 00000000 00000000 00001111。同时二进制有三种表达情势。
整数的二进制表达情势：
原码 反码 补码。
正整数的原 反 补码是雷同的
负整数的原 反 补码是要盘算的
盘算负整数的反码与补码
负数的反码便是原码的符合位稳固，其他位按位取反得到的就是反码
补码便是反码加1
以-15为例
-15的原码为 10000000 00000000 00000000 00001111
-15的补码为 11111111 11111111 11111111 11110000
-15的补码为 11111111 11111111 11111111 11110001
什么是符号位
符号位就是在整数的进制位最左侧的一位为符号位，1表现负数 0表现正数。
补码的作用
在盘算机中的运算都是围绕着补码来盘算的。
在内存中存储的是补码，盘算也是用的补码
3.移位操纵符
<< 左移操作符
>> 右移操作符
//移位操作符的操作数只能是整数
3.1 左移操纵符
左边扬弃、右边补0
https://dis.qidao123.com/imgproxy/aHR0cHM6Ly9pLWJsb2cuY3NkbmltZy5jbi9kaXJlY3QvYTMzNTRhOTNlNDVjNDczY2FhNjZiNGYzODI2MzkxYzYucG5n
在num没有被赋值的环境下，自身的值不会改变。
3.2 右移操纵符
规则
右移运算有两种规则：
> 1.逻辑移位
> 左边用0添补，右边扬弃
> 2.算术移位
> 左边用原该值的符号位添补，右边扬弃
C语言没有明白规定是算术右移还是符号右移，一样平常编译器上接纳的是算术右移
#include <stdio.h>
int main()
{
int num = -1;
int b = num >> 1;
printf("%d\n", b);
return 0;
}
//打印结果 -1
https://dis.qidao123.com/imgproxy/aHR0cHM6Ly9pLWJsb2cuY3NkbmltZy5jbi9kaXJlY3QvNDYwZmFjNTQ2NmJiNGM1ZGFjNjE1MzRkMmRkNDlhYjUucG5n
注意：对于移位操纵符，不能移动负数位，这是标准为界说举动
//错误写法
int num = 10;
num>>-1;//error
4.位操纵符
位操纵符：
& //按位与
| //按位或
^ //按位异或
//以上操作符的操作数必须是整数
位操纵符也是对二进制举行操纵的，且为双目操纵符
&的作用就是将，两个二进制位的补码，对应位置有0为0，两个同时为1才是1.
1&2
00000000 00000000 00000000 00000001
00000000 00000000 00000000 00000010
结果
00000000 00000000 00000000 00000000
|的作用就是将，两个二进制位的补码，对应位置有1为1，两个同时为0才是0.
1|2
00000000 00000000 00000000 00000001
00000000 00000000 00000000 00000010
结果
00000000 00000000 00000000 00000011
^的作用就是将，两个二进制位的补码，对应位置雷同为0，差别为1.
1^2
00000000 00000000 00000000 00000001
00000000 00000000 00000000 00000010
结果
00000000 00000000 00000000 00000011
训练：
#include <stdio.h>
int main()
{
int num1 = 1;
int num2 = 2;
printf("%d\n",num1&num2);
printf("%d\n",num1|num2);
printf("%d\n",num1^num2);
return 0;
}
//打印结果
/*
0
3
3
*/
训练
在不能创建临时变量（第3个变量）的环境下，实现两个数的交换
//代码1
#include <stdio.h>
int main()
{
int a = 5;
int b = 3;
a = a^b;
b = a^b;
a = a^b;
printf("a = %d,b = %d",a,b);
return 0;
}
//代码2
#include <stdio.h>
int main()
{
int a = 5;
int b = 3;
a = a-b;
b = a+b;
a = b-a;
printf("a = %d,b = %d\n",a,b);
return 0;
}
训练
编写代码实现：求一个整数存储在内存中的二进制中的1的个数
#include <stdio.h>
int main()
{
int a = 0;
scanf("%d",&a);
int num = 1;
int count = 0;
for(int i = 0;i<32;++i)
{
num = 1<<i;
if(a&num)
{
count++;
}
}
printf("%d\n",count);
return 0;
}
5.赋值操纵符
int weight = 120;
weight = 89;
double salary = 10000.0;
salary = 20000.0;
//赋值操作符可以连续使用，比如
int a = 10;
int b = 20;
int c = 30;
a = b = c = 50;//连续赋值
//推荐使用分开赋值，代码更简单，调试也很方便
复合赋值符
+=
-=
*=
/=
%=
>>=
<<=
&=
|=
^=
这些运算符都可以写成复合的结果
6.单目操纵符
6.1 先容单目操纵符
! 逻辑反操作
- 负值
+ 正值
& 取地址
sizeof操作数的类型长度（以字节为单位）
~ 对一个数的二进制按位取反
-- 前置、后置--
++ 前置、后置++
* 间接访问操作符（解引用操作符）
(类型) 强制类型转化
* 通过指针变量中存放的地点，找到指向的空间（内容）
#include <stdio.h>
int main()
{
int a = 1;
int* pa = &a;
a = -a;
printf("%d\n",sizeof(a));
printf("%d\n",sizeof a);
printf("%d\n",sizeof(int));
printf("%d\n",sizeof int);//错误写法，对应类型计算要加()
return 0;
}
6.2 sizeof和数组
#include <stdio.h>
void test1(int arr)
{
printf("%d\n",sizeof(arr));
}
void test2(char ch)
{
printf("%d\n",sizeof(ch));
}
int main()
{
int arr = {0};
char ch = {0};
printf("%d\n",sizeof(arr));
printf("%d\n",sizeof(ch));
test1(arr);
test2(ch);
return 0;
}
//打印结果
/*
40
10
4/8
4/8
*/
//关于前置++ 后置++与前置-- 后置--
#include <stdio.h>
int main()
{
int a = 10;
int x = ++a;
//a先自增1，然后再用a对x赋值
int y = a++;
//先用a赋值y，然后a再自增1
return 0;
}
7.关系操纵符
>
>=
<
<=
!= 不等于
== 等于
注意== 和 = 的区分
8.逻辑操纵符
&& 逻辑与
|| 逻辑或
区分逻辑与和按位与
区分逻辑或和按位或
训练
//代码1
#include <stdio.h>
int main()
{
int i = 0,a = 0,b = 2,c = 3,d = 4;
i = a++&&++b&&d++;
printf(" a = %d\n b = %d\n c = %d\n d = %d\n",a,b,c,d);
return 0;
}
//打印结果
/*
a = 1
b = 2
c = 3
d = 4
*/
//代码1
#include <stdio.h>
int main()
{
int i = 0,a = 0,b = 2,c = 3,d = 4;
i = a++||++b||d++;
printf(" a = %d\n b = %d\n c = %d\n d = %d\n",a,b,c,d);
return 0;
}
//打印结果
/*
a = 1
b = 3
c = 3
d = 4
*/
对于多个&&毗连的一个式子，从左到右当出现一个表达式为假时，此时该条式子已经为假，盘算机便不要再往右盘算。
对于多个||毗连的一个式子，从左到右当出现一个表达式为真时，此时该条式子已经为真，盘算机便不要再往右盘算。
9.条件操纵符
exp1?exp2:exp3
//当exp1为真时执行exp2反之执行exp3
if(a>5)
b = 3;
else
b = -3;
//利用条件操作符简化
b = a>5?3:-3
10.逗号表达式
exp1,exp2,exp3,...expn
逗号表达式，就是用逗号隔开的多个表达式。
逗号表达式，c从左向右依次实行。整个表达式的结果是末了一个表达式的结果。
a = get_val();
count_val(a);
while(a>0)
{
//.....
a = get_val();
count_val(a);
}
//利用逗号表达式
while(a = get_val(),count_val(a),a>0)
{
//.....
}
11.下标引用、函数调用和布局成员
1.[] 下标引用操纵符
操纵数：一个数组名+一个索引值
int arr = {0};
arr = 10;
//[]的两个操作数是arr和9。
//数组也是有类型的，去掉名字就是数组类型，如int arr = {0};类型为：int
2.（）函数调用操纵符
担当一个大概多个操纵符：第一个操纵数是函数名，剩余的操纵数就是转达给函数的参数
#include <stdio.h>
void test1()
{
printf("hahaha\n");
}
void test2(const char* str)
{
printf("%s\n",str);
}
int main()
{
test1();
test2("hello!");
}
3.访问一个布局的成员
.布局体.成员名
-> 布局体指针->成员名
#include <stdio.h>
struct stu
{
char name;
int age;
char sex;
};
int main()
{
struct stu s;
struct stu* ps;
ps = &s;
s.age = 17;
s.name = Yui;
s.sex = female;
ps->age = 18;
ps->name = Yui;
s->sex = female;
}
12.表达式求值
表达式求值的次序一部分是由操纵符的优先级和联合性决定的。
同样，有些表达式的操纵符在求值的过程中大概须要转换范例为其他范例。
12.1隐式范例转换
C的整型算术总是至少以缺省整型范例的精度来举行的。
为了得到这个精度，表达式中的字符和短整型操纵数在使用之前被转换为平常整型，这种转换称为整型提拔
整型提拔的意义：
表现式的整型要在CPU的相应运算器实行，CPU内整型运算器（ALU）的操纵数的字节长度一样平常就是int的字节长度，同时也是CPU的通用寄存器的长度。
因此，纵然两个char范例的相加，在CPU实行时实际上也要先转换为CPU内整型操纵数的标准长度。
通用CPU是难以直接实现两个8比特字节直接相加运算（固然呆板指令大概有这种字节相加的指令）。以是，表达式中的各种长度大概小于int长度的整型值，都必须先转换为int大概unsigned int
，然后才气送入CPU去实行。
//实例1
char a,b,c;
...
a = b+c;
b和c的值被提拔为平常整型，然后再实行加法运算。
加法完成后，结果将被截断，然后再存储于a当中。
然后举行整型提拔
整型提拔是按照变量的数据范例的符合位来提拔的。
#include <stdio.h>
int main()
{
//负数的整型提升
char c1 = -1;
//变量c1的二进制位（补码）中只有8个比特位
//11111111
//因为char为符合的char
//所以在整型提升的时候，高位补充符合位，即为1
//提升后的结果：
//11111111 11111111 11111111 11111111
char c2 = 1;
//变量c2的二进制位（补码）中只有8个比特位
//00000001
//因为char为符合的char
//所以在整型提升的时候，高位补充符合位，即为1
//提升后的结果：
//00000000 00000000 00000000 00000001
//无符号整型提升，高位补0
}
#include <stdio.h>
int main()
{
char c = 1;
printf("%u\n",sizeof(c));
printf("%u\n",sizeof(+c));
printf("%u\n",sizeof(-c));
return 0;
}
//打印结果
/*
1
4
4
*/
该实例中，c只要到场表达式运算，就会发生整型提拔，以是在实行+c/-c的过程中就有整型提拔。变为整型4个字节
12.2 算术转换
假如某个操纵符的各个操纵符属于差别的范例，那么除非此中一个操纵数的转换位另一个操纵数的范例，否则就无法盘算。下面的条理体系称为平常算术转换。
long double
double
float
unsigned long int
long int
unsigned int
int
假如，某个操纵数的范例在上面这个列表的排名较低，那么起首要转换位另一个操纵数的范例后实行运算。
注意：
算术转换要公道，否则大概会有精度丢失等一些题目。
float f = 3.14;
int num = f;//隐式转换，会有精度丢失
12.3操纵符的属性
复杂表达式的求值有3个影响因素。
[*]操纵符的优先级
[*]操纵符的联合性
[*]是否控制求值次序
两个相邻的操纵符先实行哪个，取决于它们的优先级。假如两者优先级雷同，取决于它们的联合性。
操纵符优先级
操纵符形貌用法示例结果类 型联合性是否控制求值 次序（）聚组（表达式）与表达式同N/A否（）函数调用rexp（rexp，…,rexp）rexpL-R否[ ]下标引用rexplexpL-R否.访问布局成员lexp.member_namelexpL-R否->访问布局指针成员rexp->member_namelexpL-R否++后缀自增lexp ++rexpL-R否–后缀自减lexp –rexpL-R否!逻辑反! rexprexpR-L否~按位取反~ rexprexpR-L否+单目，表现正值+ rexprexpR-L否-单目，表现负值- rexprexpR-L否++前缀自增++ lexprexpR-L否–前缀自减– lexprexpR-L否*间接访问* rexplexpR-L否&取地点& lexprexpR-L否sizeof取其长度，以字节
表现sizeof rexp sizeof(范例)rexpR-L否(范例）范例转换(范例) rexprexpR-L否*乘法rexp * rexprexpL-R否/除法rexp / rexprexpL-R否%整数取余rexp % rexprexpL-R否+加法rexp + rexprexpL-R否-减法rexp - rexprexpL-R否<<左移位rexp << rexprexpL-R否>>右移位rexp >> rexprexpL-R否>大于rexp > rexprexpL-R否>=大于便是rexp >= rexprexpL-R否<小于rexp < rexprexpL-R否<=小于便是rexp <= rexprexpL-R否操纵
符形貌用法示例结果类 型联合 性是否控制求值 次序==便是rexp == rexprexpL-R否!=不便是rexp != rexprexpL-R否&位与rexp & rexprexpL-R否^位异或rexp ^ rexprexpL-R否|位或rexp | rexprexpL-R否&&逻辑与rexp && rexprexpL-R是|逻辑或rexp | rexprexpL-R是? :条件操纵符rexp ? rexp : rexprexpN/A是=赋值lexp = rexprexpR-L否+=以…加lexp += rexprexpR-L否-=以…减lexp -= rexprexpR-L否*=以…乘lexp *= rexprexpR-L否/=以…除lexp /= rexprexpR-L否%=以…取模lexp %= rexprexpR-L否<<=以…左移lexp <<= rexprexpR-L否>>=以…右移lexp >>= rexprexpR-L否&=以…与lexp &= rexprexpR-L否^=以…异或lexp ^= rexprexpR-L否|=以…或lexp |= rexprexpR-L否，逗号rexp，rexprexpL-R是a*b+c*d+e*f
在上面的代码当中，由于*比+的优先级高，只能包管，*的盘算比+早，但是优先级并不能决定第三个*比第一个+早实行。
//盘算机的盘算次序大概是a*bc*da*b+c*de*fa*b+c*d+e*f
//大概a*bc*de*fa*b+c*da*b+c*d+e*f
再看一段代码
c + --c
操纵符的优先级只能决定自减–的运算在+的运算前面，但是我们并没有办法得知，+的操纵符的左操纵数的获取在右操纵数之前还是之后求值，以是结果是不可推测的，是有歧意的。
//非法表达式
int main()
{
int i = 10;
i = i-- - --i * (i=-3) * i++ + ++i;
printf("i = %d\n",i);
return 0;
}
本段代码出在《C与指针》。该书的作者实验了市面上全部的主流编译器，得到的答案却都不雷同。以是这段代码没有实际的意义。
总结：
我们写出的表达式假如不能通过操纵符的属性确定唯一的盘算路径，那么这个表达式就是存在题目标。
完
页:
[1]