C语言总结复习
目录
1.C语言的数据类型
1.1.内置类型
1.1.1转义字符（有印象即可）
1.1.2布尔类型
1.2自定义类型
1.2.1 数组
1.2.1.1C99中的变⻓数组
1.2.1.2柔性数组
1.2.1.2.1柔性数组是什么？
1.2.1.2.2柔性数组的优点（其余的自己了解）
1.2.2 结构体
1.2.2.1结构体声明（不占内存）
1.2.2.2结构体定义
1.2.2.3加入 typedef给结构体起别名
1.2.2.4如何计算结构体的大小？
1.2.2.5为什么存在内存对⻬?（了解即可）
1.2.2.6修改默认对⻬数
1.2.2.7结构体传参(记住即可)
1.2.2.8位段
1.2.3 枚举
1.2.3.1枚举是什么？
1.2.3.2枚举的语法规则
1.2.3.3枚举怎么用？
1.2.3.4 声明枚举变量
1.2.3.5 完整实例
1.2.3.6枚举有什么用？
1.2.3.7枚举的好处（优点）
1.2.4 联合体（共用体）
1.2.4.1联合体类型的声明
1.2.4.2联合体的特点
1.2.4.3相同成员的结构体和联合体对比
1.2.4.4联合体大小的计算
1.2.4.5联合体的实际例子
1.2.5结构体，联合体，枚举的区别
3.运算符和表达式：
3.1 操作符和表达式的注意事项：
3.1.1 “%”的注意事项
3.1.2 浮点数比较
3.1.3 得到浮点数结果的方法
3.1.4 逻辑与 &&、逻辑或 || 的短路特性
3.1.5 运算符优先级与结合性
3.1.6 逗号表达式
3.2 整型提升（基于补码）
3.2.1什么是整型提升？
3.2.2为什么要有整型提升？
3.2.3整型提升的具体规则
3.2.4整数溢出
3.2.4.1什么是整数溢出？
3.2.4.2有符号整数溢出：未定义行为（最危险）
3.2.4.3无符号整数溢出
3.2.4.4溢出逻辑：模 2^n 运算
3.3 原码、反码、补码
3.4 位操作符：&、|、^
3.4.1 按位与 &（全 1 才 1）
3.4.1.1 按位与 &的实际例子
3.4.2按位或 |（有 1 则 1）
3.4.2.1 按位或|的实际例子
3.4.3 按位异或 ^（相同为 0，不同为 1）
3.4.2.1 按位异或^的实际例
3.5移位操作符
3.5.1 左移操作符<<
3.5.2 右移操作符>>
4.通用占位符（需完全掌握）
5.数据在内存中的存储
5.1什么是大小端？
5.2大小端例子（和联合体中的实际例子一起看）
5.3浮点数的存储（自行了解）
6.库函数
6.1字符函数（头文件： ）
6.2字符串操作库函数（头文件： ）
1.strlen
2.strcpy
3.strcmp
4.strcat
5.strstr
6.strncpy
7.strncmp
8.strncat
6.3内存操作库函数（头文件： ）
1.memcpy
2.memmove
3.memset
4.memcmp
6.4动态内存管理库函数（头文件： ）
1.malloc
2.calloc
3.realloc
6.5通用算法库函数（头文件： ）
1.qsort
1.C语言的数据类型
1.1.内置类型
1.1.1转义字符（有印象即可）
| 转义字符 | 含义 | 作用说明 |
|---|---|---|
|
| 换行符 | 换到下一行开头 |
| 水平制表符 | 相当于按一次 Tab 键 | |
| 反斜杠 | 输出一个真正的 | |
| " | 双引号 | 输出一个真正的" |
| ' | 单引号 | 在单引号字符串里输出 ' |
| 空字符 | 字符串结束标志或者NULL | |
| 响铃符 | 让电脑发出 “滴” 一声（部分系统支持 | |
| 换页符 | 打印机 / 老式终端用，跳到下一页 | |
| 垂直制表符 | 垂直方向跳格 | |
| 回车符 | 回到当前行开头 | |
| 退格符 | 往前删一个字符（类似 Backspace | |
| ddd | 八进制 ASCII 码 d d d表示1~3个八 进制数字 | A = A |
| Ý | 十六进制 ASCII 码 d d表示2个十六进制 数字 | A = A |
1.1.2布尔类型
需包含头文件：#include
bool//类型名
true // 代表真，本质是 1
false // 代表假，本质是 0
1.2自定义类型
1.2.1 数组
1.2.1.1C99中的变⻓数组
传统 C89 要求数组大小必须是常量表达式，而 C99 允许：
int n = 10;
int arr[n]; // 变长数组，n 是变量1.2.1.2柔性数组
1.2.1.2.1柔性数组是什么？
柔性数组是 C99 标准引入的、放在结构体最后一个成员的、没有指定大小的数组，用来让结构体 “动态变长”
struct Stu
{
int age;
int score[]; // 柔性数组，不占空间
};特点：
1.必须是结构体最后一个成员
struct S
{
int n;
int arr[]; // 必须最后
};2.定义时不写大小 []
int arr[]; // 柔性数组3.不占用结构体空间（或说占用 0 字节）
4.真正的空间在 malloc 时一起分配
struct S* s = malloc(sizeof(struct S) + 数组大小 * sizeof(int));5.使用方式和普通数组一样
s->arr[0] = 10;
s->arr[1] = 20;1.2.1.2.2柔性数组的优点（其余的自己了解）
1. 内存连续（访问更快，无碎片）
柔性数组的内存紧跟在结构体后面，连续存储。
2. 只需一次 malloc + 一次 free
struct Stu* s = malloc(sizeof(struct Stu) + 10 * sizeof(int));
free(s); // 一次释放全部#include
#include
struct Stu
{
int age;
int score[];
};
int main()
{
int n = 3;
struct Stu* s = malloc(sizeof(struct Stu) + n * sizeof(int));
s->age = 20;
s->score[0] = 90;
s->score[1] = 85;
s->score[2] = 88;
printf("%d
", s->age);
for (int i = 0; i < n; i++)
printf("%d ", s->score[i]);
free(s);
s = NULL;
return 0;
} 1.2.2 结构体
1.2.2.1结构体声明（不占内存）
struct 结构体名 {
类型1 成员1;
类型2 成员2;
...
};
struct Stu
{
char name[20];//名字
int age;//年龄
char sex[5];//性别
char id[20];//学号
}; //分号不能丢1.2.2.2结构体定义
方式 1：先声明，再定义
struct Student s1;方式 2：声明时顺便定义
struct Student {
int id;
char name[20];
int age;
} s1, s2;
1.2.2.3加入 typedef给结构体起别名
1.声明(两种方法)
struct Student {
int id;
char name[20];
int age;
};
// 重点：给 struct Student 起个别名，叫 Stu
typedef struct Student Stu;
// 直接把 typedef 写在前面，最后 Stu 就是新类型名
typedef struct Student {
int id;
char name[20];
int age;
} Stu; 2.定义
// 原来的写法
struct Student s1;
// 现在的写法（简洁多了）
Stu s1;
Stu s2 = {1002, "李四", 19};
// 原来的写法
struct Student *p = &s1;
// 现在的写法
Stu *p = &s1;3.综合（声明，定义，初始化，访问，指针）
#include
#include
// 1. 声明结构体 + typedef 起别名
// 以后 Stu 就代表 struct Student
typedef struct Student {
int id;
char name[20];
int age;
} Stu;
int main() {
// 2. 用别名 Stu 定义变量并初始化
Stu s1 = {1001, "张三", 18};
// 3. 普通访问（.）
printf("普通访问：
");
printf("学号：%d
", s1.id);
printf("姓名：%s
", s1.name);
// 4. 用别名 Stu 定义指针
Stu *p = &s1;
// 5. 指针访问（->）
printf("
指针访问：
");
printf("年龄：%d
", p->age);
// 6. 指针修改成员
p->age = 20;
strcpy(p->name, "李四");
printf("
修改后：
");
printf("年龄：%d
", s1.age); // 20
printf("姓名：%s
", s1.name); // 李四
return 0;
} 1.2.2.4如何计算结构体的大小？
一.对⻬规则
1.结构体的第一个成员，会直接放在整个结构体的起始位置（偏移量为 0）。
2.后面的每个成员，都要 “对齐” 到一个 “对齐数” 的整数倍位置上
struct Test1 {
char a; // 1字节
int b; // 4字节
char c; // 1字节
};
第一步：放置第一个成员 char a
规则：第一个成员从偏移量 0 开始。
占用：1 个格子。
地址: 0 1 2 3 4 5 6 7 8 9 10 11 12
┌───┬───┬───┬───┬───┬───┬───┬───┬───┬───┬───┬───┐
│ a │ │ │ │ │ │ │ │ │ │ │ │
└───┴───┴───┴───┴───┴───┴───┴───┴───┴───┴───┴───┘
第二步：放置第二个成员 int b
规则：int 占 4 字节，对齐数是 4，必须放在 4 的倍数地址（0, 4, 8...）
当前结束在地址 1，下一个 4 的倍数是 4
地址 1, 2, 3 空着（填充字节），从地址 4 开始放 b
占用：4 个格子（地址 4, 5, 6, 7）
地址: 0 1 2 3 4 5 6 7 8 9 10 11 12
┌───┬───┬───┬───┬───┬───┬───┬───┬───┬───┬───┬───┐
│ a │pad│pad│pad│ b │ b │ b │ b │ │ │ │ │
└───┴───┴───┴───┴───┴───┴───┴───┴───┴───┴───┴───┘
第三步：放置第三个成员 char c
规则：char 占 1 字节，对齐数是 1，任何地址都可以
紧接着上一个结束地址 8 开始放
占用：1 个格子（地址 8）
地址: 0 1 2 3 4 5 6 7 8 9 10 11 12
┌───┬───┬───┬───┬───┬───┬───┬───┬───┬───┬───┬───┐
│ a │pad│pad│pad│ b │ b │ b │ b │ c │ │ │ │
└───┴───┴───┴───┴───┴───┴───┴───┴───┴───┴───┴───┘
第四步：收尾，计算总大小
规则：结构体总大小必须是最大对齐数的整数倍。
成员对齐数：a(1), b(4), c(1) → 最大对齐数是 4
当前占用到地址 8，总长度是 9 字节
9 不是 4 的倍数，需要补到最近的 4 的倍数，也就是 12
地址 9, 10, 11 空着（尾部填充）
地址: 0 1 2 3 4 5 6 7 8 9 10 11 12
┌───┬───┬───┬───┬───┬───┬───┬───┬───┬───┬───┬───┐
│ a │pad│pad│pad│ b │ b │ b │ b │ c │pad│pad│pad│
└───┴───┴───┴───┴───┴───┴───┴───┴───┴───┴───┴───┘
另外调整结构体成员的顺序，结构体大小也会发生改变
例子2.嵌套结构体
// 嵌套的子结构体
struct Inner {
char a; // 1字节
int b; // 4字节
};
// 外层结构体
struct Test4 {
char c; // 1字节
struct Inner in; // 嵌套子结构体
double d; // 8字节
};
// struct Inner 内存布局 (总大小 8 字节)
地址: 0 1 2 3 4 5 6 7 8
┌───┬───┬───┬───┬───┬───┬───┬───┐
│ a │pad│pad│pad│ b │ b │ b │ b │ <- 最大对齐数是 4 (int b)
└───┴───┴───┴───┴───┴───┴───┴───┘
结论：struct Inner 占 8 字节，它的最大对齐数是 4
放置第一个成员 char c
规则：从偏移量 0 开始
占用：1 个格子
地址: 0 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 ...
┌───┬───┬───┬───┬───┬───┬───┬───┬───┬───┬───┬───┬───┬───┬───┬───┬───┐
│ c │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │
└───┴───┴───┴───┴───┴───┴───┴───┴───┴───┴───┴───┴───┴───┴───┴───┴───┘
放置第二个成员 struct Inner in
规则：嵌套结构体的对齐数 = 子结构体的最大对齐数（也就是 4）
要求：必须放在 4 的倍数地址
当前结束在地址 1，下一个 4 的倍数是 4
地址 1, 2, 3 空着（填充），从地址 4 开始放 in
占用：8 个格子（地址 4 ~ 11）
地址: 0 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 ...
┌───┬───┬───┬───┬───┬───┬───┬───┬───┬───┬───┬───┬───┬───┬───┬───┬───┐
│ c │pad│pad│pad│ a │pad│pad│pad│ b │ b │ b │ b │ │ │ │ │ │
└───┴───┴───┴───┴───┴───┴───┴───┴───┴───┴───┴───┴───┴───┴───┴───┴───┘
<---- c ----><-------- struct Inner (8字节) -------->
放置第三个成员 double d
规则：double 占 8 字节，对齐数是 8，必须放在 8 的倍数地址
当前结束在地址 12，下一个 8 的倍数是 16
地址 12, 13, 14, 15 空着（填充），从地址 16 开始放 d
占用：8 个格子（地址 16 ~ 23）
由于这里写不下了，就不演示了（哭笑）
struct Test4 的总大小是 24 字节，而不是 1 + 8 + 8 = 17 字节，因为中间填充了大量空字节来满足对齐规则
1.2.2.5为什么存在内存对⻬?（了解即可）
1.2.2.6修改默认对⻬数
#include
#pragma pack(1)//设置默认对⻬数为1
struct S
{
char c1;
int i;
char c2;
};
#pragma pack()//取消设置的对⻬数，还原为默认
int main()
{
//输出的结果是什么？
printf("%d
", sizeof(struct S));
return 0;
} 1.2.2.7结构体传参(记住即可)
最终结论：结构体传参，优先传指针（或地址），只有结构体特别小（比如只有 1~2 个基本类型）时，才考虑传值
原因：
1. 效率差距天壤之别
传值：结构体多大，就复制多少字节。比如结构体 1KB，传值就要复制 1024 字节，频繁调用会严重拖慢程序。
传指针：无论结构体多大，只传4 字节（32 位系统）或 8 字节（64 位系统） 的地址，复制成本几乎为 0。
2. 内存占用更少
传值会在函数栈上开辟一块新空间存副本，结构体越大，栈压力越大，甚至可能栈溢出；传指针完全没有这个问题。
3. 可直接修改原数据（需要时更方便）
如果需要函数修改结构体内容，传指针一步到位；传值还得靠返回值，麻烦且效率低。
1.2.2.8位段
一、什么是位段？
普通结构体成员按字节分配，比如 char 占 1 字节、int 占 4 字节。但有些数据根本用不到 1 字节，比如：
性别：男 / 女 → 1 位就够（0/1）
状态：开关 → 1 位
年龄：0~100 → 7 位就够（2^7=128）
分数：0~100 → 7 位
位段就是让你指定成员占几位，从而把多个小数据挤到同一个字节里，节省内存
二.位段的语法
位段的成员名后边有⼀个冒号和⼀个数字（代表比特位）
struct 位段名 {
类型 成员名 : 占用位数;
// 比如：
unsigned int sex : 1; // 占1位
unsigned int age : 7; // 占7位
unsigned int score : 7; // 占7位
};struct A
{
int _a : 2;
int _b : 5;
int _c : 10;
int _d : 30;
};
int main()
{
struct A sa = {0};
scanf("%d", &sa._b);//这是错误的
//正确的⽰范
int b = 0;
scanf("%d", &b);
sa._b = b;
return 0;
}
1.2.3 枚举
1.2.3.1枚举是什么？
枚举是一种用来定义 “一组具名的整型常量” 的类型，让代码更可读、更安全。
它的本质是：给一组相关的整数起名字，方便使用。
1.2.3.2枚举的语法规则
enum 枚举名
{
枚举常量1,
枚举常量2,
枚举常量3,
// ...
};例子：
enum Color
{
RED, // 默认 0
GREEN, // 默认 1
BLUE // 默认 2
};可以手动指定：
enum Color
{
RED = 1,
GREEN = 3,
BLUE = 5
};可以部分指定：
enum Color
{
RED = 5,
GREEN, // 6
BLUE // 7
};1.2.3.3枚举怎么用？
1. 定义枚举类型
enum Color
{
RED,
GREEN,
BLUE
};1.2.3.4 声明枚举变量
enum Color c;1.2.3.5 完整实例
#include
enum Color
{
RED,
GREEN,
BLUE
};
int main()
{
enum Color c = GREEN;
if (c == GREEN)
{
printf("绿色
");
}
return 0;
} 1.2.3.6枚举有什么用？
不用写：
if (status == 1)
而是写：
if (status == SUCCESS)用于 switch 语句，让逻辑更清晰
switch (c)
{
case RED: break;
case GREEN: break;
case BLUE: break;
}1.2.3.7枚举的好处（优点）
1. 代码可读性极高
别人一看就知道 RED、GREEN 是什么，不用猜数字含义
2. 代码更安全
枚举是类型，编译器会检查类型匹配
不会像 #define 那样没有类型检查
3. 自动赋值，不用手动写数字
默认从 0 开始自动递增，避免写错数字
4. 便于维护
增加、删除枚举常量都很方便
不会出现重复值、跳值错误
5. 调试友好
调试器会显示 RED、GREEN，而不是 0、1、2
1.2.4 联合体（共用体）
1.2.4.1联合体类型的声明
#include
// 声明一个联合体类型
union Data {
int i; // 占用 4 字节
float f; // 占用 4 字节
char str[20]; // 占用 20 字节
};
int main() {
union Data data;
printf("联合体大小：%zu 字节
", sizeof(data));
return 0;
} 这里联合体的大小就为20个字节
内存解析：
┌───────────────────────────────────────────┐
│ str[20] │ 20 字节
└───────────────────────────────────────────┘
↑
所有成员共享同一块内存的起始地址
↓
┌───────────┐
│ i │ 4 字节
└───────────┘
↓
┌───────────┐
│ f │ 4 字节
└───────────┘1.2.4.2联合体的特点
内存共享：所有成员共用同一块内存，起始地址完全相同。
互斥存储：同一时间只能有一个成员有效，修改一个成员会覆盖其他成员的值。
大小由最大成员决定：整个联合体的大小等于占用内存最大的成员的大小。
节省内存：适合在不同时刻存储不同类型数据的场景，比结构体更省空间。
//代码1
#include
//联合类型的声明
union Un
{
char c;
int i;
};
int main()
{
//联合变量的定义
union Un un = {0};
// 下⾯输出的结果是⼀样的吗？
printf("%p
", &(un.i));
printf("%p
", &(un.c));
printf("%p
", &un);
return 0;
}
输出结果：
001AF85C
001AF85C
001AF85
//代码2
#include
//联合类型的声明
union Un
{
char c;
int i;
};
int main()
{
//联合变量的定义
union Un un = {0};
un.i = 0x11223344;
un.c = 0x55;
printf("%x
", un.i);
return 0;
}
运行结果：
11223355 
1.2.4.3相同成员的结构体和联合体对比
struct S
{
char c;
int i;
};
struct S s = {0};
union Un
{
char c;
int i;
};
union Un un = {0};
1.2.4.4联合体大小的计算
union Test2 {
char arr[5]; // 大小5，对齐1（char的对齐）
int i; // 大小4，对齐4
double d; // 大小8，对齐8
};
结果：sizeof (union Test2) = 8
union Test3 {
short arr[5]; // 大小10（2*5），对齐2（short的对齐）
int i; // 大小4，对齐4
};
结果：sizeof (union Test3) = 12
struct Inner {
int a;
double b;
}; // 大小16，对齐8（double的对齐）
union Test4 {
char c;
struct Inner in; // 大小16，对齐8
};
结果：sizeof (union Test4) = 161.2.4.5联合体的实际例子
1.联合体判断系统大小端
int check_sys()
{
union Un
{
char c;
int i;
}u;
u.i = 1;
return u.c;//小端：返回1，大端：返回0
}
int main()
{
int ret = check_sys();//小端：返回1，大端：返回0
if (ret == 1)
printf("小端
");
else
printf("大端
");
return 0;
}1.2.5结构体，联合体，枚举的区别
| 特性 | 结构体 struct | 联合体 union | 枚举 enum |
|---|---|---|---|
| 成员关系 | 独立共存 | 共享同一内存 | 只是一组常量 |
| 同一时间 | 所有成员有效 | 只有一个成员有效 | 只是一个整数 |
| 内存大小 | 所有成员和 + 对齐 | 最大成员大小 | int 大小 |
| 用途 | 描述对象、组合数据 | 节省内存、类型双关 | 代替数字、状态 |
| 修改影响 | 互不影响 | 覆盖其他成员 | 只是整数赋值 |
3.运算符和表达式：
3.1 操作符和表达式的注意事项：
3.1.1 “%”的注意事项
运算符%表示求模 (余) 运算，即返回两个整数相除的余值。这个运算符只能用于整数，不能用于浮点数。
求模 (%)：只看第一个数（被除数），它是正结果就正，它是负结果就负。（其余的都是数学的运算思维）
7 % 3 = 1 // 正
(-7) % 3 = -1 // 负（跟被除数走）
7 % (-3) = 1 // 正（跟被除数走）
3.1.2 浮点数比较
错误：浮点数有精度误差
double a = 0.1 + 0.2;
if (a == 0.3) { ... } // 永远不成立！正确：判断差值是否小于极小值（如 1e-6）
if (fabs(a - 0.3) < 1e-6) { ... }3.1.3 得到浮点数结果的方法
| 方法 1：直接用浮点数参与运算（最简单） |
| 方法 2：强制类型转换（最灵活） |
| 方法 3：乘以 1.0（通用小技巧） |
3.1.4 逻辑与 &&、逻辑或 || 的短路特性
这两个运算符会短路求值：左边能确定结果时，右边不执行
int a = 0, b = 0;
// 错误：a==0 为真，|| 短路，b++ 不执行！
if (a == 0 || b++) { ... }
printf("%d", b); // 输出 0，不是 13.1.5 运算符优先级与结合性
总而言之，不确定就加括号
3.1.6 逗号表达式
int a = (3, 4, 5);//a=5
int x = 1, y = 2;
int z = (x++, y++, x + y);//x=2,y=3,z=53.2 整型提升（基于补码）
3.2.1什么是整型提升？
整型提升是 C 语言的隐式类型转换规则：在表达式计算时，所有小于 int 类型的整型（char、unsigned char、short、unsigned short），都会先自动转换成int（或unsigned int），再参与运算。简单说：小整型先 “升级” 成 int，再计算，这是编译器自动完成的，不需要你手动写代码转换。
char a = 10;
char b = 20;
char c = a + b; // 这里会发生整型提升计算a + b时，a和b都是 char（小于 int），会先各自转成 int，再相加得到 int 类型的结果，最后再把结果转回 char 赋值给c。
3.2.2为什么要有整型提升？
核心原因：让 CPU 能高效、统一地处理运算。(这里不过多赘述，自己了解即可)
3.2.3整型提升的具体规则
（有符号）signed char a = 10; // 二进制：00001010（8 位）
提升为 int：00000000 00000000 00000000 00001010（32 位），值还是 10。
（有符号） signed char b = -10; // 二进制：11110110（8 位补码）
提升为 int：11111111 11111111 11111111 11110110（32 位补码），值还是 - 10。
#include
int main() {
char a = 0xF1; // 二进制：11110001，signed char表示-15
char b = 0x05; // 二进制：00000101，signed char表示5
char c = a + b; // 先提升，再计算
// 提升后：a是0xFFFFFFF1（int，-15），b是0x00000005（int，5）
// 相加结果：0xFFFFFFF6（int，-10），再转回char：0xF6（-10）
printf("a + b = %d
", c); // 输出：-10
return 0;
} 关键点：如果不提升，直接用 8 位 char 计算0xF1 + 0x05 = 0xF6，结果和提升后一致，但这是巧合；如果数值更大，就会出现差异
例子 2：容易踩坑的 “符号位扩展”
#include
int main() {
unsigned char uc = 0x80; // 二进制：10000000，值128
signed char sc = 0x80; // 二进制：10000000，signed char表示-128
// 整型提升后：
// uc转int：0x00000080（128，无符号补0）
// sc转int：0xFFFFFF80（-128，有符号补1）
printf("uc = %u
", uc); // 输出：128
printf("sc = %d
", sc); // 输出：-128
printf("uc + sc = %d
", uc + sc); // 128 + (-128) = 0，输出0
return 0;
} 例子 3：条件判断中的提升
#include
int main() {
char a = 0x80; // signed char，值-128
if (a < 0) {
printf("a 是负数
"); // 会执行，因为a提升为int后是-128
}
unsigned char b = 0x80; // 值128
if (b < 0) {
printf("b 是负数
"); // 不会执行，b提升为int后是128，大于0
}
return 0;
} 很多新手会误以为char a = 0x80是正数，其实因为整型提升 + 有符号扩展，它实际是负数，当然这里涉及到了整数溢出
3.2.4整数溢出
3.2.4.1什么是整数溢出？
整数溢出的本质：整数类型的取值范围是固定的，当运算结果超出该类型能表示的最大 / 最小值时，就会发生溢出。
| 类型 | 位宽 | 取值范围 | 最大值 | 最小值 |
|---|---|---|---|---|
| signed char | 8 位 | -128 ~ 127 | 127（0x7F） | -128（0x80） |
| unsigned char | 8 位 | 0 ~ 255 | 255（0xFF） | 0（0x00) |
| signed short | 16 位 | -32768 ~ 32767 | 32767（0x7FFF） | -32768（0x8000） |
| unsigned short | 16 位 | 0 ~ 65535 | 65535（0xFFFF） | 0（0x00） |
| signed int | 32 位 | -2147483648 ~ 2147483647 | 2147483647（0x7FFFFFFF） | -2147483648（0x80000000） |
| unsigned int | 32 位 | 0 ~ 4294967295 | 54294967295（0xFFFFFFFF) | 0（0x00） |
只要运算结果超出这个范围，就会触发溢出
3.2.4.2有符号整数溢出：未定义行为（最危险）
溢出逻辑：补码闭环循环
有符号数的溢出遵循补码的 “折返” 规则，就像钟表盘循环：
正数溢出（超过最大值）：从最大值直接跳到最小值（如 signed char 127 + 1 = -128）；
负数溢出（低于最小值）：从最小值直接跳到最大值（如 signed char -128 - 1 = 127）。
#include
int main() {
// 1. 正数溢出：127 + 1 = -128
signed char a = 127;
signed char b = a + 1; // 溢出，未定义行为，实际结果-128
printf("127 + 1 = %d
", b); // 输出：-128
// 2. 负数溢出：-128 - 1 = 127
signed char c = -128;
signed char d = c - 1; // 溢出，未定义行为，实际结果127
printf("-128 - 1 = %d
", d); // 输出：127
// 3. int溢出：2147483647 + 1 = -2147483648
int e = 2147483647;
int f = e + 1;
printf("2147483647 + 1 = %d
", f); // 输出：-2147483648
return 0;
} 3.2.4.3无符号整数溢出
无符号数溢出会循环回到 0，形成闭环
3.2.4.4溢出逻辑：模 2^n 运算
最大值 + 1 = 0（如 unsigned char 255 + 1 = 0）；
0 - 1 = 最大值（如 unsigned char 0 - 1 = 255）。
#include
int main() {
// 1. 正数溢出：255 + 1 = 0（模256）
unsigned char a = 255;
unsigned char b = a + 1;
printf("255 + 1 = %u
", b); // 输出：0
// 2. 负数溢出：0 - 1 = 255（模256）
unsigned char c = 0;
unsigned char d = c - 1;
printf("0 - 1 = %u
", d); // 输出：255
// 3. unsigned int溢出：4294967295 + 1 = 0（模2^32）
unsigned int e = 4294967295;
unsigned int f = e + 1;
printf("4294967295 + 1 = %u
", f); // 输出：0
return 0;
}
3.3 原码、反码、补码
整数的2进制表⽰⽅法有三种，即原码、反码和补码
计算机底层只认识 0 和 1，它不知道什么是 “负号”。为了表示负数，同时让加法和减法能用同一套电路实现，计算机科学家发明了这三种编码。
总结：
| 原码 | 人看的（直观）
计算：补码取反，+1就得到原码
|
| 反码 | 过渡用的（桥梁） 计算：原码取反得到反码 取反可以用单目（位）操作符“~” |
| 补码 | 计算机存储和运算时，一律使用补码！ 因此3.4节的移位操作都是用补码进行运算的
计算：原码取反，+1就得到补码
|
3.4 位操作符：&、|、^
注意：他们的操作数必须是整数
| 运算符 | 中文名 | 运算逻辑 | 简单记忆 |
|---|---|---|---|
| & | 按位与 | 同位都为 1，结果才是 1 | 像 “且”，必须都满足 |
| | | 按位或 | 同位有 1 则 1，全 0 才 0 | 像 “或”，满足一个就行 |
| ^ | 按位异或 | 同位一样是 0，反之则1 | 找不同 |
3.4.1 按位与 &（全 1 才 1）
5 的 32 位补码：0000 0000 0000 0000 0000 0000 0000 0101
3 的 32 位补码：0000 0000 0000 0000 0000 0000 0000 0011
5&3后的结果是：0000 0000 0000 0000 0000 0000 0000 0001(结果为1)
3.4.1.1 按位与 &的实际例子
1.判断奇偶：（和1按位与，为1则为奇数，为0则为偶数）num & 1
if (a & 1) {
printf("%d 是奇数
", a); // 5 & 1 = 1，输出奇数
}2.判断某一位是否为 1：（看的是原码的某一位）num & (1 << n)
num & (1 << n)//右移n位3.判断是否是 2 的幂：（判断是不是2的次方根）n & (n - 1) == 0
n & (n - 1) == 0
8 → 1000
8-1=7 → 0111
& 后 → 0000 → 是2的幂
10 → 1010
10-1=9 → 1001
& 后 → 1000 → 不是2的幂4.清零最低位的 1：n & (n - 1)
n & (n - 1)
14 → 1110
14-1=13 → 1101
& 后 → 1100 → 123.4.2按位或 |（有 1 则 1）
5 的 32 位补码：0000 0000 0000 0000 0000 0000 0000 0101
3 的 32 位补码：0000 0000 0000 0000 0000 0000 0000 0011
5|3后的结果是：0000 0000 0000 0000 0000 0000 0000 0111(结果为7)
3.4.2.1 按位或|的实际例子
1.设置某一位为 1（最常用）num | (1 << n)
int num = 8;
int result = num | (1 << 2); // 把第2位设为1
// result = 122.设置最后 k 位为 1 num | ((1 << k) - 1)
int num = 16;
int result = num | ((1 << 3) - 1); // 最后3位全1
// result = 233.快速取最大值（仅限非负数）a | b = max(a, b)（当其中一个数的二进制位完全包含另一个时）
int a = 8;
int b = 12;
int max_val = a | b; // 直接得到最大值123.4.3 按位异或 ^（相同为 0，不同为 1）
5 的 32 位补码：0000 0000 0000 0000 0000 0000 0000 0101
3 的 32 位补码：0000 0000 0000 0000 0000 0000 0000 0011
5^3后的结果是：0000 0000 0000 0000 0000 0000 0000 0110(结果为6）
异或运算有两个逆天的性质，这是交换的关键：
- 归零律：
a ^ a = 0（任何数异或自己，等于 0） - 恒等律：
a ^ 0 = a（任何数异或 0，等于自己）
3.4.2.1 按位异或^的实际例
1.交换两个变量（不用临时变量）
int x = 10, y = 20;
printf("交换前: x=%d, y=%d
", x, y);
x = x ^ y;
y = x ^ y;
x = x ^ y;
printf("交换后: x=%d, y=%d
", x, y); // 输出 x=20, y=10| 步骤 | 含义 | 此时状态 |
|---|---|---|
第一步：x = x ^ y; | 把 x 和 y 的 “差异值” 存到 x 里 |
|
第二步：y = x ^ y; | 用 “差异值” 去异或原来的 y，把原来的 x 算出来，并存到 y 里 |
|
第三步：x = x ^ y; | 用 “差异值” 去异或现在的 y（原来的 x），把原来的 y 算出来，存到 x 里。 |
|
第二步的推导：
y = (x ^ y) ^ y
根据结合律：y = x ^ (y ^ y)
根据归零律：y = x ^ 0
根据恒等律：y = x
第三步的推导：（直接记住A和B的差异值异或A得B,异或B得A，反着来）
x = (x ^ y) ^ y （注意：这里的 y 已经是原来的 x 了）
x = x ^ (y ^ y)
x = x ^ 0
x = y
2.找出数组中唯一出现一次的数（LeetCode 经典题）
核心思路：利用 x ^ x = 0，相同数异或抵消，最后剩下的就是唯一数
int findUnique(int arr[], int n) {
int res = 0;
for (int i = 0; i < n; i++) {
res ^= arr[i];
}
return res;
}
// 例子：arr = [1,2,3,2,1]，输出 33.翻转某一位：（原码中0 变 1，1 变 0）num ^= (1 << n);
int num = 5;
num ^= (1 << 2); // 翻转第2位
// num = 14.判断两个数符号是否不同 (a ^ b) < 0
int a = 5, b = -3;
if ((a ^ b) < 0) {
printf("符号不同");
} else {
printf("符号相同");
}
// 输出：符号不同3.5移位操作符
3.5.1 左移操作符<<
int a = 3; // 二进制：0000 0011
int b = a << 1; // 左移1位 → 0000 0110 → 6
int c = a << 2; // 左移2位 → 0000 1100 → 12
理解：正数左移（以 10 为例）
原值：0000 0000 0000 0000 0000 0000 0000 1010 (10)
左移：整体往左挪一位，右边补 0
结果：0000 0000 0000 0000 0000 0000 0001 0100 (20)
理解：正数左移（以-10 为例）
原值：1111 1111 1111 1111 1111 1111 1111 0110 (-10)
左移：整体往左挪一位，右边补 0
结果：1111 1111 1111 1111 1111 1111 1110 1100 (-20)
3.5.2 右移操作符>>
int a = 12; // 0000 1100
int b = a >> 1; // 0000 0110 → 6
int c = a >> 2; // 0000 0011 → 3
int d = a >> 3; // 0000 0001 → 1
int a = -12; // 补码：1111 0100
int b = a >> 1; // 1111 1010 → 补码，转十进制是 -6
int c = a >> 2; // 1111 1101 → 补码，转十进制是 -3
int d = a >> 3; // 1111 1110 → 补码，转十进制是 -2
上面的-1为特殊例子，补码全是1，就是-1，它右移永远是-1
理解： 正数右移（以 10 为例）
原值：0000 0000 0000 0000 0000 0000 0000 1010 (10)
右移：整体往右挪一位，左边补符号位（正数补 0）
结果：0000 0000 0000 0000 0000 0000 0000 0101 (5)
理解： 正数右移（以-10 为例）
原值：1111 1111 1111 1111 1111 1111 1111 0110 (-10)
右移：整体往右挪一位，左边补符号位（负数补 1）
结果：1111 1111 1111 1111 1111 1111 1111 1011 (-5)
4.通用占位符（需完全掌握）
| 占位符 | 含义 | 适用场景 | 示例 |
|---|---|---|---|
| %d | 十进制整数 | 输出整数（int） | 年龄：%d → 年龄：18 |
| %f | 浮点数 | 输出小数（float/double） | 分数：%f → 分数：95.5 |
| %.[n]f | 保留 n 位小数的浮点数 | 金额、精度要求高的场景 | 金额：%.2f → 金额：100.00 |
| %s | 字符串 | 输出文本（str） | 姓名：%s → 姓名：张三 |
|
%.[m]s
| 有长度限制的字符串 | 只输出字符串的前 m 个字符 | printf("%.5s", "HelloWorld"); |
| %c | 单个字符 | 输出单个字母 / 符号 | 字符：%c → 字符：A |
| %p | pointer（指针） | 输出变量的内存地址（十六进制格式） | int a=10; printf("%p", &a); |
| %zd | size_t（无符号整数） | 输出 sizeof() 等返回的无符号整数值 | printf("%zd", sizeof(int)); |
| %o | octal（八进制） | 权限表示（Linux 文件权限）、进制转换 | printf("%o", 10); |
| %% | 输出百分号本身 | 文本中需要显示% | 占比：%d%% → 占比：50% |
| %x | 十六进制整数 | 进制转换、内存地址 | 十六进制：%x → 十六进制：1a |
| %5d | 右对齐（默认） | 不加符号，数字 = 总宽度，内容靠右，左边补空格 | |
| %-5d | 左对齐 | 加负号 -，数字 = 总宽度，内容靠左，右边补空格 |
5.数据在内存中的存储
5.1什么是大小端？
这里的的0x11223344是一个具体的数值只不过是用十六进制的格式呈现的
而这里的44332211是数值在电脑内存里的实际存储方式
0x11223344：是一个 32 位的整数，我们人类习惯
从左到右（高字节到低字节）书写
44 33 22 11：是这个 32 位数在小端序系统下的存储方式，把最低字节
44 放在了最低地址，这里是
从左到右（低地址到高地址）
5.2大小端例子（和联合体中的实际例子一起看）
#include
int check_sys()
{
int i = 1;
return (*(char *)&i);
}
int main()
{
int ret = check_sys();
if(ret == 1)
{
printf("⼩端
");
}
else
{
printf("⼤端
");
}
return 0;
} 判断大小端，我们只需要知道他在内存中第一个字节处是否为0/1即可
我们以一个最简单的 4 字节整数 1 为例：
十六进制：0x00000001
字节拆分：00 (高字节)、00、00、01 (低字节)
判断大小端，只需要看最低地址（第一个字节存的是 01 还是 00)：
如果第一个字节是 01（低字节） → 小端序（低字节放低地址）
如果第一个字节是 00（高字节） → 大端序（高字节放低地址）
以上的概念都是围绕整数进行展开的。
5.3浮点数的存储（自行了解）
6.库函数
6.1字符函数（头文件：
6.2字符串操作库函数（头文件：
1.strlen
原型：size_t strlen ( const char * str );
功能：计算字符串长度（不包含 ，从起始地址到 的字符数）
考点：与sizeof的区别（strlen是函数，算有效字符；sizeof是运算符，算内存大小）
|
sizeof
|
strlen
|
|---|---|
|
1.
sizeof是操作符
|
1.
strlen是库函数，使⽤需要包含头⽂件
string.h
|
|
2.
sizeof计算操作数所占内存的
⼤⼩，单位是字节
|
2.
srtlen是求字符串⻓度的，统计的是
之前字符的个数
|
|
3.
不关注内存中存放什么数据
|
3.
关注内存中是否有
，如果没有
，就会持续往后找，可能
会越界
|
strlen的模拟实现：
1.计数器方式
//计数器⽅式
int my_strlen(const char * str)
{
int count = 0;
assert(str);
while(*str)
{
count++;
str++;
}
return count;
}2.不创建临时变量（递归）
//不能创建临时变量计数器
int my_strlen(const char * str)
{
assert(str);
if(*str == ' ')
return 0;
else
return 1+my_strlen(str+1);
}3.指针减指针
//指针-指针的⽅式
int my_strlen(char *s)
{
assert(str);
char *p = s;
while(*p != ' ' )
p++;
return p-s;
}2.strcpy
原型：char * strcpy ( char * destination, const char * source );
功能：字符串复制（将源字符串 前所有字符复制到目标空间，包含 ）
考点：目标空间必须足够大、可修改；源字符串必须以 结尾
strcpy的模拟实现
char* my_strcpy(char *dest, const char*src)
{
char *ret = dest;
assert(dest != NULL);
assert(src != NULL);
while((*dest++ = *src++))
{
;
}
return ret;
}3.strcmp
原型：int strcmp ( const char * str1, const char * str2 );
功能：字符串比较（逐字符比较 ASCII 值，相等返回 0，大于返回正数，小于返回负数）
考点：不是比较长度，是逐字符对比；返回值非只有 ±1（不同编译器可能不同）
strcmp的模拟实现
int my_strcmp (const char * str1, const char * str2)
{
int ret = 0 ;
assert(str1 != NULL);
assert(str2 != NULL);
while(*str1 == *str2)
{
if(*str1 == ' ')
return 0;
str1++;
str2++;
}
return *str1-*str2;
}4.strcat
原型：char * strcat ( char * destination, const char * source );
功能：字符串拼接（将源字符串拼接到目标字符串末尾，覆盖目标原 ，新增 ）
考点：目标空间必须足够大、可修改；目标和源字符串都需以 结尾
strcat的模拟实现
char *my_strcat(char *dest, const char*src)
{
char *ret = dest;
assert(dest != NULL);
assert(src != NULL);
while(*dest)
{
dest++;
}
while((*dest++ = *src++))
{
;
}
return ret;
}5.strstr
原型：char * strstr ( const char * str1, const char * str2 );
功能：查找子串（在主串str1中查找第一次出现的子串str2，找到返回子串地址，没找到返 回NULL）
考点：返回值是地址，需用char*接收；子串为空时返回主串首地址
strstr的模拟实现
char * strstr (const char * str1, const char * str2)
{
char *cp = (char *) str1;
char *s1, *s2;
if ( !*str2 )
return((char *)str1);
while (*cp)
{
s1 = cp;
s2 = (char *) str2;
while ( *s1 && *s2 && !(*s1-*s2) )
s1++, s2++;
if (!*s2)
return(cp);
cp++;
}
return(NULL);
}6.strncpy
原型：char * strncpy ( char * destination, const char * source, size_t num );
功能：指定长度复制（最多复制num个字符，源字符串长度 <num则补' '，源字符串长度≥num则不补' '）
考点：可能不自动补 ，需手动处理；目标空间至少num字节
strncpy的模拟实现
char* my_strncpy(char* dest, const char* src, size_t num)
{
// 保存目标起始地址，最后要返回
char* start = dest;
// 1. 先复制最多 num 个字符
while (num && (*dest = *src))
{
dest++;
src++;
num--;
}
// 2. 如果源字符串已经结束，但还没复制够 num 个，补
while (num--)
{
*dest = ' ';
dest++;
}
return start;
}7.strncmp
原型：int strncmp ( const char * str1, const char * str2, size_t num );
功能：指定长度比较（最多比较前num个字符，规则同strcmp）
考点：前num个字符相等则返回 0，无需比较整个字符串
strncmp的模拟实现
int my_strncmp(const char* str1, const char* str2, size_t num)
{
// 先判断 num 是否为 0，为 0 直接返回 0
if (num == 0)
return 0;
// 逐字符比较，最多比较 num 个字符
while (num > 0 && *str1 == *str2)
{
num--;
// 如果已经到字符串末尾，说明相等
if (*str1 == ' ')
return 0;
str1++;
str2++;
}
// 走到这里，说明字符不相等 或 num 已用完
return *str1 - *str2;
}
8.strncat
原型：char * strncat ( char * destination, const char * source, size_t num );
功能：从‘ ’开始指定长度拼接（最多拼接num个字符，拼接后自动补 ）
考点：目标空间需预留num+1字节（存 ）；不会覆盖目标原有效字符
strncat的模拟实现
char* my_strncat(char* dest, const char* src, size_t num)
{
// 保存目标起始地址，最后要返回
char* start = dest;
// 1. 先找到 dest 的末尾
while (*dest != ' ')
{
dest++;
}
// 2. 从 dest 的 处开始，最多复制 num 个字符
while (num && (*src != ' '))
{
*dest = *src;
dest++;
src++;
num--;
}
// 3. 最后必须手动加上 （strncat 一定会补 ）
*dest = ' ';
return start;
}6.3内存操作库函数（头文件：
核心特点：不关心 ，直接操作内存块（适用于所有数据类型）
1.memcpy
原型：void * memcpy ( void * destination, const void * source, size_t num );
功能：内存复制（从源内存复制num字节到目标内存，不处理内存重叠）
考点：与strcpy区别（memcpy不限字符串，可复制任意数据；不遇 停止）
memcpy的模拟实现
void * memcpy ( void * dst, const void * src, size_t count)
{
void * ret = dst;
assert(dst);
assert(src);
while (count--) {
*(char*)dst++ = *(char*)src++;
}
return(ret);
}2.memmove
原型：void * memmove ( void * destination, const void * source, size_t num );
功能：内存移动（功能同memcpy，但可安全处理内存重叠场景）
考点：优先用memmove，兼容性更强；重叠时memcpy会出错
memmove的模拟实现
void* my_memmove(void* dest, const void* src, size_t count)
{
// 保存目标起始地址
void* start = dest;
// 判断是否重叠，决定拷贝方向
if (dest <= src || (char*)dest >= (char*)src + count)
{
// 不重叠 → 从前往后拷贝
while (count--)
{
*(char*)dest++ = *(char*)src++;
}
}
else
{
// 重叠 → 从后往前拷贝
dest = (char*)dest + count - 1;
src = (char*)src + count - 1;
while (count--)
{
*(char*)dest-- = *(char*)src--;
}
}
return start;
}3.memset
原型：void *memset(void *ptr, int value, size_t num);
功能：把一段内存的前 num 个字节，全部设置为 value（按字节赋值）
4.memcmp
原型：int memcmp(const void *ptr1, const void *ptr2, size_t num);
功能：比较两段内存的前 num 个字节，逐字节比较。
考点：逐字节比较内存，不关心字符串结束符
6.4动态内存管理库函数（头文件：
核心特点：在堆区申请 / 释放内存，大小运行时确定，需手动管理
1.malloc
原型：void * malloc ( size_t size );
功能：动态申请内存（申请size字节连续内存，不初始化，返回void*地址）
考点：申请失败返回NULL，必须判空；返回值需强转对应类型；内存为随机值
#include
#include
int main()
{
int num = 0;
scanf("%d", &num);
int arr[num] = {0};
int* ptr = NULL;
ptr = (int*)malloc(num*sizeof(int)); 2.calloc
原型：void * calloc ( size_t num, size_t size );
功能：动态申请并初始化内存（申请num个、每个size字节的连续内存，自动清 0）
考点：参数是(个数, 单个大小)；等价于malloc + memset(0)；适合数组初始化
函数的功能是为 num 个⼤⼩为 size 的元素开辟⼀块空间，并且把空间的每个字节初始化为0
#include
#include
int main()
{
int *p = (int*)calloc(10, sizeof(int));
if(NULL != p)
{
int i = 0;
for(i=0; i<10; i++)
{
printf("%d ", *(p+i));
}
}
free(p);
p = NULL;
return 0;
}
输出结果：
0 0 0 0 0 0 0 0 0 0 3.realloc
原型：void * realloc ( void * ptr, size_t size );
功能：调整已分配内存大小（扩大 / 缩小原内存块，返回新地址）
考点：扩大时可能搬迁内存，需用新指针接收；原指针失效，避免野指针；失败返回NULL
#include
#include
int main()
{
int *ptr = (int*)malloc(100);
if(ptr != NULL)
{
//业务处理
}
else
{
return 1;
}
//扩展容量
//代码1 - 直接将realloc的返回值放到ptr中
ptr = (int*)realloc(ptr, 1000);//这样可以吗？(如果申请失败会如何？)
//代码2 - 先将realloc函数的返回值放在p中，不为NULL，在放ptr中
int*p = NULL;
p = realloc(ptr, 1000);
if(p != NULL)
{
ptr = p;
}
//业务处理
free(ptr);
return 0;
} 6.5通用算法库函数（头文件：
核心特点：通用型算法，适用于多种数据类型（需自定义比较函数）
1.qsort
原型：void qsort ( void * base, size_t num, size_t size, int (*compar)(const void *, const void *) );
| void *base | 待排序数组的起始地址（指向数组第一个元素） |
| size_t num | 数组元素个数 |
| size_t size | 数组中每个元素的大小（字节数） |
| int (*compar)(const void *, const void *) | 比较函数的指针（函数指针） |
功能：快速排序（对任意数据类型的数组排序，基于快速排序算法）
考点：需自定义compar比较函数（返回值规则同strcmp）；可排序 int/char/ 结构体等
直接看例子：
#include
#include
#include
struct stu
{
char name[20];
int age;
};
void print(int* p, int sz)
{
int i;
for (i = 0; i < sz; i++)
{
printf("%d ", *(p + i));
}
printf("
");
}
void print1(struct stu* p3,int sz)
{
int i;
for (i = 0; i < sz; i++)
{
printf("%s ",(p3+i)->name);
printf("
");
}
}
void print2(struct stu* p3,int sz)
{
int i;
for (i = 0; i < sz; i++)
{
printf("%d ", (p3+i)->age);
printf("
");
}
}
void print3(char* p,int sz)
{
int i;
for (i = 0; i < sz; i++)
{
printf("%c", *(p + i));
}
printf("
");
}
int cmp_int(const void* p1, const void* p2)
{
return *(int*)p1 - *(int*)p2;
}
int cmp_by_name(const void* p1,const void* p2)
{
return strcmp(((struct stu*)p1)->name, ((struct stu*)p2)->name);//结构体指针的间接访问，想用->就要左边是结构体指针，右边是成员名
}
int cmp_by_age(const void* p1, const void* p2)
{
return ((struct stu*)p1)->age - ((struct stu*)p2)->age;
}
int cmp_char(const void* p1, const void* p2)
{
return *(char*)p1 - *(char*)p2;
}
void test1()
{
int a[] = { 1,3,2,4,5,9,8,7,6 };
int sz = sizeof(a) / sizeof(a[0]);
qsort(a, sz, sizeof(a[0]), cmp_int);
print(a, sz);
}
void test2()
{
struct stu arr[3] = { {"zhangsan",20},{"lisi",35},{"wangwu",18} };
int sz = sizeof(arr) / sizeof(arr[0]);
qsort(arr, sz, sizeof(arr[0]), cmp_by_name);
print1(arr,sz);
}
void test3()
{
struct stu arr[3] = { {"zhangsan",20},{"lisi",35},{"wangwu",18} };
int sz = sizeof(arr) / sizeof(arr[0]);
qsort(arr, sz, sizeof(arr[0]), cmp_by_age);
print2(arr,sz);
}
void test4()
{
char a[] = { 'b','a','d','c','f','e' };
int sz = sizeof(a) / sizeof(a[0]);
qsort(a, sz, sizeof(a[0]), cmp_char);
print3(a,sz);
}
int main()
{
test1();
test2();
test3();
test4();
return 0;
} qsort的模拟实现
#include
#include//用size_t类型就要包含该头文件，stddef.h
Swap(char* p1, char* p2,size_t width)
{
int i;
for (i = 0; i < width; i++)
{
char tem = *p1;
*p1 = *p2;
*p2 = tem;
p1++;
p2++;
}
}
int cmp(const void* p1, const void* p2)
{
return *(int*)p1 - *(int*)p2;
}
void Bubble_sort(const void* base, size_t sz, size_t width,
int(*cmp)(const void* p1,const void* p2))
{
int i,j;
for (i = 0; i < sz-1; i++)
{
for (j = 0; j< sz - 1 - i; j++)
{
if (cmp((char*)base+ +width * j, (char*)base + width * (j + 1))>0)//char*是指针偏移的最小单位（1字节），width适配任意类型寻址
{
Swap((char*)base + width * j, (char*)base + width * (j + 1),width);
}
}
}
}
print1(int* p,int sz)
{
int i;
for (i = 0; i < sz; i++)
{
printf("%d ", *(p + i));
}
}
test1()
{
int a[] = { 3,2,5,6,1,7,9,8,0 };
int sz = sizeof(a) / sizeof(a[0]);
Bubble_sort(a, sz, sizeof(a[0]), cmp);
print1(a, sz);
}
int main()
{
test1();
return 0;
