操作符(operator)

操作符：：

操作符分类

1.算术操作符

2.移位操作符

操作符：：

操作符分类

1.算术操作符

算术操作符：用于处理四则运算。

1.除了%操作符外，其他的几个操作符都可以作用于整数和浮点数，%操作符只能作用于整数。

2.对于/操作符如果两个操作数都为整数，执行整数除法，而只要有浮点数执行的就是浮点数除法。

3.%操作符的两个操作数必须为整数，返回的是整除之后的余数。

2.移位操作符

左移操作符：<<

注：移位操作符的操作数只能是整数。

移位规则：左边抛弃，右边补0

性质：向左移几位结果就翻几倍，乘几个2，如x<<1 = x*2 x<<2 = x*4

右移操作符：>>

移位规则：

1.逻辑移位：右边丢弃，左边补0.

2.算术移位：右边丢弃，左边用该值的符号位补充

右移操作符对于正整数来说，右移一位相当于除以2，x>>1 = x/2 x>>2=x/4

注:绝大多数编译器都采用算术移位的原因：

逻辑移位对于负数右边舍弃左边补0 补码转化为原码负数转化为正数不合实际

警告：对于移位操作符，不要移动负数位，这个是标准未定义的。同时浮点数不支持左移右移

注：移位移的是补码，最终结果变原码


int num = 10;
num >> -1;error

3.位操作符

规则：

&---按位(二进制)位与全1为1 不是全1就是0 (补码包括符号位)
|---按位(二进制)位或全0为0 不是全0就是1 (补码包括符号位)
^---按(二进制)位异或相同为0 相异为1 (补码包括符号位)

性质:

1.按位与的性质：a&1的结果的最低位是什么，a的最后一位就是什么

n=n&(n-1),每进行一次就让最右边的1去掉一个直到变成全0

2.按位或的性质：将1左移n-1位后按位或上去原序列的那一位就变成1

3.按位异或的性质：(1)a^a=0 (2)0^a=a (3)按位异或满足交换律

4.按位取反的性质：将1左移n-1位后按位取反再按位与上去原序列的那一位就变成0

注：它们的操作数必须是整数。

面试题：不创建临时变量(第三个变量)，实现两个数的交换


//创建第三方变量
int main()
{
	int a = 3;
	int b = 5;
	int temp = 0;
	printf("交换前：a=%d b=%d\n", a, b);
	temp = a;
	a = b;
	b = temp;
	printf("交换后：a=%d b=%d\n", a, b);
	return 0;
}
//方法一：
int main()
{
	int a = 3;
	int b = 5;
  //这种方法会有溢出的问题
	printf("交换前：a=%d b=%d\n", a, b);
	a = a + b;
	b = a - b;
	a = a - b;
	printf("交换后：a=%d b=%d\n", a, b);
	return 0;
}
//方法二：
int main()
{
	int a = 3;
	int b = 5;
	printf("交换前：a=%d b=%d\n", a, b);
	a = a ^ b;//a=3^5
	b = a ^ b;//3^5^5 --> b=3
	a = a ^ b;//3^5^3 --> a=5
	printf("交换后：a=%d b=%d\n", a, b);
	return 0;
}

4.赋值操作符


int weight = 120;//体重
weight = 89;//不满意就赋值
double salary = 10000.0;
salary = 20000.0;//使用赋值操作符赋值
//赋值操作符可以连续使用
int a = 10;
int x = 0;
int y = 20;
a = x = y + 1;//连续赋值但不推荐
//同样的语义
x = y + 1;
a = x;
//这样的写法更加清晰而且易于调试
int x = 10;
x = x + 10;
x += 10;
//其他运算符一样的道理 这样写更简洁

5.单目操作符


#include
int main()
{
	int a = -10;
	int* p = NULL;
	printf("%d\n", !2);
	printf("%d\n", !0);
	a = -a;
	p = &a;
	printf("%d\n", sizeof(a));
	printf("%d\n", sizeof(int));
	printf("%d\n", sizeof a);//ok
	printf("%d\n", sizeof int);//err
	return 0;
}
#include 
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;
}
//程序(1) (2) (3) (4)的输出结果分别为 40 4 10 4
//补充：&是升维度的 *是降维度的


