[C语言]操作符

&: int a = 3; int b = 5; int c = a & b；——c = 1

0...011 0...101 ——> 0...001

|: int a = 3; int b = 5; int c = a | b；——c = 7

0...011 0...101 ——> 0...111

^: int a = 3; int b = 5; int c = a ^ b；——c = 6

0...011 0...101 ——> 0...110

特殊：a^a = 0 0^a = a

求一个整数存储在内存中的二进制中1的个数

//求一个整数存储在内存中的二进制中1的个数
int main()
{
	int num = 0;
	int a = 1;
	int b = 0;
	int count = 0;
	scanf("%d", &num);
	for (b = 1; b < 32; b++)
	{
		if ((num & a) == 1)
		{
			count++;
		}
		num = num >> 1;
	}
	
	printf("%d ", count);
	return 0;
}

4.赋值操作符

int weight = 120;//体重

weight = 89;//赋值

double salary = 10000.0;

salary = 20000.0;//使用赋值操作符赋值

复合赋值符

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

int x = 10;

x = x+10;

x += 10;//复合赋值

5.单目操作符（只有一个操作符）

! 逻辑反操作

- 负值

+ 正值

& 取地址

sizeof 操作数的类型长度（以字节为单位）

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

-- 前置、后置--

++ 前置、后置++

* 间接访问操作符(解引用操作符)

(类型) 强制类型转换

5.1 sizeof

sizeof——计算变量/类型所占内存大小，单位是字节

sizeof是一个操作符，不是函数

sizeof括号中的表达式不参与运算

#include <stdio.h>
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 };
	char ch[10] = { 0 };
	printf("%d\n", sizeof(arr));//(1)
	printf("%d\n", sizeof(ch));//(3)
	test1(arr);
	test2(ch);
	return 0;
}

为什么（4）的答案为4？

很容易觉得答案为10，但实际这里数组传参是首元素地址，那么求解ch的大小就是地址的大小，为4个字节

#include <stdio.h>
int i;
int main()
{
  i--;
  if(i>sizeof(i))
  {
    printf(">");
  }
   else
  {
    printf("<");
  }
 return 0;
}

判断以上代码输出什么？

输出“>”，因为sizeof这个操作符算出的结果是unsigned int

5.2 前置、后置++或--

后置++——先使用，后++

int a = 10; int b = a++;——b = 10,a = 9

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

int a = 10; int b = ++a;——b = 11,a = 11

5.3 ~按位取反 (所有位取反)

int a = -1;（负数存补码）1...1

int b = ~a;——b = 0; 0...0

5.4 &取地址操作符，*解引用操作符

int a = 10; int * pa = &a; *pa=20;——a=20

5.5 强制类型转换

int main()
{
    //强制类型转换
    int a = (int)3.14;
    printf("%d\n", a);
    return 0;
}

a = 3

6.关系操作符

< <= > >= == (相等) !=（不相等）

注：字符串比较用strcmp函数

7.逻辑操作符

&& 逻辑与

|| 逻辑或

