操作符详解

操作符的分类

算术操作符
移位操作符
位操作符
赋值操作符
单目操作符
关系操作符
逻辑操作符
条件操作符
逗号表达式
下标引用、函数调用和结构成员

算术操作符

  +    -   *   /   %

1. 除了 % 操作符之外，其他的几个操作符可以作用于整数和浮点数。
2. 对于 / 操作符如果两个操作数都为整数，执行整数除法。而只要有浮点数执行的就是浮点数除法。
3. % 操作符的两个操作数必须为整数。返回的是整除之后的余数

移位操作符

操作二进制位，左移右移操作的是内存中二进制补码，不改变变量本身，打印出来的是原码，右移分两种，算术右移（补符号位）和逻辑右移（补0），位操作符是双目操作符，异或可以实现两个整数的交换

a^a=0
a^0=a

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

int main()
{
	int a = 3;
	int b = 5;

	printf("a=%d b=%d\n", a, b);
	//创建临时变量
	//int tmp = a;
	//a = b;
	//b = tmp;
	
	//不创建临时变量，但可能会溢出
	//a = a + b;
	//b = a - b;
	//a = a - b;

	a = a ^ b;
	b = a ^ b;
	a = a ^ b;

	printf("a=%d b=%d\n", a, b);

	return 0;
}

编写代码，求一个整数存储在内存中的二进制中1的个数。 解析，5的二进制表示为
00000000000000000000000000000101，和
00000000000000000000000000000001按位与，最右边是几结果就是几，算出来之后，把5右移，进行32次循环，相当于每一位都计算一下就可以得出结果
（num>>i&1)==1 i=0,1,2…

#include <stdio.h>

int main()
{
	int num = 0;
	scanf("%d", &num);
	int i = 0;
	int count = 0;

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

	return 0;
}

赋值操作符

支持连续赋值，但可读性不好

//复合赋值符，赋值给自己

int main()
{
	int a = 10;
	a = a + 2;
	a += 2;

	a = a >> 1;
	a >>= 1;

	a = a & 4;
	a &= 4;

	return 0;
}

C99后引入Bool类型，#Stdbool.h 返回true或者false
取地址&，只要对象在内存中开空间就能取到地址，对变量，结构体，数组，函数都可以取地址
struct S s={0};
struct S* s=&s;
*解引用，间接访问操作符，*pa=a； *&a==a;
单目，逻辑反，if(!num){}代表num为假则进入
sizeof（） 的用法，占内存空间的大小，（）可以省略，代表这是运算符，不是函数，sizeof(),()中的表达式不参与计算

int a=10;
short s=0;
sizeof(s=a+2);

a为整型，4byte，short为短整型，2byte，不需要计算，直接得出结果就是2byte，编译期间，直接把sizeof（）中的值替换，不会去计算值
~会把所有二进制位取反，例如a=0; ~a=-1;

	int a = 11;
	//00000000000000000000000000001111
	//11111111111111111111111111111011
	//00000000000000000000000000000100
	//1<<2
	a |= (1<<2);
	printf("%d\n", a);//15
	
	a &= (~(1 << 2));
	printf("%d\n", a);//11
	//a一开始是11，后来变成了15，再恢复为11

(类型)，强转，不推荐

while(scanf("%d",&n)!=EOF)
//EOF为-1，~（-1）为全0，scanf读取失败会返回EOF,所以另一种终止循环的方式为while(~scanf("%d",&n))，全0进不去

如果直接比较两个字符串，比较的是地址，只有strcmp才能比较字符串的大小 char
arr[]=“abcdef”,用常量字符串初始化这个数组，但实际上这个常量字符串是不存在的 char
*p=“abcdef”,p是指向这个常量字符串的地址，这个字符串存在于常量区

笔试题

#include <stdio.h>
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\nd = %d\n", a, b, c, d);
    return 0;
}
//程序输出的结果是什么？

注：&&左边表达式为假的话右边就不算了，，但a的自增是要算的 ||左边的表达式为真，右边就不算了

条件（三目）操作符

逗号表达式 从左到右，结果为最后一个表达式的结果

a = get_val();
count_val(a);
while (a > 0)
{
      //业务处理
        a = get_val();
        count_val(a);
}
如果使用逗号表达式，改写：
while (a = get_val(), count_val(a), a>0)
{
         //业务处理
}

