C语言入门第五节：操作符详解

1、算术操作符

  +  -  *  /  %

2、移位操作符

移位操作符的操作数只能是整数

2.1 左移操作符

左边抛弃、右边补0

 

2.2 右移操作符 

首先右移运算分两种：

1. 逻辑右移

   左边用0填充，右边丢弃

2. 算数右移

   左边用原该值的符号位填充，右边丢弃

2.2.1 原码反码补码 

计算机中的整数有三种2进制表示方法，即原码、反码和补码。

三种表示方法均有符号位和数值位两部分，符号位用0表示“正”，1表示“负”。

int main()
{
	//正数的原码、反码和补码是相同的
	int a = 15;
	//00000000000000000000000000001111 - 原码
	//00000000000000000000000000001111 - 反码
	//00000000000000000000000000001111 - 补码

	int b = -15;
	//10000000000000000000000000001111 - 原码
	//11111111111111111111111111110000 - 反码（原码的符号位不变，其他位按位取反）
	//11111111111111111111111111110001 - 补码（反码加1）
	return 0;
}

整数在内存中存储的是补码
计算的时候也是使用补码计算的

 3、位操作符

& 按位与：有0则为0，两个同时为1，才为1
|  按位或：有1则为1，两个同时为0才是0
^ 按位异或：相同为0，相异为1
注：操作数必须是整数。

 我们拿3 | -5举例

int main()
{
	int a = 3;
	int b = -5;
	//00000000000000000000000000000011 - 3的补码
	//11111111111111111111111111111011 - -5的补码
	//11111111111111111111111111111011 - c的补码
	//11111111111111111111111111111010 - c的反码（补码-1）
	//10000000000000000000000000000101 - -5
	int c = a | b;
	printf("%d\n", c);
	return 0;
}

3的补码与5的补码按位或之后得到的不是直接结果，要把补码转成原码才是打印出来的结果

练习

不能创建临时变量（第三个变量），实现两个数的交换。

int main()
{
	int a = 3;
	int b = 5;
	a = a ^ b;
	b = a ^ b;//b=a^b^b=a
	a = a ^ b;//a=a^b^a^b^b=b
	printf("%d %d\n", a, b);

	return 0;
}

 编写代码实现：求一个整数存储在内存中的二进制中1的个数。

int main()
{
	int num = -1;
	int i = 0;
	int count = 0;
	for (i = 0; i < 32; i++)
	{
		if (num & (1 << i))
			count++;
	}
	printf("%d\n", count);
	return 0;
}

4、赋值操作符

+=        -=        *=        /=        %=        >>=        <<=        &=        |=        ^=

5、单目操作符

!                   逻辑反操作
-                   负值
+                  正值
&                  取地址
sizeof           操作数的类型长度（以字节为单位）
~                  对一个数的二进制按位取反
--                  前置、后置--
++                前置、后置++
*                   间接访问操作符(解引用操作符)
(类型)           强制类型转换 

 5.1 sizeof和数组

我们看下面一段代码，结果是什么？

void test1(int arr[])
{
	printf("%d\n", sizeof(arr));
}

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

int main()
{
	int arr[10] = { 0 };
	char ch[10] = { 0 };
	printf("%d\n", sizeof(arr));
	printf("%d\n", sizeof(ch));
	test1(arr);
	test2(ch);
	return 0;
}

40 10 4 4

当数组作为一个函数的参数传递时，它实际上是传递了数组首元素的地址，即指针，而不是整个数组的拷贝，所以test1和test2中sizeof计算出来的大小在32位平台下都是4字节。

 小知识点：

• 前置++先自增后使用
• 后置++先使用后增加

6、关系操作符

>        >=        <        <=        !=        ==      

7、逻辑操作符

&&     逻辑与
||        逻辑或

区分逻辑与按位与和逻辑或按位或 

1&2----->0
1&&2---->1
1|2----->3
1||2---->1

逻辑与操作符用于连接条件，仅当两个条件都为真（非0值）时，整个表达式的结果才为真（1）。