int main()
{
    int i = 0, a = 0, b = 2, c = 3, d = 4;
    i = a++ && ++b && d++;
    //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

对于&&来讲，若第一个表达式为假，则无需进行后续计算

对于||来讲，若第一个表达式为真，则无需进行后续计算

8.条件操作符（三目操作符）

求两个数中的较大值：max = (a>b ? a : b);

9.逗号表达式

从左到右依次计算，结果是最后一个表达式

int a = 1;

int b = 2;

int c = (a>b, a=b+10, a, b=a+1);——c = 13

可以简化代码

a = get_val();

count_val(a);

while (a > 0)

{

//业务处理

a = get_val();

count_val(a);

}

如果使用逗号表达式，改写：

while (a = get_val(), count_val(a), a>0)

{

//业务处理

}

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

10.1 下标引用操作符

操作数：一个数组名 + 一个索引值

int arr[10];//创建数组

arr[9] = 10;//实用下标引用操作符。

[ ]的两个操作数是arr（数组名）和9（索引值）。

10.2 函数调用操作符

接受一个或者多个操作数：第一个操作数是函数名，剩余的操作数就是传递给函数的参数。

例如：Add(a,b)——Add（函数名），a、b(参数)

10.3 访问一个结构成员

. 结构体.成员名

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

//结构成员访问操作符
//书：书名，书号，定价

//创建一个自定义类型
struct Book
{
	//结构体的成员(变量)
	char name[20];
	char id[20];
	int price;
};
int main()
{
	struct Book b = {"C语言","C20220104",30};
	struct Book* pb = &b;
	
	//结构体指针->成员名
	printf("书名：%s\n",pb->name);
	printf("书号：%s\n", pb->id);
	printf("定价：%d\n", pb->price);
	
	//结构体变量名.成员名
	/*printf("书名：%s\n", b.name);
	printf("书号：%s\n", b.id);
	printf("定价：%d\n", b.price);*/
	return 0;
}

11.表达式求值

表达式求值的顺序一部分是由操作符的优先级和结合性决定。

同样，有些表达式的操作数在求值的过程中可能需要转换为其他类型。

11.1 隐式类型转换（*）

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

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

char类型、short类型（自身类型达不到整型大小），这些类型参与运算就会发生整型提升

整型提升的意义

表达式的整型运算要在CPU的相应运算器件内执行，CPU内整型运算器(ALU)的操作数的字节长度一般就是int的字节长度，同时也是CPU的通用寄存器的长度。

因此，即使两个char类型的相加，在CPU执行时实际上也要先转换为CPU内整型操作数的标准长度。

通用CPU是难以直接实现两个8比特字节直接相加运算（虽然机器指令中可能有这种字节相加指令）。所以，表达式中各种长度可能小于int长度的整型值，都必须先转换为int或unsigned int，然后才能送入CPU去执行运算。

如何进行整体提升呢？

整形提升是按照变量的数据类型的符号位来提升的

1.负数的整形提升

char c1 = -1;

变量c1的二进制位(补码)中只有8个比特位：

1111111

因为 char 为有符号的 char 所以整形提升的时候，高位补充符号位，即为1

提升之后的结果是： 11111111111111111111111111111111

2.正数的整形提升

char c2 = 1;

变量c2的二进制位(补码)中只有8个比特位：

00000001

因为 char 为有符号的 char

所以整形提升的时候，高位补充符号位，即为0

提升之后的结果是： 00000000000000000000000000000001

3.无符号整形提升，高位补0

例1 输出c = -126

注意存储的是补码，需判断正负，以确定原码的数值

int main()
{
	char a = 3;
	//00000000000000000000000000000011
	//00000011—— a
	
	char b = 127;
	//01111111—— b
	
	char c = a + b;
	//00000000000000000000000000000011
	//00000000000000000000000001111111
	//00000000000000000000000010000010
	//10000010—— c
	
	//11111111111111111111111110000010——补码(整型提升)
	//11111111111111111111111110000001——反码
	//10000000000000000000000001111110——原码
	//-126
	
	//发现a和b都是char类型，都没有达到一个int的大小
	//这里就会发生整型提升
	
	printf("%d\n", c);
	return 0;
}

例2 只会输出c

a和b发生整型提升，不再等于原来的值

int main()
{
	char a = 0xb6;
	short b = 0xb600;
	int c = 0xb6000000;
	if (a == 0xb6)
		printf("a");
	if (b == 0xb600)
		printf("b");
	if (c == 0xb6000000)
		printf("c");
	return 0;
}

例3 输出1 4 4

参与运算发生整型提升

int main()
{
	char c = 1;
	printf("%u\n", sizeof(c));
	printf("%u\n", sizeof(+c));//参与运算发生整型提升
	printf("%u\n", sizeof(-c));
	return 0;
}

11.2 算术转换

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

long double

double

float

unsigned long int

long int

unsigned int

int

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

例如：int a = 3; float f = 3.14 ; float b = f + a = 6.140000（此时a由int→float）

警告：但是算术转换要合理，要不然会有一些潜在的问题。

例如：float f = 3.14;

int num = f;——f=3,隐式转换，会有精度丢失

11.3 操作符的属性

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

1. 操作符的优先级

2. 操作符的结合性

3. 是否控制求值顺序

两个相邻的操作符先执行哪个？

取决于他们的优先级。如果两者的优先级相同，取决于他们的结合性

一些问题表达式

1.a*b + c*d + e*f——无法确定出唯一的计算顺序：代码1在计算的时候，由于*比+的优先级高，只能保证，*的计算是比+早，但是优先级并不能决定第三个*比第一个+早执行。

2.c + -- c——同上，操作符的优先级只能决定自减--的运算在+的运算的前面，但是我们并没有办法得知，+操作符的左操作数的获取在右操作数之前还是之后求值

若c = 3，那么前一个c可能取3，也可能取2

3.answer = fun() - fun() * fun()——我们只能通过操作符的优先级得知：先算乘法，再算减法。函数的调用先后顺序无法通过操作符的优先级确定

总结：写出的表达式如果不能通过操作符的属性确定唯一的计算路径，那这个表达式就是存在问题的。