[C++知识库]【C语言学习记录】（五）——操作符详解③——赋值运算符 和 单目运算符

（一）赋值运算符

一、运算符

case1：基本的赋值运算符

case2：复合的赋值运算符

二、举例

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、逻辑反操作 ！

在 ! 的左边只有一个操作数，所以是单目操作符
示例一：

int main()
{
	//单目运算符 ！ 
	int flag = 5;
	if (flag)//flag为真，打印1 2 3 
	{
		printf("1 2 3\n");
	}
	//flag为假，打印4 5 6
	if (!flag)
	{
		printf("4 5 6\n");
	}
	return 0;
/*单目操作符: 只有一个操作数*/
}

结果：

2、正负号 + -

示例二：

int main()
{
	int a = 10;
	a = -a;
	printf("%d\n", a);
	a = +a;//+ 正号可以省略
	printf("%d\n", a);
	return 0;
}

结果：

3、计算操作数的类型长度——sizeof

示例三：

int main()
{
	int a = 10;
	printf("%d\n", sizeof(a));//计算a所占空间的大小，单位是字节
	printf("%d\n", sizeof(int));//计算int类型的大小
	printf("%d\n", sizeof a);//计算一个变量名的大小的时候可以将其两端的圆括号省略掉
	//printf("%d\n", sizeof int);错误写法：计算类型的大小，不能省略()
}

结果为：
这证明sizeof是操作符，不是函数。如果sizeof是函数，则后面的()不能省略。

int main()
{
	char arr[10] = { 0 };
	printf("数组arr的大小为：%d\n", sizeof(arr));//大小为：10（char类型是1个字节）
	printf("%d\n", sizeof(char [10]));//10, char [10]是数组arr的类型
								
	/*若换成int 一个int是4个字节*/
	int arr1[10] = { 0 };
	printf("数组arr1的大小为：%d\n", sizeof(arr1));//sizeof可以计算数组大小，单位依然是字节
	return 0;
	
}

结果为：

int main()
{
	int a = 10;
	short s = 5;
	printf("%d\n", sizeof(short));
	printf("%d\n", sizeof(s = a + 2));//2
	printf("%d\n", 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说了算）

4、对一个数的二进制位按位取反 ~

~ 按位取反——取补码的反码 (包括符号位在内)
示例四：

int main()
{
	int a = -1;
	//10000000000000000000000000000001 -原码
	//11111111111111111111111111111110 -反码
	//11111111111111111111111111111111 -补码
	// ~ 按位取反——取补码的反码  (包括符号位在内)
	//11111111111111111111111111111111
	//00000000000000000000000000000000
	int  b = ~a;
	printf("a = %d\n", a);
	printf("b = %d\n", b);

	return 0;
}

结果：

5、前置、后置++ –

示例五：

int main()
{
	int a = 10;
	int b = a++;//后置++，先使用，再++
	//int b = ++a;//前置++，先++，再使用
	printf("%d\n", a);//  11
    printf("%d\n", b);// 10
	return 0;
}

int main()
{
	int a = 10;
	int b = a--;//后置--，先使用，再--
	//int b = --a;//前置--，先--，再使用
	printf("%d\n", a);//  9
	printf("%d\n", b);// 10
	return 0;
}

int main()
{
	int a = 10;
	printf("%d\n", a--); //10
	printf("%d\n", a); //9
	return 0;
}

后置++，先使用，再++
前置++，先++，再使用

后置–，先使用，再–
前置–，先–，再使用

6、取地址操作符 & 和 解引用操作符 *

& ——取地址操作符,地址是2进制的序列，但是 它是以16进制的数展示的
示例六：

int main()
{
	int a = 10;
	printf("%p\n", &a);
	int* pa = &a;//pa是用来存放地址的  ——pa就是一个指针变量
	*pa = 20;// * ——解引用操作符——间接访问操作符
	printf("%d\n", a);

	return 0;
}

? ? int* pa = &a; 符号 * 说明pa是个指针变量，它指向的那个对象（a）的类型也是int类型。 符号 & 是获取a的在内存中的地址。

7、强制类型转换 （类型）

强制类型转换——()里面放要转换成的类型
示例七：

int main()
{
	int a = (int)3.14;//若不转换，则会有一个警告：double转化为int，可能会丢失数据。
	printf("%d\n", a);

	return 0;
}

例题：sizeof和数组

问：

1. （1）和（2）两个地方的输出分别是多少？
2. （3）和（4）两个地方的输出分别是多少？

void test1(int arr[])
{
	printf("%d\n", sizeof(arr));// <2>

}
void test2(char ch[])
{
	printf("%d\n", sizeof(ch));// <4>

}
int main()
{
	int arr[10] = { 0 };
	int ch[10] = { 0 };
	printf("%d\n", sizeof(arr));// <1>
	printf("%d\n", 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位的二进制序列，所以地址的大小是固定的，指针变量不管是什么类型，它的大小都是那么大的。

8、关系操作符

注意：在编程过程中==和=不小心写错，导致的错误
? ? 比较两个字符串相等，不能使用==。可以通过引入头文件#include <string.h>，然后if(strcmp(str1, str2) == 0)语句判断。
? ? 即：通过strcmp进行比较两个字符串是否相同（逐个比较两个字符串中的对应位置的字符是否一致），如果都相同，则返回0。

9、逻辑操作符 && 和 ||

区分逻辑与和按位与? ? ? 区分逻辑或和按位或
&& 逻辑与
|| 逻辑或

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("hehe\n");
	}
	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 = %d\nb = %d\nc = %d\nd = %d\n", 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 = %d\nb = %d\nc = %d\nd = %d\n", 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 = %d\nb = %d\nc = %d\nd = %d\n", 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 = %d\nb = %d\nc = %d\nd = %d\n", 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。