#include 
//++和--运算符
//前置++和--
int main()
{
    int a = 10;
    int x = ++a;
    //先对a进行自增，然后对使用a，也就是表达式的值是a自增之后的值。x为11。
    int y = --a;
    //先对a进行自减，然后对使用a，也就是表达式的值是a自减之后的值。y为10;
    return 0; 
}
//后置++和--
int main()
{
    int a = 10;
    int x = a++;
    //先对a先使用，再增加，这样x的值是10；之后a变成11；
    int y = a--;
    //先对a先使用，再自减，这样y的值是11；之后a变成10；
    return 0; 
}
//强制类型转换
time_t; long long
srand((unsigned int)time(NULL));

注：对于内置类型，前置++和后置++没啥区别，但C++对于自定义类型会有区别，而且后置++的优先级比前置++的高

注：ASCII码值的取值范围是0—127

两道操作符经典的计算题


#include 
int main()
{
	int a, b, c;
	a = 5;
	c = ++a;
	b = ++c, c++, ++a, a++;
	b += a++ + c;
	printf("a = %d b = %d c = %d\n", a, b, c);
	return 0;
}
//程序运行结果为：a=9,b=23,c=8 逗号表达式的优先级是最低的 比赋值操作符还要低
#include 
int main()
{
    int i = 1;
    int ret = (++i)+(++i)+(++i);
    printf("ret = %d\n", ret);
	return 0;
}
//程序运行错误 在不同的编译器结果可能是10或12

6.关系操作符

警告：在编程的过程中==和=不小心写错导致的错误。


#include
int main()
{
	if (3 == 5)
	{
		printf("haha\n");
	}
	//两个字符串比较相等应该使用strcmp
	if ("abc" == "abcdef") //err 这样写是在比较2个字符串的首字符的地址
	{
        printf("hehe\n");
	}
	return 0;
}

7.逻辑操作符

规则：逻辑与：全真为真不是全真就是假的

逻辑或：全假为假不是全假就是真的

特点：逻辑与和逻辑或可以控制求值顺序，一定程度上不受优先级的影响

逻辑与：只要表达式左边为假则整体为假

逻辑或：只要表达式左边为真则整体为真

区分逻辑与和按位与

区分逻辑或和按位或


//1&2-------->0
//1&&2------->1
 
//1|2-------->3
//1||2------->1
//逻辑与和逻辑或的应用
int is_leap_year(int y)
{
	if (((y % 4 == 0) && (y % 100 != 0)) || (y % 400 == 0))
	{
		return 1;
	}
	else
	{
		return 0;
	}
}

360笔试题


#include 
//&& 左边为假，右边就不计算了
//|| 左边为真，右边就不计算了
int main()
{
    int i = 0,a=0,b=2,c =3,d=4;
    i = a++ && ++b && d++;
    printf("a = %d b = %d c = %d d = %d\n", a, b, c, d);
    return 0; 
}
//程序输出的结果是1 2 3 4
#include 
int main()
{
    int i = 0,a=1,b=2,c =3,d=4;
    i = a++ && ++b && d++;
    printf("a = %d b = %d c = %d d = %d\n", a, b, c, d);
    return 0; 
}
//程序输出的结果是2 3 3 5
#include 
int main()
{
    int i = 0,a=1,b=2,c =3,d=4;
    i = a++||++b||d++;
    printf("a = %d b = %d c = %d d = %d\n", a, b, c, d);
    return 0; 
}
//程序输出的结果是2 2 3 4
#include 
int main()
{
    int i = 0,a=0,b=2,c =3,d=4;
    i = a++||++b||d++;
    printf("a = %d b = %d c = %d d = %d\n", a, b, c, d);
    return 0; 
}
//程序输出的结果是1 3 3 4

8.条件操作符


//1.if(a > 5)
//        b=3;
//  else
//        b=-3;
//转换成条件表达式 (a > 5) ? (b = 3) : (b = -3);
//简化成 b = (a > 5 ? 3 : -3);
//2.使用条件表达式求两个数中较大值
//int max = (a > b ? a : b);

9.逗号表达式

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


//代码1
int a = 1;
int b = 2;
int c = (a>b, a=b+10, a, b=a+1);
//代码2
if(a=b+1, c=a/2, d>0)
//代码3  
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.下标引用，函数调用和结构成员

1.[] 下标引用操作符

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

