C语言之操作符

目录

[1. 操作符的分类](#1. 操作符的分类)

[2. 移位操作符](#2. 移位操作符)

[2.1 左移操作符 <<](#2.1 左移操作符 <<)

[2.2 右移操作符 >>](#2.2 右移操作符 >>)

[3. 位操作符](#3. 位操作符)

[3.1 按位与 &](#3.1 按位与 &)

[3.2 按位或 |](#3.2 按位或 |)

[3.3 按位异或 ^](#3.3 按位异或 ^)

[3.4 按位取反 ~](#3.4 按位取反 ~)

[3.5 例题](#3.5 例题)

[3.5.1 按位异或 ^ 拓展公式](#3.5.1 按位异或 ^ 拓展公式)

[3.5.2 不能创建临时变量（第三个变量），实现两个整数的交换。](#3.5.2 不能创建临时变量（第三个变量），实现两个整数的交换。)

[3.5.3 编写代码实现：求⼀个整数n存储在内存中的二进制中1的个数。](#3.5.3 编写代码实现：求⼀个整数n存储在内存中的二进制中1的个数。)

[3.5.4 整数内存二进制位置1或置0](#3.5.4 整数内存二进制位置1或置0)

[4. 逗号表达式](#4. 逗号表达式)

[5. 下标引用[ ]和函数调用 ()](#5. 下标引用[ ]和函数调用 ())

[5.1 下标引用操作符[ ]](#5.1 下标引用操作符[ ])

[5.2 函数调用操作符 ()](#5.2 函数调用操作符 ())

[6. 结构成员访问操作符 . ->](#6. 结构成员访问操作符 . ->)

[6.1 结构体](#6.1 结构体)

[6.1.1 结构体的声明](#6.1.1 结构体的声明)

[6.1.2 结构体变量的定义和初始化](#6.1.2 结构体变量的定义和初始化)

[6.2 结构成员访问操作符](#6.2 结构成员访问操作符)

[6.2.1 结构成员的直接访问](#6.2.1 结构成员的直接访问)

[6.2.2 结构体成员的间接访问](#6.2.2 结构体成员的间接访问)

[7. 操作符的属性：优先级、结合性](#7. 操作符的属性：优先级、结合性)

[7.1 优先级](#7.1 优先级)

[7.2 结合性](#7.2 结合性)

[8. 表达式求值](#8. 表达式求值)

[8.1 整型提升](#8.1 整型提升)

[8.2 算数转换](#8.2 算数转换)

[8.3 总结](#8.3 总结)

---

1. 操作符的分类

• 算术操作符：+ ，- ，* ，/ ，%
• 移位操作符：<< ，>>
• 位操作符：& ，| ，^
• 赋值操作符：= ，+= ，-= ，*= ，/= ，%= ，<<= ，>>= ，&= ，|= ，^=
• 单目操作符：！，++ ，-- ，&(取地址符）, *(指针) , ~ ，+(正号) ，-(负号) , sizeof
• 逻辑操作符：&& ，|| ，！
• 条件操作符：？，:
• 逗号操作符：,
• 下标引用：[ ]
• 函数调用：( )
• 结构成员访问：. ` ->

2. 移位操作符

移位操作符的操作数只能是整数，操作对象是整数在内存中存储的二进制补码，移位的是二进制位。

2.1 左移操作符 <<

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

#include <stdio.h>
int main()
{
	int a = 5;
	int b = a << 1;
	printf("%d\n", a);
	printf("%d\n", b);
	return 0;
}

a的值经过左移1位，a的值不变，把左移1位的值赋给b，此时a=5 ,b=10。

2.2 右移操作符 >>

移位规则：右移运算分为两种：

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

2.算数右移：右边抛弃，左边用原来的值的符号位填充

#include <stdio.h>
int main()
{
	int a = -5;
	int b = a >> 1;
	printf("%d\n", a);
	printf("%d\n", b);
	return 0;
}

a的值经过右移1位，a的值不变，把右移1位的值赋给b，此时a=-5 ,b=-3。

大多数编译器都是算术右移。

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

3. 位操作符

移位操作符的操作数只能是整数，操作对象是整数在内存中存储的二进制补码。

#include <stdio.h>
int main()
{
	int a = 3;
	int b = -5;
	printf("%d\n", a & b);
    printf("%d\n", a | b);
    printf("%d\n", a ^ b);
	return 0;
}

下面是a和b的原码，反码和补码。

3.1 按位与 &

运算规则：两个整数& ，内存中的补码对应的二进制位进行&，有0为0，全1为1。

a & b = 3

3.2 按位或 |

运算规则：两个整数| ，内存中的补码对应的二进制位进行|，有1为1，全0为0。

a | b = -5

3.3 按位异或 ^

运算规则：两个整数^ ，内存中的补码对应的二进制位进行^，相同为0，不同为1。

a ^ b = -8

3.4 按位取反 ~

运算规则：内存中二进制补码按位取反，0变成1，1变成0。

#include <stdio.h>
int main()
{
	int a = 0;
	int b = ~a;
	printf("%d\n", b);
	return 0;
}

b = -1

3.5 例题

3.5.1 按位异或 ^ 拓展公式

异或 ^ 运算规则: 相同为0，不同为1。

a ^ a = 0 0 ^ a = a a ^ a ^ b =a ^ b ^ a （满足交换律）

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

方法1：创建第三个变量，交换，不符合题意。

#include <stdio.h>
int main()
{
	int a = 1;
	int b = 2;
	int c = 0;
	printf("交换前 a=%d b=%d\n", a, b);
	c = a;
	a = b;
	b = c;
	printf("交换后 a=%d b=%d\n", a, b);
	return 0;
}

方法2：a = a + b; b = a - b; a = a - b; 这种方法虽说可以完成运算，但是如果a 和 b 两个数很大，加起来就有可能超出整型的存储范围，存在数据溢出风险。

#include <stdio.h>
int main()
{
	int a = 1;
	int b = 2;
	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;
}

方法3：a = a ^ b; b = a ^ b; a = a ^ b;这种方法就不会存在数据溢出的情况。

#include <stdio.h>
int main()
{
	int a = 1;
	int b = 2;
	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;
}

但如果不是题目要求不能创建第三个变量，我们最多还是使用第一种方法，第三种方法不容易理解，且效率没有第一种方法高。

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

方法1： 循环求出内存中存储的补码二进制的每一位，看是不是1，是1就加1，不是1不加，最后直到这个数等于0，停止循环。此方法对负数不适用。

为什么对负数不适用呢？

这种方法的本质上是将n /= 2当成n >>= 1，右移一位的本质是除以2，向下取整，相当于把n在内存中存储的二进制补码每一位都依次右移到最后一位，然后 % 2，取最后一位数看是不是1。

但是如果要把n /= 2当成n >>= 1，也要分情况来看，

当n是无符号整型时，右移是逻辑右移，左边直接补0，并且向下取整，等效于n/2 。

当n是有符号整型时，右移是算术右移，左边要补符号位，

n为非负数时，左边补0，等效于n/2，

n为负数时，左边补1，当n等于偶数时，等效于n/2，当n等于奇数时，n>>1相当于除以2并向下取整，-7>>1 = -4, -7 / 2 = -3 , 右移是向下取整，除法是取整接近0的数，两值不相等，就不等效于n/2。

所以n为-1时，-1 / 2 = 0；直接结束循环。这就可以改成方法2。

#include <stdio.h>
int main()
{
	int n = 0;
	int count = 0;
	scanf("%d", &n);
	while (n)
	{
		if (n % 2 == 1)
		{
			count++;
		}
		n /= 2;
	}
	printf("二进制中1的个数为:%d\n", count);
	return 0;
}

**方法2：**这种方法思路跟方法1有点相似， 如果n的最后一位是1，n&1 == 1，如果n的最后一位是0，n&1 == 0，整型一共32个二进制位，这里是把n的每一位都移到最后一位与1进行按位与（&）操作一共32位所以要循环32次，这里会把n右移一位的值赋值给n，改变了n的值。

#include <stdio.h>
int count(int n)
{
	int amount = 0;
	int i = 0;
	for (i = 0; i < 32; i++)
	{
		if ((n & 1) == 1)
		{
			amount++;
		}
		n >>= 1;
	}
	return amount;
}
int main()
{
	int n = 0;
	scanf("%d", &n);
	int a = count(n);
	printf("二进制中1的个数为:%d\n", a);
	return 0;
}

方法2副本： count函数里也可以写成下面这样，跟方法2思路有点差异。

这里是把n的每一位向右移动后的返回值与1进行按位与操作，这里不会改变n本身的值，只是把32位都一次性移动到最后一位与1进行&，最右边的一位移动0位就比较，以此类推，最左边一位要移到最右边一位，要移动31位，不改变n的值。

#include <stdio.h>
int count(int n)
{
	int amount = 0;
	int i = 0;
	for (i = 0; i < 32; i++)
	{
		if (((n >> i) & 1) == 1)
		{
			amount++;
		}
	}
	return amount;
}
int main()
{
	int n = 0;
	scanf("%d", &n);
	int a = count(n);
	printf("二进制中1的个数为:%d\n", a);
	return 0;
}

**方法3：**这里我们先拓展一个东西，如果一个整数n=7，

n在内存中的补码形式是00000000000000000000000000000111，

n-1 补码形式是00000000000000000000000000000110

n = n&n-1 补码形式是00000000000000000000000000000110

n-1 补码形式是00000000000000000000000000000101

n = n&n-1 补码形式是00000000000000000000000000000100

这里你会发现每次n&n-1后n在内存中的二进制最后面的1都会去掉，直到最后n=0，此时n在内存二进制中没有1。负数也同样适用。

那我们就可以写下下面的代码：

#include <stdio.h>
int main()
{
    int n = 0;
    int count = 0;
    scanf("%d",&n);
    while(n)
    {
        n = n & (n-1);
        count++;
    }
    printf("二进制中1的个数为:%d\n", count);
    return 0;
}

方法3的运行次数就是数在内存中有几个1就运行几次，比方法1和方法2要效率高点。

3.5.4 整数内存二进制位置1或置0

//整数内存二进制位置1
#include <stdio.h>
int main()
{
	int n = 13;
	printf("%d\n", n);
	n |= 1 << (5 - 1);
	printf("%d\n", n);
	return 0;
}

假设有一个整数n，将n在内存中的二进制的第x位如果为1，先变0再变1，如果为0，先变1再变0。

这里我用n=13，第5位举例子。

13的原码=反码=补码=00000000000000000000000000001101，需要把从右往左第5位先变成1，再变成0。

置1：我们可以使用 | 操作符，将13的补码与00000000000000000000000000010000进行按位或操作，即：

00000000000000000000000000001101 |

00000000000000000000000000010000 =

00000000000000000000000000011101，这样就实现了第五位变成1，如何得到00000000000000000000000000010000，我们会发现将1的补码向左移动（5-1）位就可以得到。

即：1<<(5-1) == 00000000000000000000000000010000

代码如下：

//整数内存二进制位置1
#include <stdio.h>
int main()
{
	int n = 13;
	printf("%d\n", n);
	n |= 1 << (5 - 1);
	printf("%d\n", n);
	return 0;
}

置0：接着把00000000000000000000000000011101，的第5位置为0，该如何操作呢？

这里我们便用到 & 操作符，将00000000000000000000000000011101与11111111111111111111111111101111进行&操作。即：

00000000000000000000000000011101 &

111111111111111111111111111 01111 =

00000000000000000000000000001101，这样就实现了第五位变成0，如何得到111111111111111111111111111 01111，我们会发现00000000000000000000000000010000 按位取反会得到这个值，即进行 ~(1<<(5-1)) 操作。

~(1<<(5-1)) =111111111111111111111111111 01111

代码如下：

//整数内存二进制位置0
#include <stdio.h>
int main()
{
	int n = 13;
	printf("%d\n", n);
	n &= ~(1 << (5 - 1));
	printf("%d\n", n);
	return 0;
}

4. 逗号表达式

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

例如：(a，b，c，d)

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

int a = 1;

int b = 2;

int c = 4;

int d = ( a+b , a+c , b+c ) ;

d的值应该是最后一个表达式的结果，也就是b+c=6，所以d=6。

#include <stdio.h>
int main()
{
	int input = 0;
	while (printf("请输入一个整数：\n"), scanf("%d", &input) == 1)
	{
		printf("%d\n", input);
	}
	return 0;
}

上图的代码也是可以的。

5. 下标引用[ ]和函数调用 ()

5.1 下标引用操作符[ ]

操作数是：数组名 + 索引值下标。

例如：

#include <stdio.h>
int main()
{
	int arr[10] = { 0 };
	arr[5] = 6;

	return 0;
}

arr[5] = 6; 中 arr和5是[ ] 的两个操作数。

5.2 函数调用操作符 ()

操作数是：函数名 + 参数 ，参数可有可无。

#include <stdio.h>
int add(a, b)
{
	return a + b;
}
int main()
{
	int a = 1;
	int b = 2;
	int c = add(a, b);
	printf("%d\n", c);
	return 0;
}

上面的add(a,b);中add和a,b是()的两个操作数。

6. 结构成员访问操作符 . ->

6.1 结构体

在C语言中，已经提供了很多内置类型int , long, char ,float ,double 等，但是光靠这些类型是无法满足我们编码所需要的，比如说：要定义一个学生的变量，需要姓名，身高，体重，学号，等。应该用什么类型呢，这时仅靠C语言中内置类型时无法满足的。

C语言提供了一种自定义类型，结构体，程序员可以自己创造想要的类型。

结构是一些值的集合，这些值称为成员变量，结构的每个成员可以是任意类型的，如标量、数组、指针，甚至是其他结构体。

6.1.1 结构体的声明

struct name
{
    member_list;

}variable_list;

struct 是声明结构体的关键字，name 是结构体的名字，member_list 是指结构体内的多个成员变量，variable_list是指多个结构体变量（可有可无）。

下面是定义的学生的结构体类型，包含姓名，年龄，性别，学号等成员变量，s1,s2,s3是直接创建的结构体变量（全局变量）。

struct student
{
     char name[20];//姓名
     int age;//年龄
     char sex[5];//性别
     char id[20];//学号

}s1,s2,s3;

6.1.2 结构体变量的定义和初始化

下面代码定义结构体变量可以直接在结构体声明的同时定义 ，也可以直接定义。

初始化可以对应结构体里面的成员变量按顺序一一对应初始化，也可以不按顺序初始化，这时候

需要用到**. 操作符**来访问结构体里面的成员变量来进行初始化，可以不按照顺序。

struct stu
{
    char name[20];
    int age;
}x1; //声明类型的同时定义结构体变量x1
struct stu x2; //定义结构体变量x2

//按顺序初始化
struct stu x3 = {"张三",18};

//不按顺序初始化
struct stu x4 = {.age = 18,.name = "张三"};

下面是结构体的嵌套情况下的初始化：

struct count
{
    int a;
    int b;
};

struct arr
{
    int c;
    struct count;
    char b;
};

struct s1 = {10,{20,30},'a'};

6.2 结构成员访问操作符

6.2.1 结构成员的直接访问

结构体成员的直接访问是通过点操作符（.）访问的。点操作符接受两个操作数。

通过结构体变量.成员变量名来访问成员变量。如下图：

#include <stdio.h>
struct Point
{
    int x;
    int y;
}p = {1,2};

int main()
{
    printf("x: %d y: %d\n", p.x, p.y);
    return 0;
}

6.2.2 结构体成员的间接访问

结构体成员的间接访问是通过（->）操作符访问的。

通过结构体指针.成员变量名来访问成员变量。

当我们得到的不是⼀个结构体变量，而是⼀个指向结构体的指针。如下面代码：

#include <stdio.h>
struct Point
{
    int x;
    int y;
};

int main()
{
    struct Point p = {3, 4};
    struct Point *ptr = &p;
    ptr->x = 10;
    ptr->y = 20;
    printf("x = %d y = %d\n", ptr->x, ptr->y);

    return 0;
}

这里ptr就是一个指向结构体的指针，通过ptr->x,ptr->y,来访问结构体中的成员变量。

7. 操作符的属性：优先级、结合性

7.1 优先级

优先级指的是，如果⼀个表达式包含多个运算符，哪个运算符应该优先执行。各种运算符的优先级是不一样的。

1 + 2 * 3；

例如：表达式 1 + 2 * 3 里面既有加法运算符（ + ），⼜有乘法运算符（ * ）。由于乘法的优先级高于加法，所以会先计算 2 * 3 ，而不是先计算 1 + 2 。

7.2 结合性

如果两个运算符优先级相同，优先级没办法确定先计算哪个了，这时候就看结合性了，则根据运算符是左结合，还是右结合，决定执行顺序。大部分运算符是左结合（从左到右执行），少数运算符是右结合（从右到左执行），比如赋值运算符（ = ）就是从右到左执行。

1 * 2 / 3；

上面示例中， * 和 / 的优先级相同，它们都是左结合运算符，所以从左到右执行，先计算 1 * 2，再计算 2 / 3 。

运算符的优先级顺序很多，下面是部分运算符的优先级顺序（按照优先级从高到低排列），建议大家记住这些常用操作符的优先级就行，其他操作符在使用的时候查看下面表格就可以了。

• 圆括号（ () ）

• 自增运算符（ ++ ），自减运算符（-- ）

• 单目运算符（ + 和 ） • 乘法（ * ），除法（ / ） • 加法（ + ），减法（ ）

• 关系运算符（ < 、 > 等）

• 赋值运算符（ = ）

由于圆括号的优先级最高，可以使用它改变其他运算符的优先级。

操作符优先级表格：

8. 表达式求值

8.1 整型提升

C语言中整型算术运算总是至少以缺省（默认）整型类型的精度来进行的。

在C语言中整型的默认类型是int类型，浮点型的默认类型是double类型，b = 100,要把100变成long类型，需要在100后面加上l,写成long b = 100l ; 浮点型同理要写成 float c = 3.14f ; 。

#include <stido.h>
int main()
{
    int a = 100;
    long b = 100l;
    float c = 3.14f;

    return 0;
}

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

下面代码中在进行 a+b的运算前，需要把a和b先转换成整型再参与运算。

#include <stdio.h>
int main()
{
    char a = 20;
    char b = 120;
    char c = a + b;
    printf("%d",c);

    return 0;
}
    

整型提升的意义：

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

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

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

上面代码中求出c的值等于多少？ 答案是 -116 为什么呢？

char a = 20;

char b =120;

这里的20的二进制是：00000000000000000000000000010100

120的二进制是：00000000000000000000000001111000

但是a和b都是char类型，长度为1个字节（8个比特位）,所以20和120分别赋值给a和b的二进制是

char a=20： 00010100

char b=120： 0111 1000

接下来计算char c = a + b；这时候要对a和b进行整型提升后再进行运算。

如何进行整型提升？

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

2. 无符号整数提升，高位补0。

而char类型是有符号整型，对a和b整型提升后的值是：

20: 000000000000000000000000 0001 0100

120: 000000000000000000000000 0111 1000

20+120 : 000000000000000000000000 1000 1100

此时把20+120赋值给c ,c是字符型。

char c =140 : 10001100

此时要打印c的值，而%d意思是打印一个有符号整型的十进制数。

所以要对c进行整型提升后再进行打印。

c整型提升后： 111111111111111111111111 1000 1100 --补码

100000000000000000000000 0111 0011

100000000000000000000000 0111 0100 --原码（-116）

所以打印出来c的结果位-116。

8.2 算数转换

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

1. long double
2. double
3. float
4. unsigned long int
5. long int
6. unsigned int
7. int

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

50 + 3.14f ;

这里的50是int类型，3.14是float类型，要先把50转换成float类型，再进行运算。（这个转换是编译器进行的）。

8.3 总结

即使有了操作符的优先级和结合性，我们写出的表达式依然有可能不能通过操作符的属性确定唯一的计算路径，那这个表达式就是存在潜在风险的，建议不要写出特别复杂的表达式。