C语言操作符讲解--(里面包含进制转换和原码,反码,补码)

目录

前言

1. 操作符的分类

2. ⼆进制和进制转换 

2.1 2进制转10进制

2.1.1 10进制转2进制数字 

2.2 2进制转8进制和16进制 

2.2.1 2进制转8进制

2.2.2 2进制转16进制 

3. 原码、反码、补码

4. 移位操作符

4.1 左移操作符

​编辑 4.2 右移操作符

5. 位操作符：&、|、^、~

5.1按位与(&)示例

5.2按位或(|)示例

5.3按位异或(^)示例

5.4按位取反(~)示例

实现两个数的交换。

练习1：

练习2：

6. 单⽬操作符

7. 逗号表达式

8. 下标访问[]、函数调⽤()

8.1 [ ] 下标引⽤操作符 操作数：

8.2 函数调⽤操作符

9. 结构成员访问操作符

9.1 结构体

9.1.1 结构的声明 

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

9.2 结构成员访问操作符 

9.2.1 结构体成员的直接访问

9.2.2 结构体成员的间接访问 

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

10.1 优先级

10.2 结合性

11. 表达式求值

11.1 整型提升

11.2 算术转换 

11.3 问题表达式解析

11.4 总结

---

前言

当谈到 C 语言中的操作符时，它们在编程中扮演着至关重要的角色。操作符是用于执行各种操作的特殊符号，它们允许我们在程序中进行数学运算、逻辑判断、位操作等。以下是 C 语言中操作符的一些关键地位：

1. 基本工具：操作符是编写 C 代码的基本工具之一。它们使我们能够执行各种任务，例如计算、赋值、比较和逻辑运算。

2. 表达式构建：操作符用于构建表达式。通过组合操作符和操作数，我们可以创建复杂的表达式，从而实现更高级的功能。

3. 优先级和结合性：C 语言中的操作符具有不同的优先级和结合性。这些规则决定了表达式中操作符的计算顺序。例如，乘法操作符 * 的优先级高于加法操作符 +。

4. 算术操作符：算术操作符用于执行基本的数学运算，例如加法、减法、乘法和除法。这些操作符在编写数值计算和数学公式时非常重要。

5. 逻辑操作符：逻辑操作符用于执行逻辑判断。例如，逻辑与操作符 && 用于同时判断两个条件是否为真，逻辑或操作符 || 用于判断其中一个条件是否为真。

6. 位操作符：位操作符用于对整数的二进制位进行操作。这些操作符在处理底层数据和位掩码时非常有用。

7. 赋值操作符：赋值操作符用于将值赋给变量。例如，= 用于简单的赋值，+= 用于累加赋值。

总之，操作符是 C 语言中不可或缺的部分，它们使我们能够编写出高效、功能强大的程序。如果你对特定操作符还不是很了解的话，赶紧收藏关注起来吧!

1. 操作符的分类

算术操作符： + 、- 、 * 、/、%

• 移位操作符: <<、>>