注：定义数组时数组的两个操作数不可以交换，访问时才可以。

2.() 函数调用操作符

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

3.访问一个结构体成员

. 结构体变量 . 成员名

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


#include 
 
struct Stu
{
	char name[20];
	int age;
	double score;
};
 
void set_stu(struct Stu* ps)
{
	strcpy((*ps).name, "zhangsan");
	(*ps).age = 20;
	(*ps).score = 100.0;
 
	strcpy(ps->name, "zhangsan");
	ps->age = 20;
	ps->score = 100.0;
}
 
void print_stu(struct Stu* ps)
{
	printf("%s %d %lf\n", ps->name, ps->age, ps->score);
}
 
int main()
{
	struct Stu s = {0};
	set_stu(&s);//此处不可以传值调用
	print_stu(&s);
	return 0;
}

11.表达式求值

表达式求值的顺序一部分是由操作符的优先级和结合性决定。同样，有些表达式的操作数在求值的过程中可能需要转化为其他类型。

隐式类型转换：

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

理解整型提升的口诀：存储是截断截断的是补码运算才是整型提升

整型提升的意义：

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


//实例1
char a,b,c;
...
a = b + c;
//b和c的值被提升为普通整型，然后再执行加法运算。
//加法运算完成之后，结果将被截断，然后再存储于a中。

如何进行整型提升？

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


//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还是补0看的是符号位

整型提升的例子：


//实例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; 
}
//实例1中的a,b要进行整形提升,但是c不需要整形提升
//a,b整形提升之后,变成了负数,所以表达式 a==0xb6 , b==0xb600 的结果是假,但是c不发生整形提升,则表
//达式 c==0xb6000000 的结果是真.
//所程序输出的结果是:c（改成无符号类型 a,b,c全输出）
//实例2
int main()
{
     char c = 1;
     printf("%u\n", sizeof(c));
     printf("%u\n", sizeof(+c));
     printf("%u\n", sizeof(-c));
     return 0;
}
//实例2中的,c只要参与表达式运算,就会发生整形提升,表达式 +c ,就会发生提升,所以 sizeof(+c) 是4个字节.表达式 -c 也会发生整形提升,所以 sizeof(-c) 是4个字节,但是 sizeof(c) ,就是1个字节

算术转换

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

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

注：算术转换只是类型发生了变化，原反补码该是什么还是什么

注：printf %u打印的是无符号数，认为内存中(补码)存的是无符号数，原反补相同(无符号数的原码反码补码相同)

一道经典算术转换题目


//下列代码的输出结果:
#include 
int i;
int main()
{
    i--;
    if (i > sizeof(i))
    {
        printf(">\n");
    }
    else
    {
        printf("<\n");
    }
    return 0; 
}
//程序运行结果是：>
//sizeof这个操作符计算返回值类型是size_t类型的 当有符号数和无符号数进行比较会进行算术转换 
//有符号数提升为无符号数 是一个非常大的正数 输出大于号
//只要是表达式 有不同类型的数据 最终一定会进行转换 类型大小小于整型进行整型提升 
//类型大小大于整型进行算术转换

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


float f = 3.14;
int num = f;//隐式转换，会有精度丢失

操作符的属性：

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

1.操作符的优先级 2.操作符的结合性 3.是否控制求值顺序

两个相邻的操作符先执行哪个取决于他们的优先级。如果两者的优先级相同，取决于他们的结合性

一些问题表达式：


//表达式1 a*b + c*d + e*f
//注释：代码1在计算的时候，由于*比+的优先级高，只能保证，*的计算是比+早，但是优先级并不
//能决定第三个*比第一个+早执行。
//1.a*b 2.c*d 3.a*b + c*d 4.e*f 5.a*b + c*d + e*f
//或者
//1.a*b 2.c*d 3.e*f 4.a*b + c*d 5.a*b + c*d + e*f
//表达式2 c + --c;
//注释：同上，操作符的优先级只能决定自减--的运算在+的运算的前面，但是我们并没有办法得
//知，+操作符的左操作数(c)的获取在右操作数(--c)之前还是之后求值，所以结果是不可预测的
//表达式3
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(); 
//我们只能通过操作符的优先级得知：
//先算乘法，再算减法。函数的调用先后顺序无法通过操作符的优先级确定。