手撕C语言初阶---操作符(超详解！值得收藏~)

目录

操作符和表达式

操作符

算数操作符

 移位操作符

位操作符

赋值操作符

复合赋值符

单目操作符

关系操作符

逻辑操作符

条件操作符

逗号表达式

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

表达式求值

隐式类型转换

算术转换

操作符的属性

---

操作符和表达式

本章重点

1. 各种操作符的介绍。
2. 表达式求值
 

操作符

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

算数操作符

+    -    *   /    %

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

例：

int main()
{
	printf("%d\n", 5 / 2);
	printf("%f\n", 5.0 / 2);
	return 0;
}

 

 移位操作符

<< 左移操作符
>> 右移操作符

左移操作符 移位规则：

左边抛弃、右边补0

右移操作符 移位规则：

首先右移运算分两种：
1. 逻辑移位 左边用0填充，右边丢弃
2. 算术移位 左边用原该值的符号位填充，右边丢弃

警告⚠： 对于移位运算符，不要移动负数位，这个是标准未定义的。

例如： 

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

位操作符
 

位(二进制位)操作符有：

& //按位与
| //按位或
^ //按位异或
注：他们的操作数必须是整数。

#include 
int main()
{
    int num1 = 1;
    int num2 = 2;
    num1 & num2;
    num1 | num2;
    num1 ^ num2;
    return 0;
}

&(按位与):有0为0，无0为1

 |(按位或):有1为1，无1为0

 ^(按位异或):相异为1，相同为0

 一道变态的面试题：

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

#include 
int main()
{
    int a = 10;
    int b = 20;
    a = a^b;
    b = a^b;
    a = a^b;
    printf("a = %d b = %d\n", a, b);
    return 0;
}

看到这个代码你的内心是否是这样？小朋友你是否有很多问号？？？？

 看到这张图你的心里是否有一些思路

首先 a = a^b,这一步相当于一个袋子，将a和b两个数装进袋子里，再将这个袋子给a。

然后 b = a^b,根据我们的口诀相异为1，相同为零，如果我们将袋子里的a和b看成两个二进制位的话，那么将这个袋子和b异或，那么b和b相同就为0了，这个时候袋子里就只剩下a了，再将剩下的a赋给b。

 最后 a = a^b,也是一样的道理，因为这个时候b是等于a的，那么将袋子和b异或，袋子里就只剩下b了，最后a就等于b了。

大家是否能够理解呢？有困惑也没关系，毕竟也是第一次见到这个，以后遇到的机会还有很多，经验是慢慢积累的。

这里给大家推荐一道关于按位与的算法题，看看你能否解决呢。

力扣---只出现一次的数字

练习：

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

有时在刷题中可能遇到类似的题目这里提供两种方法。

方法一：

思路：根据按位与的思想(有0为0，无0为1)，那么如果将这个数的每一位都与1相与就可判断，这个数的二进制位中有多少个1。

代码如下：

#include 
int main()
{
    int num = -1;
    int i = 0;
    int count = 0;//计数
    for(i=0; i<32; i++)//整形为32位
    {
        if( ((num>>i)&1) == 1 )//把每一位都放到第一位的位置与1按位与
        count++;
    }
    printf("二进制中1的个数 = %d\n",count);
    return 0;
}

方法二：

思路:

如图:

a = 10,如果我们将a-1，那么a的二进制位中最右边的第一个1(包括1)的右边的所有二进制肯定与a-1的对应位不相同，

如果将它们按位与，则这些位都应该位为0，这样一次就找出了一个为1的二进制位，循环下去直到a为0就可计算出a的二进制位中有多少个1。

//方法2：
#include 
int main()
{
    int num = -1;
    int i = 0;
    int count = 0;//计数
    while(num)
    {
         count++;
         num = num&(num-1);
    }
         printf("二进制中1的个数 = %d\n",count);
         return 0;
}
//这种方式是不是很好？达到了优化的效果，但是难以想到.

赋值操作符

赋值操作符是一个很棒的操作符，他可以让你得到一个你之前不满意的值。