按位与操作符用于两个整数变量，它对这两个变量的每一个位（bit）执行AND操作。

看下面两段代码：

int main()
{
	int i = 0, a = 0, b = 2, c = 3, d = 4;
	i = a++ && ++b && d++;
	printf("a = %d\nb = %d\nc = %d\nd = %d\n", a, b, c, d);
	return 0;
}

int main()
{
	int i = 0, a = 0, b = 2, c = 3, d = 4;
	i = a++||++b||d++;
	printf("a = %d\nb = %d\nc = %d\nd = %d\n", a, b, c, d);
	return 0;
}

输出结果：1 2 3 4

输出结果：1 3 3 4

因为：

• &&操作符，左边为假，右边就不计算了
• ||操作符，左边为真，右边就不计算了

所以第一段代码a++先使用再增加，结果为0后面不会计算

第二段代码a++结果为0还会计算++b，前两个的逻辑或的结果为1就不会计算d++了

8、条件操作符

exp1 ? exp2 : exp3

exp1为真的话整个表达式的结果是exp2的结果，为假的话整个表达式的结果为exp3的结果。

9、逗号表达式

exp1, exp2, exp3, …expN

逗号表达式，就是用逗号隔开的多个表达式。

逗号表达式，从左向右依次执行。整个表达式的结果是最后一个表达式的结果。

10、下标引用、函数调用和结构成员

10.1 []下标引用操作符

int arr[10];        //创建数组
arr[9] = 10;      //使用下标引用操作符。
[ ]的两个操作数是arr和9。

10.2 ()函数调用操作符

void test1()
{
	printf("hello\n");
}

int main()
{
	test1();//()函数调用操作符。
	return 0;
}

10.3 访问结构的成员

• . 结构体.成员名
•  -> 结构体指针->成员名

struct stu
{
	char name[20];
	int age;
};

void Print(struct stu* p)
{
	printf("%s %d\n", p->name, p->age);
	printf("%s %d\n", (*p).name, (*p).age);
}

int main()
{
	struct stu s1 = { "lily",20 };
	struct stu s2 = { "mike",20 };
	Print(&s1);
	Print(&s2);
	return 0;
}

11、表达式求值

11.1 隐式类型转换

C的整型算术运算总是至少以缺省整型类型的精度来进行的。

为了获得这个精度，表达式中的字符和短整型操作数在使用之前被转换为普通整型，这种转换称为整型提升。

char a,b,c;
a = b + c;

b和c的值被提升为普通整型，然后再执行加法运算。

加法运算完成之后，结果将被截断，然后再存储于a中。

如何进行整型提升呢？

int main()
{
	//负数的整型提升
	char c1 = -1;
	//11111111 - 补码
	//char有符号，所以整型提升时高位补充符号位1
	//提升之后的结果为：
	//11111111111111111111111111111111

	//正数的整型提升
	char c2 = 1;
	//00000001 - 补码
	//char有符号，所以整型提升时高位补充符号位0
	//提升之后的结果为：
	//00000000000000000000000000000001
	return 0;
}

无符号整型提升，高位补0

证明整型提升确实存在的例子：

int main()
{
	char c = 1;
    //%u - 10进制的形式打印无符号的整数(unsigned int)
	printf("%u\n", sizeof(c));
	printf("%u\n", sizeof(+c));
	printf("%u\n", sizeof(-c));

	return 0;
}

输出结果：1 4 4

• c只要参与表达式运算,就会发生整型提升,表达式 +c ,就会发生提升。

11.2 算数转换

如果某个操作符的各个操作数属于不同的类型，那么除非其中一个操作数的转换为另一个操作数的类型，否则操作就无法进行。下面的层次体系称为寻常算术转换。

long double
double
float
unsigned long int
long int
unsigned int
int

如果某个操作数的类型在上面这个列表中排名较低，那么首先要转换为另外一个操作数的类型后执行运算。

11.3 操作符的属性

复杂表达式的求值有三个影响的因素。

1. 操作符的优先级

2. 操作符的结合性

3. 是否控制求值顺序。

操作符优先级：