下标引用操作符

arr[4]和*（arr+4）是一样的
*（arr+4）<==> *(4+arr) <==> 4[arr]
//说明 []就是一个操作符，arr和4都是操作数

函数调用操作符（）

int Add(int x,int y)
{}
int main()
{
Add(2,3);
}
//()为函数调用操作符，操作数为Add，2，3

访问一个结构的成员

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

struct Stu
{
 char name[10];
 int age;
 char sex[5];
 double score;
 }
 struct stu S={"zhang",20,90.5f}
 1.函数调用，传结构体，结构体接收，struct Stu ss
 ss.name;//访问
 2.传指针，指针接收，struct Stu* ps
 (*ps).name;//访问
 ps->name;
 //修改
 s.name="li";//err
 name是数组名，数组名是地址，地址是编号，编号是常量值，常量值不可以修改
 修改指针指向的空间的数据
 strcmp(s.name,"li");//给出首元素的地址
 *（s.name）也是错误写法，这样只能访问一个字符
 scanf("%s",s.name); 

操作符：将数值变量有机组合成表达式
按照顺序，优先级，结合性，隐式类型转换

隐式类型转换

C的整型算术运算总是至少以缺省整型类型的精度来进行的。
为了获得这个精度，表达式中的字符和短整型操作数在使用之前被转换为普通整型，这种转换称为整型提升

整型提升的意义：
表达式的整型运算要在CPU的相应运算器件内执行，CPU内整型运算器(ALU)的操作数的字节长度
一般就是int的字节长度，同时也是CPU的通用寄存器的长度。
因此，即使两个char类型的相加，在CPU执行时实际上也要先转换为CPU内整型操作数的标准长
度。
通用CPU（general-purpose CPU）是难以直接实现两个8比特字节直接相加运算（虽然机器指令
中可能有这种字节相加指令）。所以，表达式中各种长度可能小于int长度的整型值，都必须先转
换为int或unsigned int，然后才能送入CPU去执行运算

int main()
{
char c1=3;
char c2=127;
char c3=c1+c2;
printf("%d",c3);
c3=?

分析过程：
3的二进制序列为00000000000000000000000000000011
截断后放入c1中为00000011
127的二进制序列000000000000000000000000011111111
截断后放入c2中为011111111
char c3=c1+c2
在计算时要把c1和c2提升成整型
c1有符号，符号位补0
c2有符号，符号位补0
00000000000000000000000000000011
000000000000000000000000011111111
00000000000000000000000010000010 c3
截断后为10000010（补码）
执行打印%d是以整型打印，需要对c3整型提升，高位补1符号位
11111111111111111111111111110000010 补码
10000000000000000000000001111110 原码
打印出来是-126

//实例1
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;
}
将0xb6赋值给a，10110110提升成1111...10110110

实例1中的a,b要进行整形提升,但是c不需要整形提升
a,b整形提升之后,变成了负数,所以表达式 a0xb6 , b0xb600 的结果是假,但是c不发生整形提升,则表达式 c==0xb6000000 的结果是真.
所程序输出的结果是
c

sizeof(c);  //1
sizeof(+c);  //4
sizeof(-c);  //4
printf("%u",...)
反应了+/-使c发生了整型提升

算术转换

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

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

操作符的属性

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

1. 操作符的优先级（相邻操作符）
2. 操作符的结合性 （相邻操作符优先级一样时考虑结合性）
3. 是否控制求值顺序。
4. 注：&&和||和？ ：和，都会影响结合顺序

问题代码，函数调用顺序不明确

int fun()
{
     static int count = 1;
     return ++count;
}
int main()
{
     int answer;
     answer = fun() - fun() * fun();
     printf( "%d\n", answer);//输出多少？
     return 0;
}

虽然在大多数的编译器上求得结果都是相同的。 但是上述代码 answer = fun() - fun() * fun();
中我们只能通过操作符的优先级得知：先算乘法， 再算减法。 函数的调用先后顺序无法通过操作符的优先级确定。

//代码5
#include <stdio.h>
int main()
{
 int i = 1;
 int ret = (++i) + (++i) + (++i);
 printf("%d\n", ret);
 printf("%d\n", i);
 return 0;
}