C语言从入门到进阶——第10讲：操作符详解

文章目录

• 1. 操作符的分类
• 2. 二进制和进制转换
• • 2.1 2进制转10进制
  • 2.2 10进制转2进制
  • 2.3 2进制转8进制
  • 2.4 2进制转16进制
• 3. 原码、反码、补码
• • 3.1 有符号整数的表示规则
  • 3.2 无符号整数的表示规则
  • 3.3 补码的存储意义
• 4. 移位操作符
• • 4.1 左移操作符 <<
  • 4.2 右移操作符 >>
• 5. 位操作符: &、|、^、~
• • 5.1 基本使用示例
  • 5.2 经典面试题：无临时变量交换两个整数
  • 5.3 练习1：求整数内存中二进制的1的个数
  • 5.4 练习2：二进制位置0或者置1
• 6. 单目操作符
• 7. 逗号表达式
• • 7.1 核心规则
  • 7.2 示例1：基础取值
  • 7.3 示例2：条件判断中使用
  • 7.4 示例3：简化循环代码
• 8. 下标访问[]、函数调用()
• • 8.1 [] 下标引用操作符
  • 8.2 () 函数调用操作符
• 9. 结构成员访问操作符
• • 9.1 结构体基础
  • • 9.1.1 结构的声明
    • 9.1.2 结构体变量的定义和初始化
  • 9.2 结构成员访问操作符
  • • 9.2.1 直接访问：点操作符 `.`
    • 9.2.2 间接访问：箭头操作符 `->`
    • 9.2.3 综合举例
• 10. 操作符的属性: 优先级、结合性
• • 10.1 优先级
  • 10.2 结合性
  • 10.3 常用操作符优先级（从高到低）
  • 10.4 完整优先级参考
• 11. 表达式求值
• • 11.1 整型提升
  • • 11.1.1 定义
    • 11.1.2 整型提升的意义
    • 11.1.3 整型提升的规则
    • 11.1.4 示例
  • 11.2 算术转换
  • • 11.2.1 定义
    • 11.2.2 转换规则（从高到低，低类型转高类型）
  • 11.3 问题表达式解析
  • • 11.3.1 表达式1：运算顺序不唯一
    • 11.3.2 表达式2：操作数求值顺序歧义
    • 11.3.3 表达式3：极端复杂的未定义表达式
    • 11.3.4 表达式4：函数调用顺序不确定
    • 11.3.5 表达式5：前置++的执行顺序歧义
  • 11.4 总结

1. 操作符的分类

• 算术操作符: +、-、*、/、%
• 移位操作符: <<、>>
• 位操作符: &、|、^
• 赋值操作符: =、+=、-=、*=、/=、%=、<<=、>>=、&=、|=、^=
• 单目操作符: !、++、–、&、*、+、-、~、sizeof、(类型)
• 关系操作符: >、>=、<、<=、==、!=
• 逻辑操作符: &&、||
• 条件操作符: ? :
• 逗号表达式: ,
• 下标引用: []
• 函数调用: ()
• 结构成员访问: .、->

上述的操作符，已讲解算术操作符、赋值操作符、逻辑操作符、条件操作符和部分的单目操作符，后续继续介绍与二进制相关的操作符，先铺垫二进制和进制转换的知识。

2. 二进制和进制转换

2进制、8进制、10进制、16进制是数值的不同表示形式，例如数值15的各进制表示：

• 15的2进制: 1111
• 15的8进制: 17
• 15的10进制: 15
• 15的16进制: F

标识规则：16进制的数值前加0x，8进制的数值前加0。

2.1 2进制转10进制

10进制的每一位有对应的权重，从右向左分别是10⁰、10¹、10²…，例如10进制123转2进制：

2进制与10进制原理类似，每一位权重从右向左分别是2⁰、2¹、2²…，例如2进制1101转10进制：

2.2 10进制转2进制

采用除2取余，由下往上排列余数的方法，例如10进制125转2进制：

2.3 2进制转8进制

8进制数字每一位取值0-7，每个8进制数最多用3个二进制位表示（如7的二进制是111）。 转换规则：从二进制序列右边低位开始向左，每3个二进制位换算一个8进制位，剩余不够3个的直接换算。 标识规则：16进制表示时前面加0。 示例：2进制01101011转8进制为0153。

2.4 2进制转16进制

16进制数字每一位取值0-9、a-f，每个16进制数最多用4个二进制位表示（如f的二进制是1111）。 转换规则：从二进制序列右边低位开始向左，每4个二进制位换算一个16进制位，剩余不够4个的直接换算。 标识规则：16进制表示时前面加0x。 示例：2进制01101011转16进制为0x6b。

3. 原码、反码、补码

整数的2进制表示方法有原码、反码和补码三种。

3.1 有符号整数的表示规则

有符号整数的原码、反码、补码均分为符号位和数值位：

• 二进制序列最高1位为符号位，0表示“正”，1表示“负”，剩余位为数值位，用于表示数值大小；