• 位操作符: & | ^ `

• 赋值操作符: =  、  += 、-= 、 *=、/=  、%= 、 <<= 、>>= 、 &= 、|=、^=

• 单⽬操作符： ！、 ++ 、- 、 & 、 * 、 + 、- 、 ~ 、 sizeof 、 ( 类型 )

• 关系操作符: > 、 >= 、 < 、<=、==、!=

• 逻辑操作符：&&、||

• 条件操作符： ?  :

• 逗号表达式： ,

• 下标引⽤： []

• 函数调⽤： () 

操作符中有⼀些操作符和⼆进制有关系，我们先铺垫⼀下⼆进制的和进制 转换的知识。

2. ⼆进制和进制转换 

其实我们经常能听到2进制、8进制、10进制、16进制这样的讲法，那是什么意思呢？其实2进制、8进 制、10进制、16进制是数值的不同表⽰形式⽽已。

⽐如：数值15的各种进制的表⽰形式：

15的2进制：1111
15的8进制：17
15的10进制：15
15的16进制：F

我们重点介绍⼀下⼆进制：

⾸先我们还是得从10进制讲起，其实10进制是我们⽣活中经常使⽤的，我们已经形成了很多尝试：

• 10进制中满10进1

• 10进制的数字每⼀位都是0~9的数字组成

其实⼆进制也是⼀样的

• 2进制中满2进1

• 2进制的数字每⼀位都是0~1的数字组成

那么 1101 就是⼆进制的数字了。 

2.1 2进制转10进制

其实10进制的123表⽰的值是⼀百⼆⼗三，为什么是这个值呢？其实10进制的每⼀位是权重的，10进 制的数字从右向左是个位、⼗位、百位....，分别每⼀位的权重是 10^0 ,10^1 ,10^2 ...

如下图：

2进制和10进制是类似的，只不过2进制的每⼀位的权重，从右向左是: 2^0 ,2^1 ,2^2 ... 

2.1.1 10进制转2进制数字 

2.2 2进制转8进制和16进制 

2.2.1 2进制转8进制

8进制的数字每⼀位是0~7的，0~7的数字，各⾃写成2进制，最多有3个2进制位就⾜够了，⽐如7的⼆ 进制是111，所以在2进制转8进制数的时候，从2进制序列中右边低位开始向左每3个2进制位会换算⼀ 个8进制位，剩余不够3个2进制位的直接换算。

如：2进制的01101011，换成8进制：0153，0开头的数字，会被当做8进制。

2.2.2 2进制转16进制 

16进制的数字每⼀位是0~9,a~f的，0~9,a~f的数字，各⾃写成2进制，最多有4个2进制位就⾜够了， ⽐如f的⼆进制是1111，所以在2进制转16进制数的时候，从2进制序列中右边低位开始向左每4个2进 制位会换算⼀个16进制位，剩余不够4个⼆进制位的直接换算。

如：2进制的01101011，换成16进制：0x6b，16进制表⽰的时候前⾯加0x

3. 原码、反码、补码

整数的2进制表⽰⽅法有三种，即原码、反码和补码

有符号整数的三种表⽰⽅法均有符号位和数值位两部分，2进制序列中，最⾼位的1位是被当做符号 位，剩余的都是数值位。

符号位都是⽤0表⽰“正”，⽤1表⽰“负”。

正整数的原、反、补码都相同。

负整数的三种表⽰⽅法各不相同。

原码：直接将数值按照正负数的形式翻译成⼆进制得到的就是原码。

反码：将原码的符号位不变，其他位依次按位取反就可以得到反码。

补码：反码+1就得到补码。

反码得到原码也是可以使⽤：取反，+1的操作。

注意:

对于整形来说：数据存放内存中其实存放的是补码。

4. 移位操作符

<<左移操作符

>>右移操作符

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

4.1 左移操作符

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

示例:

int main()
{
	int a = -6;
	//10000000000000000000000000000110
	//11111111111111111111111111111001
	//11111111111111111111111111111010  ---> -6的补码
	//11111111111111111111111111110100  -- b中得到的补码
	//10000000000000000000000000001011
	//10000000000000000000000000001100 -> -12

	int b = (a << 1);

	printf("%d\n", b);//-12
	printf("%d\n", a);//-6


	return 0;
}

左移一位有乘2的效果 

 4.2 右移操作符

移位规则：⾸先右移运算分两种：

1. 逻辑右移：左边⽤0填充，右边丢弃 

2. 算术右移：左边⽤原该值的符号位填充，右边丢弃 

右移是算数右移,还是逻辑右移是取决于编译器的实现,常见的编译器都是算数右移

大家可以用下面程序判断你们的编译器是算术右移还是逻辑右移 

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

 如果编译器是算数右移,那么n与num都等于-1

int main()
{
	int a = 6;
	a >>= 1;
	printf("%d\n", a);//3
	return 0;
}

右移一位具有除2的效果 

5. 位操作符：&、|、^、~

位操作符有：

1 &  按位与

2 | 按位或 

3 ^ 按位异或

4 ~按位取反

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

5.1按位与(&)示例

按位&与,只有两个位都为1才为1,否则为0 

5.2按位或(|)示例

 按位或(|)只有两个位都为0才为0,否则为1

5.3按位异或(^)示例

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

5.4按位取反(~)示例

 ⼀道变态的⾯试题：

不能创建临时变量（第三个变量)

实现两个数的交换。

#include <stdio.h>
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;
}

这里需要注意这两个点: 

1.a^a = 0

2.0^a= a

根据异或的性质,任何数异或自己都为0,0异或任何数都为任何数

a = a ^ b

b = a ^ b ^ b = a

a = a ^ b ^ a = b

练习1：

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

方法一:

int main()
{
	//int n = 13;
	//00000000000000000000000000001101
	// n = n>>1;
	//00000000000000000000000000000001
	//00000000000000000000000000000001


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

	return 0;
}

将整数每一位与1进行与(&)运算,根据&运算的法则,如果整数32位的第一位为1,则结果为1,反之为0.

方法二:

#include <stdio.h>
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;
	
}

练习2：

⼆进制位置0或者置1

编写代码将13⼆进制序列的第5位修改为1，然后再改回0

#include <stdio.h>
int main()
{
	int a = 13;
	//~00001101---13
	//~00000001---1
	//~00010000---1 << 4
	//~00011101---a | (1 << 4)
	a = a | (1 << 4);
	printf("a = %d\n", a);
	a = a & ~(1 << 4);
	printf("a = %d\n", a);
	return 0;
}

6. 单⽬操作符

单⽬操作符有这些： ！、 ++ 、- 、 & 、 * 、 + 、 、 ~ 、 sizeof 、 ( 类型 )

单⽬操作符的特点是只有⼀个操作数，在单⽬操作符中只有&和*需要重点介绍介绍，这2个操作符，我们放在学习指针的时候学习。

7. 逗号表达式

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

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

如下图所示:

int main()
{
	int a = 1;
	int b = 2;
	int c = (a > b, a = b + 10, a, b = a + 1);//逗号表达式
//	           -1       12      12      13
	printf("%d\n", c);//13

	return 0;
}

8. 下标访问[]、函数调⽤()

8.1 [ ] 下标引⽤操作符 操作数：

⼀个数组名+⼀个索引值

8.2 函数调⽤操作符

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

#include <stdio.h>
void test1()
{
	printf("hehe\n");
}
void test2(const char* str)
{
	printf("%s\n", str);
}
int main()
{
	test1();//这⾥的()就是作为函数调⽤操作符。
	test2("hello bit.");//这⾥的()就是函数调⽤操作符。

	return 0;
}

9. 结构成员访问操作符

9.1 结构体

C语⾔已经提供了内置类型，如：char、short、int、long、float、double等，但是只有这些内置类 型还是不够的，假设我想描述学⽣，描述⼀本书，这时单⼀的内置类型是不⾏的。描述⼀个学⽣需要 名字、年龄、学号、⾝⾼、体重等；描述⼀本书需要作者、出版社、定价等。C语⾔为了解决这个问 题，增加了结构体这种⾃定义的数据类型，让程序员可以⾃⼰创造适合的类型。

注意:

结构是⼀些值的集合，这些值称为成员变量。结构的每个成员可以是不同类型的变量，如： 标量、数组、指针，甚⾄是其他结构体。

9.1.1 结构的声明 

struct tag
{
	member-list;
}variable-list;

描述⼀个学⽣：

struct Stu
{
	char name[20];//名字

	int age;//年龄

	char sex[5];//性别

	char id[20];//学号

}; //分号不能丢

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

//创建出一个新的类型
//自定义的类型


struct Student
{
	char name[20];//名字
	int age;//年龄
	int high;//身高
	float weight;//体重
	char id[16];//学号
}s4, s5, s6;//这里的分号不能少
//s4, s5, s6 是结构体变量（全局的）

struct Student s7;//全局的

int main()
{
	struct Student s1 = {"张三", 20, 180, 75.5f, "20230901022"};//初始化
	struct Student s2 = {.age=30, .name="lisi", .weight=80.5f, .high=177, .id="20220101033"};

	printf("%s %d %d %.1f %s\n", s1.name, s1.age, s1.high, s1.weight, s1.id);
	//结构体变量.成员名

	//struct Student s3;
	//s1, s2, s3是三个结构体变量（局部的）


	return 0;
}

9.2 结构成员访问操作符 

9.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;
}

使⽤⽅式：结构体变量.成员名 

9.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;
}

使⽤⽅式：结构体指针->成员名 

更多关于结构体的知识，后面会在结构体中重点讲解。 

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

C语⾔的操作符有2个重要的属性：优先级、结合性，这两个属性决定了表达式求值的计算顺序。

10.1 优先级

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

上⾯⽰例中，表达式 3 + 4 * 5 ⾥⾯既有加法运算符（ + ），⼜有乘法运算符（ * ）。由于乘法 的优先级⾼于加法，所以会先计算 4 * 5 ，⽽不是先计算 3 + 4 。

10.2 结合性

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

上⾯⽰例中，* 和 / 的优先级相同，它们都是左结合运算符，所以从左到右执⾏，先计算 上⾯⽰例中， 先计算5 * 6 ,再计算 6 / 2 .

 运算符的优先级顺序很多，下⾯是部分运算符的优先级顺序（按照优先级从⾼到低排列），建议⼤概 记住这些操作符的优先级就⾏，其他操作符在使⽤的时候查看下⾯表格就可以了。

• 圆括号（ () ）

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

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

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

• 赋值运算符（ = ）

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

 参考:C 运算符优先级 - cppreference.com

11. 表达式求值

11.1 整型提升

C语⾔中整型算术运算总是⾄少以缺省整型类型的精度来进⾏的。

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

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

示例:

 

b和c的值被提升为普通整型，然后再执⾏加法运算。

加法运算完成之后，结果将被截断，然后再存储于a中。

如何进⾏整体提升呢？

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

2. ⽆符号整数提升，⾼位补0

例一:负数整形提升

 

例二:正数整形提升

 

11.2 算术转换 

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

如果某个操作数的类型在上⾯这个列表中排名靠后，那么⾸先要转换为另外⼀个操作数的类型后执⾏ 运算。

11.3 问题表达式解析

11.3.1 表达式1

a*b + c*d + e*f

表达式1在计算的时候，由于 * ⽐ + 的优先级⾼，只能保证， * 的计算是⽐ + 早，但是优先级并不 能决定第三个 * ⽐第⼀个 + 早执⾏。 所以表达式的计算机顺序就可能是：

 

11.3.2 表达式2

c + --c;

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

 

11.3.2 表达式3

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

表达式3在不同编译器中测试结果：⾮法表达式程序的结果
 

11.3.2 表达式4

#include <stdio.h>
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(); 中我们只能通过操作符的优先级得知：先算乘法，再算减法。

函数的调⽤先后顺序⽆法通过操作符的优先级确定。 

11.3.2 表达式5

  //表达式5
#include <stdio.h>
int main()
{
	int i = 1;
	int ret = (++i) + (++i) + (++i);
	printf("%d\n", ret);
	printf("%d\n", i);
	return 0;
}
//尝试在linux环境gcc编译器，VS2013环境下都执⾏，看结果。

 

 

看看同样的代码产⽣了不同的结果，这是为什么？

简单看⼀下汇编代码，就可以分析清楚.

这段代码中的第⼀个 + 在执⾏的时候，第三个++是否执⾏，这个是不确定的，因为依靠操作符的优先级和结合性是⽆法决定第⼀个 + 和第三个前置 ++ 的先后顺序。 

11.4 总结

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