也就是你可以给自己重新赋值。

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;//复合赋值
//其他运算符一样的道理。这样写更加简洁.

单目操作符
 

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

 这里的单目操作符的使用均以代码演示

int main()
{
    // ！逻辑反操作
    int a = 0;
    if (!a)//C语言中0为假，非0为真，这里使用逻辑反操作符后非0为真
    {
        printf("haha\n");
    }
    else
    {
        printf("hehe\n");
    }
    return 0;
}

负值和正值不再介绍

int main()
{
    //&取地址操作符
	int a = 10;
    int*pa = &a;//取出a的地址保存在指针变量pa中

	printf("%p", pa);
	return 0;
}

int main()
{
    //sizeof
	int a = 10;

	printf("%d\n", sizeof(a));//4
	printf("%d\n", sizeof(int));//4
    printf("%d\n", sizeof(a+1));//4 

	printf("%d\n", sizeof a);//这样写行不行？可以，sizeof不是函数所以可以不用括号
	printf("%d\n", sizeof int);//这样写行不行？不行，计算类型大小必须要括号

    int arr[10] = {1,2,3,4,5,6,7,8,9,10};

    printf("%d\n", sizeof(arr))//求整个数组的大小 40
    printf("%d\n", sizeof(arr[0]))//4

	return 0;
}

关于sizeof其实我们之前已经见过了，可以求变量（类型）所占空间的大小。

注：

sizeof 不是函数，函数需要用函数调用符号（），来调用，而 sizeof，是不需要调用符号也可以使用。
sizeof()，计算的是括号里面的变量或者类型的字节大小，与存放的数据无关；
sizeof(),括号内的表达式，不参与计算,括号内的表达式在编译阶段就已经定好了。

ps:强调一下sizeof(arr)表示求整个数组的大小；而sizeof(&arr)是求整个数组的地址的大小，既然是地址在32机器下大小都为4，在64位机器下大小都为8！

另外:只有在sizeof(arr)和&arr时，数组名才表示整个数组，其他情况下数组名均表示数组首元素的地址！！！

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

关系操作符

关系操作符
>
>=
<
<=
!= 用于测试“不相等”
== 用于测试“相等”
 

这些关系运算符比较简单，没什么可讲的，但是我们要注意一些运算符使用时候的陷阱。
警告： 在编程的过程中== 和=不小心写错，导致的错误。

例如：

#include
int main()
{
	int a = 10;
	if (a = 10)//使用了=，条件恒成立
	{
		printf("haha\n");
	}
	else
	{
		printf("hehe\n");
	}
	return 0;
}

逻辑操作符

逻辑操作符有哪些：

&& 逻辑与
|| 逻辑或

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

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

&&：两边表达式都为真，结果为真

||：两边表达式中有一个为真，结果就为真

ps：&&和||有“短路”功能

如果&&中第一个表达式为假，则结果为假且第二个表达式不会计算。

如果||中第一个表达式为真，则结果为真且第二个表达式不会计算。

#include
int main()
{
	int a = 0, b = 1;
	int c = a && ++b;//a为0表达式为假，++b不会计算
	printf("a = %d, b = %d, c = %d\n", a, b, c);
    return 0;
}

 

#include
int main()
{
	int a = 0, b = 1;
	int d = ++a || ++b;//++a为1，表达式为真，++b不会计算
	printf("a = %d, b = %d, d = %d\n ", a, b, d);
	return 0;
}

 练习：360笔试题

#include 
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;
}
    //程序输出的结果是什么？

条件操作符

exp1 ? exp2 : exp3

这个是一个三目操作符：先计算exp1，如果表达式为真，则结果为exp2；否则结果为exp3。

例如：

int main()
{
	int a = 10;
	int b = 20;
	int c = a > 20 ? a : b;//将a和b中的较大值放进c中
	printf("%d\n", c);
	return 0;
}

逗号表达式
 

exp1, exp2, exp3, …expN

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

逗号表达式，从左向右依次执行。

整个表达式的结果是最后一个表达式的结果。
 