• 正整数的原码、反码、补码完全相同：符号位为0，数值位为数值的二进制；
• 负整数的原码、反码、补码各不相同，转换规则：
• 原码：符号位为1，数值位为数值的二进制；
• 反码：原码符号位不变，数值位按位取反；
• 补码：反码加1；
• 补码转原码：取反后加1（与原码转补码运算过程一致）。

3.2 无符号整数的表示规则

无符号整数没有符号位，每一位都是数值位，其原码、反码、补码完全相同。

3.3 补码的存储意义

在计算机系统中，整形数据一律用补码表示和存储，原因：

4. 移位操作符

移位操作符包括左移操作符<<和右移操作符>>，操作数只能是整数，且禁止移动负数位。

4.1 左移操作符 <<

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

示例代码：

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

4.2 右移操作符 >>

右移运算分为逻辑右移和算术右移：

示例代码（正数右移）：

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

警告：不要对操作数移动负数位，例如num >> -1;为错误代码。

示例代码（负数右移）：

int num=–1;
// 内存中补码：11111111111111111111111111111111
num>>1;
// 算术右移结果：11111111111111111111111111111111（左边补符号位1）

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

位操作符的操作数必须是整数，包括按位与&、按位或|、按位异或^、按位取反~，均基于二进制补码进行运算。

5.1 基本使用示例

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

5.2 经典面试题：无临时变量交换两个整数

利用按位异或的特性（a^a=0、a^0=a、a^b^b=a）实现，代码如下：

#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;
}

5.3 练习1：求整数内存中二进制的1的个数

提供三种实现方法，其中方法3为最优解：

方法1：取余除2法（存在负数缺陷）

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

缺陷：无法正确处理负数，因负数取余和除2的结果不符合二进制逻辑。

方法2：按位与移位法（通用，固定循环32次）

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

原理：通过1 << i遍历每一位，与原数按位与判断该位是否为1，适配所有整数（含负数）。

方法3：按位与优化法（最优，循环次数=1的个数）

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

原理：num & (num – 1)会消去num二进制补码中最右边的1，循环至num为0时，循环次数即为1的个数。

5.4 练习2：二进制位置0或者置1

需求：将13二进制序列的第5位修改为1，再改回0（二进制位从0开始计数）。 13的二进制：00000000000000000000000000001101 第5位置1后：00000000000000000000000000011101 第5位置0后：00000000000000000000000000001101

实现代码：

#include <stdio.h>
int main()
{
int a = 13;
a = a | (1 << 4); // 第5位（索引4）置1：按位或
printf("a = %d\\n", a);
a = a & ~(1 << 4); // 第5位（索引4）置0：按位与 + 按位取反
printf("a = %d\\n", a);
return 0;
}

核心规则：

• 指定位置1：原数 | (1 << 位索引)；
• 指定位置0：原数 & ~(1 << 位索引)。

6. 单目操作符

单目操作符的特点是只有一个操作数，包含：!、++、–、&、*、+、-、~、sizeof、(类型)。 其中&（取址）和*（解引用）操作符在指针章节详细讲解，其余操作符已讲解。

7. 逗号表达式

逗号表达式是用逗号隔开的多个表达式，格式为：exp1, exp2, exp3, …expN。

7.1 核心规则

7.2 示例1：基础取值

int a = 1;
int b = 2;
int c = (a > b, a = b + 10, a, b = a + 1);//逗号表达式
// 执行顺序：a>b(假) → a=12 → a(12) → b=13
// 最终c=13

7.3 示例2：条件判断中使用

if (a = b + 1, c = a / 2, d > 0)
// 执行所有子表达式，最终判断d>0的结果

7.4 示例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)
{
//业务处理
}

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

8.1 [] 下标引用操作符

操作数：一个数组名 + 一个索引值（下标），两个操作数无顺序要求。 示例代码：

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

8.2 () 函数调用操作符

操作数：接受一个或多个操作数，第一个操作数为函数名，剩余操作数为传递给函数的参数（参数个数可0）。 示例代码：

#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. 结构成员访问操作符

C语言的内置类型（char、short、int等）无法满足复杂对象的描述需求，因此提供结构体这种自定义数据类型，结构成员访问操作符用于访问结构体的成员变量，包括.和->。

9.1 结构体基础

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

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 结构体变量的定义和初始化

方式1：声明类型的同时定义变量

struct Point
{
int x;
int y;
}p1; // 声明时定义变量p1
struct Point p2; // 单独定义变量p2

方式2：直接初始化（普通/指定顺序）

struct Point p3 = {10, 20}; // 按成员顺序初始化
struct Stu
{
char name[15];//名字
int age; //年龄
};
struct Stu s1 = {"zhangsan", 20};// 按顺序初始化
struct Stu s2 = {.age=20, .name="lisi"};// 指定成员顺序初始化

方式3：结构体嵌套初始化

struct Node
{
int data;
struct Point p;
struct Node* next;
}n1 = {10, {4,5}, NULL}; // 嵌套初始化
struct Node n2 = {20, {5, 6}, NULL};// 嵌套初始化

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

9.2.3 综合举例

