| 操作符 | 含义 |
|---|---|
| = | 将 " = " 右侧的值赋给左侧的变量 |
| 序号 | 操作符 | 含义 | 示例 |
|---|---|---|---|
| 1 | += | 加法运算 | a += 3 等同于 a = a + 3 |
| 2 | -= | 减法运算 | b -= 1 等同于 b = b - 1 |
| 3 | *= | 乘法运算 | c *= 1 等同于 c = c * 1 |
| 4 | /= | 除法运算 | d /= 1 等同于 d = d / 1 |
| 5 | %= | 取余运算 | a %= 1 等同于 a = a % 1 |
| 6 | >>= | 右移赋值 | b >>= 1 等同于 b = b >> 1 |
| 7 | <<= | 左移赋值 | c <<= 1 等同于 c = c << 1 |
| 8 | &= | 与赋值 | d &= 1 等同于 d = d & 1 |
| 9 | l= | 或赋值 | a l= 1 等同于 a = a l 1 |
| 10 | ^= | 异或赋值 | b ^= 1 等同于 b = b ^ 1 |
int main()
{
//赋值操作符 =
int a = 10;
int x = 0;
int y = 30;
a = x = y + 1;//连续赋值
//同样的语义：
x = y + 1;
a = x;//代码清晰易读
}
在C语言中 = 是赋值
== 是判断
int main()
{
//复合赋值符 += -= *= /= %= >>= <<= &= |= ^=
int a = 100;
a = 100;
a = a + 100;//(1)
a += 100;//(2) 两种写法的语义完全相同
a = a >> 3;
a >>= 3;
return 0;
}
（二）单目运算符
一、运算符
| 序号 | 运算符 | 含义 |
|---|---|---|
| 1 | ! | 逻辑反操作 |
| 2 | - | 负值 |
| 3 | + | 正值 |
| 4 | & | 取地址 |
| 5 | sizeof | 操作数的类型长度（以字节为单位） |
| 6 | ~ | 对一个数的二进制按位取反 |
| 7 | – （两个减号并排） | 前置、后置– |
| 8 | ++ | 前置、后置++ |
| 9 | * | 间接访问操作符（解引用操作符） |
| 10 | (类型) | 强制类型转换 |
在 ! 的左边只有一个操作数，所以是单目操作符
示例一：
int main()
{
//单目运算符 ！
int flag = 5;
if (flag)//flag为真，打印1 2 3
{
printf("1 2 3n");
}
//flag为假，打印4 5 6
if (!flag)
{
printf("4 5 6n");
}
return 0;
}
结果：
2、正负号 + -示例二：
int main()
{
int a = 10;
a = -a;
printf("%dn", a);
a = +a;//+ 正号可以省略
printf("%dn", a);
return 0;
}
结果：
3、计算操作数的类型长度——sizeof示例三：
int main()
{
int a = 10;
printf("%dn", sizeof(a));//计算a所占空间的大小，单位是字节
printf("%dn", sizeof(int));//计算int类型的大小
printf("%dn", sizeof a);//计算一个变量名的大小的时候可以将其两端的圆括号省略掉
//printf("%dn", sizeof int);错误写法：计算类型的大小，不能省略()
}
结果为：
这证明sizeof是操作符，不是函数。如果sizeof是函数，则后面的()不能省略。
int main()
{
char arr[10] = { 0 };
printf("数组arr的大小为：%dn", sizeof(arr));//大小为：10（char类型是1个字节）
printf("%dn", sizeof(char [10]));//10, char [10]是数组arr的类型
int arr1[10] = { 0 };
printf("数组arr1的大小为：%dn", sizeof(arr1));//sizeof可以计算数组大小，单位依然是字节
return 0;
}
结果为：
int main()
{
int a = 10;
short s = 5;
printf("%dn", sizeof(short));
printf("%dn", sizeof(s = a + 2));//2
printf("%dn", s);//5 sizeof的()中的表达式不参与运算
return 0;
}
结果：
首先，short类型一定是占两个字节的，int是占4个字节的。然后a+2=12，此时我们使用sizeof去算大小的时候，由于a+2的结果一定是放到s里面的，所以（）内的表达式的结果最终是由s决定，s所占的空间有多大，sizeof(s = a+2)的值就有多大。因为s是short类型 ，所以是大小为：2个字节。
（一个大的变量放在一个小的空地里面的时候放不下，就要截断它，保留有限位就行了，所以表达式最终的大小还是由s说了算）
~ 按位取反——取补码的反码 (包括符号位在内)
示例四：
int main()
{
int a = -1;
//10000000000000000000000000000001 -原码
//11111111111111111111111111111110 -反码
//11111111111111111111111111111111 -补码
// ~ 按位取反——取补码的反码 (包括符号位在内)
//11111111111111111111111111111111
//00000000000000000000000000000000
int b = ~a;
printf("a = %dn", a);
printf("b = %dn", b);
return 0;
}
结果：
5、前置、后置++ –示例五：
int main()
{
int a = 10;
int b = a++;//后置++，先使用，再++
//int b = ++a;//前置++，先++，再使用
printf("%dn", a);// 11
printf("%dn", b);// 10
return 0;
}
int main()
{
int a = 10;
int b = a--;//后置--，先使用，再--
//int b = --a;//前置--，先--，再使用
printf("%dn", a);// 9
printf("%dn", b);// 10
return 0;
}
int main()
{
int a = 10;
printf("%dn", a--); //10
printf("%dn", a); //9
return 0;
}
后置++，先使用，再++
前置++，先++，再使用
后置–，先使用，再–
前置–，先–，再使用
& ——取地址操作符,地址是2进制的序列，但是 它是以16进制的数展示的
示例六：
int main()
{
int a = 10;
printf("%pn", &a);
int* pa = &a;//pa是用来存放地址的 ——pa就是一个指针变量
*pa = 20;// * ——解引用操作符——间接访问操作符
printf("%dn", a);
return 0;
}
int* pa = &a; 符号 * 说明pa是个指针变量，它指向的那个对象（a）的类型也是int类型。 符号 & 是获取a的在内存中的地址。
7、强制类型转换 （类型）强制类型转换——()里面放要转换成的类型
示例七：
int main()
{
int a = (int)3.14;//若不转换，则会有一个警告：double转化为int，可能会丢失数据。
printf("%dn", a);
return 0;
}
例题：sizeof和数组
问：
- （1）和（2）两个地方的输出分别是多少？（3）和（4）两个地方的输出分别是多少？
void test1(int arr[])
{
printf("%dn", sizeof(arr));// <2>
}
void test2(char ch[])
{
printf("%dn", sizeof(ch));// <4>
}
int main()
{
int arr[10] = { 0 };
int ch[10] = { 0 };
printf("%dn", sizeof(arr));// <1>
printf("%dn", sizeof(ch));// <3>
test1(arr);
test2(ch);
return 0;
}
分析：
<1> arr是int类型的数组，里面由10的元素，一个int类型的大小是4个字节，所以数组arr的大小是40。
<3> ch是char类型的数组，里面一样含有10个元素。一个char类型的大小是1个字节，所以数组char的大小是10。
<2>和<4>的结果都会是4或者8。
因为在调用函数test1()和test2()的时候，采用数组传参，但是实际传递过去的是数组首元素的地址，即数组中第一个元素的地址。
数组arr中的所有元素都是整型，首元素的地址就是整型的地址，整型的地址传到函数test1()中，而地址应该放到指针中，所以test1()的参数实际上是int *arr，arr是一个指针。sizeof（arr)算的实际上一个指针变量的大小，在32位平台下是4，64位平台下是8。
同理ch是一个char类型的数组，一个char类型的数组传过去，test2()里的参数也是一个指针，即char *ch,因为指针变量是用来存放地址的，所以ch也是用来存放地址的，它的大小也是4个或8个字节。
指针大小不论类型，它们都是用来存放地址的。而地址总是32位的二进制序列或者62位的二进制序列，所以地址的大小是固定的，指针变量不管是什么类型，它的大小都是那么大的。
| 操作符 | 含义 |
|---|---|
| > | 大于 |
| >= | 大于等于 |
| < | 小于 |
| <= | 小于等于 |
| != | 用于测试“不相等” |
| == | 用于测试“相等” |
注意：在编程过程中==和=不小心写错，导致的错误
比较两个字符串相等，不能使用==。可以通过引入头文件#include
即：通过strcmp进行比较两个字符串是否相同（逐个比较两个字符串中的对应位置的字符是否一致），如果都相同，则返回0。
区分逻辑与和按位与 区分逻辑或和按位或
&& 逻辑与
|| 逻辑或
1&2 ----->0 按位与
1&&2 ----->1 逻辑与
1|2 ------->3 按位或
1||2 ------->1 逻辑或
示例九：
int mian()
{
int a = 3;
int b = 0;
//if (a && b)
if(a || b)
{
printf("hehen");
}
return 0;
}
测试题：下面程序输出的结果是什么？
int main()
{
int i = 0, a = 0, b = 2, c = 3, d = 4;
i = a++ && ++b && d++;
//i=a++||++b||d++;
printf("a = %dnb = %dnc = %dnd = %dn", a, b, c, d);
return 0;
}
输出结果：
因为&&是逻辑与，必须两边都是真（非0）才能执行本语句，如果有一个是假（0），则语句不往后算。举个例子在int c = a && b;里面，如果a=0，则不管b=0或者1或者2都无所谓，因为在a=0的时候，这个语句已经判断c为0（逻辑假），左边已经不用算了。
而在本题中：a++在前，所以是先使用a的值，然后a+1，由于a=0，所以表达式a++为0，而0为假，&&是逻辑与，故不论++b为何值，表达式a++ && ++b都为0；同理a++ && ++b && d++也为0，因此i=0，++b和d++都没有算。由于a++，且a已经使用完毕，则a+1=1。
int main()
{
int i = 0, a = 1, b = 2, c = 3, d = 4; //a=1时
i = a++ && ++b && d++;
//i=a++||++b||d++;
printf("a = %dnb = %dnc = %dnd = %dn", a, b, c, d);
return 0;
}
当a = 1时，表达式a++为真，我们可以继续往下算，得到i = 1。
输出结果依次为：a = 2 , b = 3 , c = 3 , d = 5 ;
int main()
{
int i = 0, a = 1, b = 2, c = 3, d = 4; //a=1时
//i = a++ && ++b && d++;
i = a++ || ++b || d++;
printf("a = %dnb = %dnc = %dnd = %dn", a, b, c, d);
return 0;
}
输出结果依次为：a = 2 , b = 2 , c = 3 , d = 4 ;
因为a=1，表达式a++为真，而 || 是逻辑或，只要有一个为真即可，剩下的表达式无所谓，所以++b || d++不用再算了。因此i=1。
综上：对于逻辑与&&，左边为假，则右边不要继续算了；
对于逻辑或 || ，左边为真，则右边不要继续算了。
int main()
{
int i = 0, a = 0, b = 2, c = 3, d = 4; //a=0时
//i = a++ && ++b && d++;
i = a++ || ++b || d++;
printf("a = %dnb = %dnc = %dnd = %dn", a, b, c, d);
return 0;
}
输出结果依次为：a = 1 , b = 3 , c = 3 , d = 4 ;
因为a=0，表达式a++为假，接下来计算表达式++b。因为b=2，++b使b先自增1，变为3，然后使用，发现++b为真，而 || 是逻辑或，只要有一个为真即可，剩下的表达式无所谓，所以d++不用再算了。因此i=1。