//代码1
int a = 1;
int b = 2;
int c = (a>b, a=b+10, a, b=a+1);//逗号表达式
//c是多少？
//代码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)
{
    //业务处理
}

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

1.[ ] 下标引用操作符
操作数：一个数组名 + 一个索引值

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

2.( ) 函数调用操作符 接受一个或者多个操作数：第一个操作数是函数名，剩余的操作数就是传递给函数的参数。
 

#include 
void test1()
{
printf("hehe\n");
}
void test2(const char *str)
{
    printf("%s\n", str);
}
int main()
{
    test1(); //实用（）作为函数调用操作符。
    test2("hello bit.");//实用（）作为函数调用操作符。
    return 0;
}

3.访问一个结构的成员
 

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

#include 
struct Stu//创建结构体
{
    char name[10];
    int age;
    char sex[5];
    double score;
}；
void set_age1(struct Stu stu)
{
    stu.age = 18;
}
void set_age2(struct Stu* pStu)
{
    pStu->age = 18;//结构成员访问
}
int main()
{
    struct Stu stu;
    struct Stu* pStu = &stu;//结构成员访问
    stu.age = 20;//结构成员访问
    set_age1(stu);
    pStu->age = 20;//结构成员访问
    set_age2(pStu);
    return 0;
}

表达式求值
 

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

隐式类型转换
 

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

//实例1
char a,b,c;
...
a = b + c;

b和c的值被提升为普通整型，然后再执行加法运算。
加法运算完成之后，结果将被截断，然后再存储于a中。

如何进行整体提升呢？

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

//负数的整形提升
char c1 = -1;
变量c1的二进制位(补码)中只有8个比特位：
1111111
因为 char 为有符号的 char
所以整形提升的时候，高位补充符号位，即为1
提升之后的结果是：
11111111111111111111111111111111
//正数的整形提升
char c2 = 1;
变量c2的二进制位(补码)中只有8个比特位：
00000001
因为 char 为有符号的 char
所以整形提升的时候，高位补充符号位，即为0
提升之后的结果是：
00000000000000000000000000000001

//无符号整形提升，高位补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

//实例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个字节。
 

算术转换
 

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

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

如果某个操作数的类型在上面这个列表中排名较低，那么首先要转换为另外一个操作数的类型后执行运算。
警告： 但是算术转换要合理，要不然会有一些潜在的问题。

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

操作符的属性
 

复杂表达式的求值有三个影响的因素。
1. 操作符的优先级
2. 操作符的结合性
3. 是否控制求值顺序。
两个相邻的操作符先执行哪个？取决于他们的优先级。如果两者的优先级相同，取决于他们的结合性。
操作符优先级

当然这个也不需要死记硬背，要在刷题中多多理解加深记忆即可。

一些问题表达式

//表达式的求值部分由操作符的优先级决定。
//表达式1
a*b + c*d + e*f

注释：代码1在计算的时候，由于比+的优先级高，只能保证，的计算是比+早，但是优先级并不
能决定第三个*比第一个+早执行。

所以表达式的计算机顺序就可能是：
 

a*b
c*d
a*b + c*d
e*f
a*b + c*d + e*f
或者：
a*b
c*d
e*f
a*b + c*d
a*b + c*d + e*f

//表达式2
c + --c;

注释：同上，操作符的优先级只能决定自减--的运算在+的运算的前面，但是我们并没有办法得
知，+操作符的左操作数的获取在右操作数之前还是之后求值，所以结果是不可预测的，是有歧义
的。
 

//代码3-非法表达式
int main()
{
    int i = 10;
    i = i-- - --i * ( i = -3 ) * i++ + ++i;
    printf("i = %d\n", i);
    return 0;
}

这个代码是不是看着就很恶心~

表达式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(); 中我们只能通过操作符的优先级得知：先算乘法，再算减法。
函数的调用先后顺序无法通过操作符的优先级确定！

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

所以我们在写代码时一定不要写出这样的代码。

本章完~是不是干货满满呢，关注我带你学习更多编程知识