#include <stdio.h>
#include <string.h>
struct Stu
{
char name[15];//名字
int age; //年龄
};
void print_stu(struct Stu s)
{
printf("%s %d\\n", s.name, s.age);
}
void set_stu(struct Stu* ps)
{
strcpy(ps->name, "李四");
ps->age = 28;
}
int main()
{
struct Stu s = { "张三", 20 };
print_stu(s); // 传值，用.访问
set_stu(&s); // 传地址，用->访问
print_stu(s);
return 0;
}

更多结构体知识在《第20讲:自定义类型:结构体》中讲解。

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

C语言操作符的两个重要属性优先级和结合性，决定了表达式求值的计算顺序，解决多操作符表达式的执行顺序问题。

10.1 优先级

定义：如果一个表达式包含多个运算符，优先级高的运算符优先执行。 示例：

3 + 4 * 5;
// 乘法*优先级高于加法+，先计算4*5，再计算3+20，结果为23

10.2 结合性

定义：当两个运算符优先级相同时，由结合性决定执行顺序。

• 左结合：从左到右执行（大部分运算符，如*、/、+、-）；
• 右结合：从右到左执行（少数运算符，如赋值运算符=、单目运算符）。 示例：

5 * 6 / 2;
// *和/优先级相同，左结合，先计算5*6，再计算30/2，结果为15

10.3 常用操作符优先级（从高到低）

技巧：圆括号()的优先级最高，可通过添加圆括号改变其他运算符的执行顺序。

10.4 完整优先级参考

参考：https://zh.cppreference.com/w/c/language/operator_precedence

11. 表达式求值

表达式求值不仅受操作符优先级和结合性影响，还涉及整型提升和算术转换，且部分复杂表达式因计算路径不唯一，会产生未定义行为。

11.1 整型提升

11.1.1 定义

C语言中整型算术运算总是至少以默认整型类型（int）的精度进行，表达式中的char、short类型操作数在使用前会被转换为普通整型（int/unsigned int），该转换称为整型提升。

11.1.2 整型提升的意义

CPU的整型运算器（ALU）和通用寄存器的字节长度为int的字节长度，难以直接实现8比特（char）、16比特（short）的直接运算，因此需先转换为int/unsigned int后再执行运算。

11.1.3 整型提升的规则

11.1.4 示例

负数的整型提升

char c1 = –1;
// c1的8位补码：11111111
// 有符号char，整型提升后32位：11111111111111111111111111111111

正数的整型提升

char c2 = 1;
// c2的8位补码：00000001
// 有符号char，整型提升后32位：00000000000000000000000000000001

运算中的整型提升

char a,b,c;
a = b + c;
// 1. b和c先整型提升为int，执行加法运算；
// 2. 加法结果截断为char类型，存储到a中。

11.2 算术转换

11.2.1 定义

当某个操作符的操作数为不同类型时，需将其中一个操作数转换为另一个操作数的类型，才能执行运算，该转换称为寻常算术转换。

11.2.2 转换规则（从高到低，低类型转高类型）

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

规则：排名靠后的类型转换为排名靠前的类型，例如int + float会将int转换为float后再运算。

11.3 问题表达式解析

即使遵循优先级和结合性，部分表达式仍无法确定唯一的计算路径，导致结果在不同编译器中不同，这类表达式存在潜在风险，不建议编写。

11.3.1 表达式1：运算顺序不唯一

a * b + c * d + e * f

• 优先级仅保证*比+先执行，但无法确定第三个*是否比第一个+先执行；
• 可能的计算顺序：(a*b)+(c*d)+(e*f) 或 (a*b)+((c*d)+(e*f))，结果虽相同，但计算路径不唯一。

11.3.2 表达式2：操作数求值顺序歧义

c + —c;

• 优先级仅保证–在+前执行，但无法确定+的左操作数c和右操作数–c的求值顺序；
• 若先求左操作数，结果为原c + (原c-1)；若先求右操作数，结果为(原c-1) + (原c-1)，结果不唯一。

11.3.3 表达式3：极端复杂的未定义表达式

int main()
{
int i = 10;
i = i— – —i * ( i = –3 ) * i++ + ++i;
printf("i = %d\\n", i);
return 0;
}

结果：在不同编译器中结果差异极大，例如Tandy 6000 Xenix 3.2输出-128，gcc输出-63，Microsoft C 5.1输出42，属于非法表达式。

11.3.4 表达式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;
}

• 优先级仅保证乘法先执行，但无法确定三个fun()的调用顺序；
• 不同调用顺序会导致不同结果，例如先调用所有fun()再运算，或边调用边运算，结果不同。

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

结果：

gcc编译器：

10
4

VS2022编译器：

12
4

原因：无法确定第一个+执行时，第三个++i是否已执行，导致计算路径不唯一。

11.4 总结

即使掌握操作符的优先级和结合性，编写的复杂表达式仍可能因计算路径不唯一产生未定义行为，在不同编译器中得到不同结果。 建议：避免编写过于复杂的表达式，通过添加圆括号明确运算顺序，将复杂表达式拆分为多个简单表达式，提升代码的可读性和可移植性。