理解C语言之深入理解指针

一、

[1. 内存和地址](#1. 内存和地址)

[1.1 内存](#1.1 内存)

[1.2 究竟该如何理解编址](#1.2 究竟该如何理解编址)

[2. 指针变量和地址](#2. 指针变量和地址)

[2.1 取地址操作符（&）](#2.1 取地址操作符（&）)

[2.2 指针变量和解引⽤操作符（*）](#2.2 指针变量和解引⽤操作符（*）)

[2.2.1 指针变量](#2.2.1 指针变量)

[2.2.2 如何拆解指针类型](#2.2.2 如何拆解指针类型)

[2.2.3 解引⽤操作符](#2.2.3 解引⽤操作符)

[2.3 指针变量的⼤⼩](#2.3 指针变量的⼤⼩)

[3. 指针变量类型的意义](#3. 指针变量类型的意义)

[3.1 指针的解引⽤](#3.1 指针的解引⽤)

[3.2 指针+-整数](#3.2 指针+-整数)

[3.3 void* 指针](#3.3 void* 指针)

[4. const修饰指针](#4. const修饰指针)

[4.1 const修饰变量](#4.1 const修饰变量)

[4.2 const修饰指针变量](#4.2 const修饰指针变量)

[5. 指针运算](#5. 指针运算)

[5.1 指针+-整数](#5.1 指针+-整数)

[5.2 指针-指针](#5.2 指针-指针)

[5.3 指针的关系运算](#5.3 指针的关系运算)

[6. 野指针](#6. 野指针)

[6.1 野指针成因](#6.1 野指针成因)

[6.2 如何规避野指针](#6.2 如何规避野指针)

[6.2.1 指针初始化](#6.2.1 指针初始化)

[6.2.2 ⼩⼼指针越界](#6.2.2 ⼩⼼指针越界)

[6.2.3 指针变量不再使⽤时，及时置NULL，指针使⽤之前检查有效性](#6.2.3 指针变量不再使⽤时，及时置NULL，指针使⽤之前检查有效性)

[6.2.4 避免返回局部变量的地址](#6.2.4 避免返回局部变量的地址)

[7. assert断⾔](#7. assert断⾔)

[8. 指针的使⽤和传址调⽤](#8. 指针的使⽤和传址调⽤)

[8.1 strlen的模拟实现](#8.1 strlen的模拟实现)

[8.2 传值调⽤和传址调⽤](#8.2 传值调⽤和传址调⽤)

二、

[1. 数组名的理解](#1. 数组名的理解)

[2. 使⽤指针访问数组](#2. 使⽤指针访问数组)

[3. ⼀维数组传参的本质](#3. ⼀维数组传参的本质)

[4. 冒泡排序](#4. 冒泡排序)

[5. ⼆级指针](#5. ⼆级指针)

[6. 指针数组](#6. 指针数组)

[7. 指针数组模拟⼆维数组](#7. 指针数组模拟⼆维数组)

三、

[1. 字符指针变量](#1. 字符指针变量)

[2. 数组指针变量](#2. 数组指针变量)

[2.1 数组指针变量是什么？](#2.1 数组指针变量是什么？)

[2.2 数组指针变量怎么初始化](#2.2 数组指针变量怎么初始化)

[3. ⼆维数组传参的本质](#3. ⼆维数组传参的本质)

[4. 函数指针变量](#4. 函数指针变量)

[4.1 函数指针变量的创建](#4.1 函数指针变量的创建)

[4.2 函数指针变量的使⽤](#4.2 函数指针变量的使⽤)

[4.3 两段有趣的代码](#4.3 两段有趣的代码)

[4.3.1 typedef 关键字](#4.3.1 typedef 关键字)

[5. 函数指针数组](#5. 函数指针数组)

[6. 转移表](#6. 转移表)

四、

[1. 回调函数是什么？](#1. 回调函数是什么？)

[2. qsort使⽤举例](#2. qsort使⽤举例)

[2.1 使⽤qsort函数排序整型数据](#2.1 使⽤qsort函数排序整型数据)

[2.2 使⽤qsort排序结构数据](#2.2 使⽤qsort排序结构数据)

[3. qsort函数的模拟实现](#3. qsort函数的模拟实现)

五、

[1. sizeof和strlen的对⽐](#1. sizeof和strlen的对⽐)

[1.1 sizeo](#1.1 sizeo)

[1.2 strlen](#1.2 strlen)

[1.3 sizeof和strlen的对⽐](#1.3 sizeof和strlen的对⽐)

[2. 数组和指针笔试题解析](#2. 数组和指针笔试题解析)

[2.1 ⼀维数组](#2.1 ⼀维数组)

[2.2 字符数组](#2.2 字符数组)

[2.3 ⼆维数组](#2.3 ⼆维数组)

[3. 指针运算笔试题解析](#3. 指针运算笔试题解析)

[3.1 题⽬1：](#3.1 题⽬1：)

[3.2 题⽬2](#3.2 题⽬2)

[3.3 题⽬3](#3.3 题⽬3)

[3.4 题⽬4](#3.4 题⽬4)

[3.5 题⽬5](#3.5 题⽬5)

[3.6 题⽬6](#3.6 题⽬6)

[3.7 题⽬7](#3.7 题⽬7)

一、

1. 内存和地址

1.1 内存

在讲内存和地址之前，我们想有个⽣活中的案例：

有⼀栋宿舍楼，把你放在楼⾥，楼上有100个房间，但是房间没有编号，你的⼀个朋友来找你玩，如果想找到你，就得挨个房⼦去找，这样效率很低，但是我们如果根据楼层和楼层的房间的情况，给每个房间编上号，如：

一楼：101，102，103...

⼆楼：201，202，203....

.......

有了房间号，如果你的朋友得到房间号，就可以快速的找房间，找到你。

⽣活中，每个房间有了房间号，就能提⾼效率，能快速的找到房间。

如果把上⾯的例⼦对照到计算机中，⼜是怎么样呢？

我们知道计算机上CPU（中央处理器）在处理数据的时候，需要的数据是在内存中读取的，处理后的数据也会放回内存中，那我们买电脑的时候，电脑上内存是8GB/16GB/32GB等，那这些内存空间如何⾼效的管理呢？

其实也是把内存划分为⼀个个的内存单元，每个内存单元的⼤⼩取1个字节。计算机中常⻅的单位（补充）：⼀个⽐特位可以存储⼀个2进制的位1或者0

1byte = 8bit

1KB = 1024byte

1MB = 1024KB

1GB = 1024MB

1TB = 1024GB

1PB = 1024TB

其中，每个内存单元，相当于⼀个学⽣宿舍，⼀个字节空间⾥⾯能放8个⽐特位，就好⽐同学们住的⼋⼈间，每个⼈是⼀个⽐特位。

每个内存单元也都有⼀个编号（这个编号就相当于宿舍房间的⻔牌号），有了这个内存单元的编号，CPU就可以快速找到⼀个内存空间。

⽣活中我们把⻔牌号也叫地址，在计算机中我们把内存单元的编号也称为地址。C语⾔中给地址起了新的名字叫：指针。所以我们可以理解为：

内存单元的编号==地址==指针

1.2 究竟该如何理解编址

CPU访问内存中的某个字节空间，必须知道这个字节空间在内存的什么位置，⽽因为内存中字节很多，所以需要给内存进⾏编址(就如同宿舍很多，需要给宿舍编号⼀样)。计算机中的编址，并不是把每个字节的地址记录下来，⽽是通过硬件设计完成的。钢琴、吉他上⾯没有写上"剁、来、咪、发、唆、拉、西"这样的信息，但演奏者照样能够准确找到每⼀个琴弦的每⼀个位置，这是为何？因为制造商已经在乐器硬件层⾯上设计好了，并且所有的演奏者都知道。本质是⼀种约定出来的共识！

⾸先，必须理解，计算机内是有很多的硬件单元，⽽硬件单元是要互相协同⼯作的。所谓的协同，⾄少相互之间要能够进⾏数据传递。但是硬件与硬件之间是互相独⽴的，那么如何通信呢？答案很简单，⽤"线"连起来。⽽CPU和内存之间也是有⼤量的数据交互的，所以，两者必须也⽤线连起来。不过，我们今天关⼼⼀组线，叫做地址总线。

硬件编址也是如此我们可以简单理解，32位机器有32根地址总线，每根线只有两态，表⽰0,1【电脉冲有⽆】，那么⼀根线，就能表⽰2种含义，2根线就能表⽰4种含义，依次类推。32根地址线，就能表⽰2^32种含义，每⼀种含义都代表⼀个地址。地址信息被下达给内存，在内存上，就可以找到该地址对应的数据，将数据在通过数据总线传⼊ CPU内寄存器。

2. 指针变量和地址

2.1 取地址操作符（&）

理解了内存和地址的关系，我们再回到C语⾔，在C语⾔中创建变量其实就是向内存申请空间，⽐如：

⽐如，上述的代码就是创建了整型变量a，内存中申请4个字节，⽤于存放整数10，其中每个字节都有地址，上图中4个字节的地址分别是：

0x006FFD70

0x006FFD71

0x006FFD72

0x006FFD73

那我们如何能得到a的地址呢？这⾥就得学习⼀个操作符(&)-取地址操作符

cpp 复制代码

#include <stdio.h>

int main()
{
     int a = 10;
     &a;//取出a的地址 
     printf("%p\n", &a);
     return 0;
}

按照我画图的例⼦，会打印处理：006FFD70&a取出的是a所占4个字节中地址较⼩的字节的地址。

虽然整型变量占⽤4个字节，我们只要知道了第⼀个字节地址，顺藤摸⽠访问到4个字节的数据也是可⾏的。

2.2 指针变量和解引⽤操作符（*）

2.2.1 指针变量

那我们通过取地址操作符(&)拿到的地址是⼀个数值，⽐如：0x006FFD70，这个数值有时候也是需要存储起来，⽅便后期再使⽤的，那我们把这样的地址值存放在哪⾥呢？答案是：指针变量中。⽐如：

cpp 复制代码

#include <stdio.h>

int main()
{
     int a = 10;
     int * pa = &a;//取出a的地址并存储到指针变量pa中 
 
     return 0;
}

指针变量也是⼀种变量，这种变量就是⽤来存放地址的，存放在指针变量中的值都会理解为地址。

2.2.2 如何拆解指针类型

我们看到pa的类型是 int*，我们该如何理解指针的类型呢？

int a = 10;

int * pa = &a;

这⾥pa左边写的是int* ，* 是在说明pa是指针变量，⽽前⾯的int 是在说明pa 指向的是整型**(int)**类型的对象。

那如果有⼀个char类型的变量ch，ch的地址，要放在什么类型的指针变量中呢？

char ch = 'w';

pc = &ch;//pc 的类型怎么写呢？

2.2.3 解引⽤操作符

我们将地址保存起来，未来是要使⽤的，那怎么使⽤呢？

在现实⽣活中，我们使⽤地址要找到⼀个房间，在房间⾥可以拿去或者存放物品。

C语⾔中其实也是⼀样的，我们只要拿到了地址（指针），就可以通过地址（指针）找到地址（指针）指向的对象，这⾥必须学习⼀个操作符叫解引⽤操作符(*)。

cpp 复制代码

#include <stdio.h>
int main()
{
     int a = 100;
     int* pa = &a;
     *pa = 0;
     return 0;
}

上⾯代码中第7⾏就使⽤了解引⽤操作符， *pa 的意思就是通过pa中存放的地址，找到指向的空间， *pa 其实就是a变量了；所以***pa=0** ，这个操作符是把a改成了0. 有同学肯定在想，这⾥如果⽬的就是把a 改成0 的话，写成a = 0; 不就完了，为啥⾮要使⽤指针呢？

其实这⾥是把a的修改交给了pa来操作，这样对a的修改，就多了⼀种的途径，写代码就会更加灵活，后期慢慢就能理解了。

2.3 指针变量的⼤⼩

前⾯的内容我们了解到，32位机器假设有32根地址总线，每根地址线出来的电信号转换成数字信号后是1或者0，那我们把32根地址线产⽣的2进制序列当做⼀个地址，那么⼀个地址就是32个bit位，需要4 个字节才能存储。

如果指针变量是⽤来存放地址的，那么指针变的⼤⼩就得是4个字节的空间才可以。

同理64位机器，假设有64根地址线，⼀个地址就是64个⼆进制位组成的⼆进制序列，存储起来就需要 8个字节的空间，指针变量的⼤⼩就是8个字节。

cpp 复制代码

#include <stdio.h>

//指针变量的⼤⼩取决于地址的⼤⼩ 

//32位平台下地址是32个bit位（即4个字节） 

//64位平台下地址是64个bit位（即8个字节） 

int main()
{
     printf("%zd\n", sizeof(char *));
     printf("%zd\n", sizeof(short *));
     printf("%zd\n", sizeof(int *));
     printf("%zd\n", sizeof(double *));
     return 0;
}

结论：

• 32位平台下地址是32个bit位，指针变量⼤⼩是4个字节

• 64位平台下地址是64个bit位，指针变量⼤⼩是8个字节

• 注意指针变量的⼤⼩和类型是⽆关的，只要指针类型的变量，在相同的平台下，⼤⼩都是相同的。

3. 指针变量类型的意义

指针变量的⼤⼩和类型⽆关，只要是指针变量，在同⼀个平台下，⼤⼩都是⼀样的，为什么还要有各种各样的指针类型呢？

其实指针类型是有特殊意义的，我们接下来继续学习。

3.1 指针的解引⽤

对⽐，下⾯2段代码，主要在调试时观察内存的变化。

cpp 复制代码

//代码1 

#include <stdio.h>

int main()
{
     int n = 0x11223344;
     int *pi = &n; 
     *pi = 0; 
     return 0;
}

cpp 复制代码

//代码2 

#include <stdio.h>

int main()
{
     int n = 0x11223344;
     char *pc = (char *)&n;
     *pc = 0;
     return 0;
}

调试我们可以看到，代码1会将n的4个字节全部改为0，但是代码2只是将n的第⼀个字节改为0。

**结论：**指针的类型决定了，对指针解引⽤的时候有多⼤的权限（⼀次能操作⼏个字节）。

⽐如： char* 的指针解引⽤就只能访问⼀个字节，⽽ int* 的指针的解引⽤就能访问四个字节。

3.2 指针+-整数

先看⼀段代码，调试观察地址的变化。

cpp 复制代码

#include <stdio.h>

int main()
{
     int n = 10;
     char *pc = (char*)&n;
     int *pi = &n;
 
     printf("%p\n", &n);
     printf("%p\n", pc);
     printf("%p\n", pc+1);
     printf("%p\n", pi);
     printf("%p\n", pi+1);
     return 0;
}

代码运⾏的结果如下：

我们可以看出， char* 类型的指针变量+1跳过1个字节， **int***类型的指针变量+1跳过了4个字节。这就是指针变量的类型差异带来的变化。指针+1，其实跳过1个指针指向的元素。指针可以+1，那也可以-1。

**结论：**指针的类型决定了指针向前或者向后⾛⼀步有多⼤（距离）

3.3 void* 指针

在指针类型中有⼀种特殊的类型是void * 类型的，可以理解为⽆具体类型的指针（或者叫泛型指针），这种类型的指针可以⽤来接受任意类型地址。但是也有局限性， **void***类型的指针不能直接进⾏指针的+-整数和解引⽤的运算。

举例：

cpp 复制代码

#include <stdio.h>
int main()
{
     int a = 10;
     int* pa = &a;
     char* pc = &a;
     return 0;
}

在上⾯的代码中，将⼀个int类型的变量的地址赋值给⼀个char*类型的指针变量。编译器给出了⼀个警告（如下图），是因为类型不兼容。⽽使⽤**void***类型就不会有这样的问题。

使⽤void*类型的指针接收地址：

cpp 复制代码

#include <stdio.h>

int main()
{
     int a = 10;
     void* pa = &a;
     void* pc = &a;
     
     *pa = 10;
     *pc = 0;
     return 0;
}

VS编译代码的结果：

这⾥我们可以看到， void* 类型的指针可以接收不同类型的地址，但是⽆法直接进⾏指针运算。

那么**void***类型的指针到底有什么⽤呢？

⼀般void* 类型的指针是使⽤在函数参数的部分，⽤来接收不同类型数据的地址，这样的设计可以实现泛型编程的效果。使得⼀个函数来处理多种类型的数据

4. const修饰指针

4.1 const修饰变量

变量是可以修改的，如果把变量的地址交给⼀个指针变量，通过指针变量的也可以修改这个变量。但是如果我们希望⼀个变量加上⼀些限制，不能被修改，怎么做呢？这就是const的作⽤。

cpp 复制代码

#include <stdio.h>

int main()
{
     int m = 0;
     m = 20;//m是可以修改的 
     const int n = 0;
     n = 20;//n是不能被修改的 
     return 0;
}

上述代码中n是不能被修改的，其实n本质是变量，只不过被const修饰后，在语法上加了限制，只要我们在代码中对n就⾏修改，就不符合语法规则，就报错，致使没法直接修改n。

但是如果我们绕过n，使⽤n的地址，去修改n就能做到了，虽然这样做是在打破语法规则。

cpp 复制代码

#include <stdio.h>

int main()
{
     const int n = 0;
     printf("n = %d\n", n);
     int*p = &n;
     *p = 20;
     printf("n = %d\n", n);
     return 0;
}

输出结果：

我们可以看到这⾥⼀个确实修改了，但是我们还是要思考⼀下，为什么n要被const修饰呢？就是为了不能被修改，如果p拿到n的地址就能修改n，这样就打破了const的限制，这是不合理的，所以应该让 p拿到n的地址也不能修改n，那接下来怎么做呢？

4.2 const修饰指针变量

⼀般来讲const修饰指针变量，可以放在*的左边，也可以放在*的右边，意义是不⼀样的。

cpp 复制代码

int * p;//没有const修饰？ 

int const * p;//const 放在*的左边做修饰 

int * const p;//const 放在*的右边做修饰

我们看下⾯代码，来分析具体分析⼀下：

cpp 复制代码

#include <stdio.h>

//代码1 - 测试⽆const修饰的情况 

void test1()
{
     int n = 10;
     int m = 20;
     int *p = &n;
     *p = 20;//ok?
     p = &m; //ok?
}


//代码2 - 测试const放在*的左边情况 

void test2()
{
     int n = 10;
     int m = 20;
     const int* p = &n;
     *p = 20;//ok?
     p = &m; //ok?

}


//代码3 - 测试const放在*的右边情况 

void test3()
{
     int n = 10;
     int m = 20;
     int * const p = &n;
     *p = 20; //ok?
     p = &m; //ok?

}

//代码4 - 测试*的左右两边都有const 

void test4()
{
     int n = 10;
     int m = 20;
     int const * const p = &n;
     *p = 20; //ok?
     p = &m; //ok?

}

int main()
{
     //测试⽆const修饰的情况 
     test1();
     //测试const放在*的左边情况 
     test2();
     //测试const放在*的右边情况 
     test3();
     //测试*的左右两边都有const 
     test4();
     return 0;
}

结论：const修饰指针变量的时候

• const如果放在*的左边，修饰的是指针指向的内容，保证指针指向的内容不能通过指针来改变。但是指针变量本⾝的内容可变。

• const如果放在*的右边，修饰的是指针变量本⾝，保证了指针变量的内容不能修改，但是指针指向的内容，可以通过指针改变。

5. 指针运算

指针的基本运算有三种，分别是：

• 指针+-整数

• 指针-指针

• 指针的关系运算

5.1 指针+-整数

因为数组在内存中是连续存放的，只要知道第⼀个元素的地址，顺藤摸⽠就能找到后⾯的所有元素。

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

cpp 复制代码

#include <stdio.h>

//指针+- 整数 

int main()
{
 int arr[10] = {1,2,3,4,5,6,7,8,9,10};
 int *p = &arr[0];
 int i = 0;
 int sz = sizeof(arr)/sizeof(arr[0]);
 for(i=0; i<sz; i++)
 {
 printf("%d ", *(p+i));//p+i 这⾥就是指针+整数 
 }
 return 0;
}

5.2 指针-指针

cpp 复制代码

//指针-指针 

#include <stdio.h>

int my_strlen(char *s)
{
 char *p = s;
 while(*p != '\0' )
 p++;
 return p-s;
}

int main()
{
 printf("%d\n", my_strlen("abc"));
 return 0;
}

5.3 指针的关系运算

cpp 复制代码

//指针的关系运算 

#include <stdio.h>

int main()
{
 int arr[10] = {1,2,3,4,5,6,7,8,9,10};
 int *p = &arr[0];
 int i = 0;
 int sz = sizeof(arr)/sizeof(arr[0]);
 while(p<arr+sz) //指针的⼤⼩⽐较 
 {
 printf("%d ", *p);
 p++;
 }
 return 0;
}

6. 野指针

概念：野指针就是指针指向的位置是不可知的（随机的、不正确的、没有明确限制的）

6.1 野指针成因

指针未初始化

cpp 复制代码

#include <stdio.h>

int main()
{ 
 int *p;//局部变量指针未初始化，默认为随机值 
 *p = 20;
 return 0;
}

指针越界访问

cpp 复制代码

#include <stdio.h>

int main()
{
 int arr[10] = {0};
 int *p = &arr[0];
 int i = 0;
 for(i=0; i<=11; i++)
 {
 //当指针指向的范围超出数组arr的范围时，p就是野指针 
 *(p++) = i;
 }
 return 0;
}

指针指向的空间释放

cpp 复制代码

#include <stdio.h>

int* test()
{
 int n = 100;
 return &n;
}

int main()
{
 int*p = test();
 printf("%d\n", *p);
 return 0;
}

6.2 如何规避野指针

6.2.1 指针初始化

如果明确知道指针指向哪⾥就直接赋值地址，如果不知道指针应该指向哪⾥，可以给指针赋值NULL.

NULL 是C语⾔中定义的⼀个标识符常量，值是0，0也是地址，这个地址是⽆法使⽤的，读写该地址会报错。

cpp 复制代码

#ifdef __cplusplus

     #define NULL 0

 #else

     #define NULL ((void *)0)

 #endif

初始化如下：

cpp 复制代码

#include <stdio.h>

int main()
{
 int num = 10;
 int*p1 = &num;
 int*p2 = NULL;
 
 return 0;
}

6.2.2 ⼩⼼指针越界

⼀个程序向内存申请了哪些空间，通过指针也就只能访问哪些空间，不能超出范围访问，超出了就是越界访问。

6.2.3 指针变量不再使⽤时，及时置NULL，指针使⽤之前检查有效性

当指针变量指向⼀块区域的时候，我们可以通过指针访问该区域，后期不再使⽤这个指针访问空间的时候，我们可以把该指针置为NULL 。因为约定俗成的⼀个规则就是：只要是NULL指针就不去访问，同时使⽤指针之前可以判断指针是否为NULL。

我们可以把野指针想象成野狗，野狗放任不管是⾮常危险的，所以我们可以找⼀棵树把野狗拴起来，就相对安全了，给指针变量及时赋值为NULL，其实就类似把野狗栓起来，就是把野指针暂时管理起来。

不过野狗即使拴起来我们也要绕着⾛，不能去挑逗野狗，有点危险；对于指针也是，在使⽤之前，我们也要判断是否为NULL，看看是不是被拴起来起来的野狗，如果是不能直接使⽤，如果不是我们再去使⽤。

cpp 复制代码

int main()
{
 int arr[10] = {1,2,3,4,5,67,7,8,9,10};
 int *p = &arr[0];
 for(i=0; i<10; i++)
 {
 *(p++) = i;
 }
 //此时p已经越界了，可以把p置为NULL 
 p = NULL;
 //下次使⽤的时候，判断p不为NULL的时候再使⽤ 
 //...

 p = &arr[0];//重新让p获得地址 
 if(p != NULL) //判断 
 {
 //...

 }
 return 0;
}

6.2.4 避免返回局部变量的地址

如造成野指针的第3个例⼦，不要返回局部变量的地址。

7. assert断⾔

assert.h 头⽂件定义了宏assert()，⽤于在运⾏时确保程序符合指定条件，如果不符合，就报错终⽌运⾏。这个宏常常被称为"断⾔"。

assert(p != NULL);

上⾯代码在程序运⾏到这⼀⾏语句时，验证变量 p 是否等于 NULL 。如果确实不等于 NULL ，程序继续运⾏，否则就会终⽌运⾏，并且给出报错信息提⽰。

assert() 宏接受⼀个表达式作为参数。如果该表达式为真（返回值⾮零）， assert() 不会产⽣任何作⽤，程序继续运⾏。如果该表达式为假（返回值为零），assert() 就会报错，在标准错误流 stderr 中写⼊⼀条错误信息，显⽰没有通过的表达式，以及包含这个表达式的⽂件名和⾏号。

assert() 的使⽤对程序员是⾮常友好的，使⽤assert() 有⼏个好处：它不仅能⾃动标识⽂件和出问题的⾏号，还有⼀种⽆需更改代码就能开启或关闭 assert() 的机制。如果已经确认程序没有问题，不需要再做断⾔，就在 #include 语句的前⾯，定义⼀个宏 NDEBUG。

cpp 复制代码

#define NDEBUG
#include <assert.h>

然后，重新编译程序，编译器就会禁⽤⽂件中所有的 assert() 语句。如果程序⼜出现问题，可以移除这条 #define NDEBUG 指令（或者把它注释掉），再次编译，这样就重新启⽤了 assert() 语句。

assert() 的缺点是，因为引⼊了额外的检查，增加了程序的运⾏时间。⼀般我们可以在 Debug 中使⽤，在Release 版本中选择禁⽤ assert 就⾏，在VS 这样的集成开发环境中，在 Release 版本中，直接就是优化掉了。这样在debug 版本写有利于程序员排查问题，在Release 版本不影响⽤⼾使⽤时程序的效率。

8. 指针的使⽤和传址调⽤

8.1 strlen的模拟实现

库函数strlen的功能是求字符串⻓度，统计的是字符串中 \0 之前的字符的个数。

函数原型如下：

size_t strlen ( const char * str );

参数str接收⼀个字符串的起始地址，然后开始统计字符串中 \0 之前的字符个数，最终返回⻓度。如果要模拟实现只要从起始地址开始向后逐个字符的遍历，只要不是 \0 字符，计数器就+1，这样直到 \0 就停⽌。

参考代码如下：

cpp 复制代码

int my_strlen(const char * str)
{
 int count = 0;
 assert(str);
 while(*str)
 {
 count++;
 str++;
 }
 return count;
}

int main()
{
 int len = my_strlen("abcdef");
 printf("%d\n", len);
 return 0;
}

8.2 传值调⽤和传址调⽤

学习指针的⽬的是使⽤指针解决问题，那什么问题，⾮指针不可呢？

例如：写⼀个函数，交换两个整型变量的值⼀番思考后，我们可能写出这样的代码：

cpp 复制代码

#include <stdio.h>

void Swap1(int x, int y)
{
 int tmp = x;
 x = y;
 y = tmp;
}

int main()
{
 int a = 0;
 int b = 0;
 scanf("%d %d", &a, &b);
 printf("交换前：a=%d b=%d\n", a, b);
 Swap1(a, b);
 printf("交换后：a=%d b=%d\n", a, b);
 return 0;
}

当我们运⾏代码，结果如下：

我们发现其实没产⽣交换的效果，这是为什么呢？

调试⼀下，试试呢？

我们发现在main函数内部，创建了a和b，a的地址是0x00cffdd0 ，b的地址是0x00cffdc4 ，在调⽤ Swap1函数时，将a和b传递给了Swap1 函数，在Swap1 函数内部创建了形参x和y接收a和b的值，但是 x的地址是0x00cffcec ，y的地址是0x00cffcf0 ，x和y确实接收到了a和b的值，不过x的地址和a的地址不⼀样，y的地址和b的地址不⼀样，相当于x和y是独⽴的空间，那么在Swap1函数内部交换x和y的值，⾃然不会影响a和b，当Swap1函数调⽤结束后回到main函数，a和b的没法交换。Swap1 函数在使⽤的时候，是把变量本⾝直接传递给了函数，这种调⽤函数的⽅式我们之前在函数的时候就知道了，这种叫传值调⽤。

结论：实参传递给形参的时候，形参会单独创建⼀份临时空间来接收实参，对形参的修改不影响实参。

所以Swap是失败的了。

那怎么办呢？

我们现在要解决的就是当调⽤Swap函数的时候，Swap 函数内部操作的就是main 函数中的a和b，直接将a和b的值交换了。那么就可以使⽤指针了，在main 函数中将a和b的地址传递给Swap函数，Swap 函数⾥边通过地址间接的操作main函数中的a和b，并达到交换的效果就好了。

cpp 复制代码

#include <stdio.h>

void Swap2(int*px, int*py)
{
 int tmp = 0;
 tmp = *px;
 *px = *py;
 *py = tmp;
}

int main()
{
 int a = 0;
 int b = 0;
 scanf("%d %d", &a, &b);
 printf("交换前：a=%d b=%d\n", a, b);
 Swap2(&a, &b);
 printf("交换后：a=%d b=%d\n", a, b);
 return 0;
}

⾸先看输出结果：

我们可以看到实现成Swap2的⽅式，顺利完成了任务，这⾥调⽤Swap2函数的时候是将变量的地址传递给了函数，这种函数调⽤⽅式叫：传址调⽤。

传址调⽤，可以让函数和主调函数之间建⽴真正的联系，在函数内部可以修改主调函数中的变量；所以未来函数中只是需要主调函数中的变量值来实现计算，就可以采⽤传值调⽤。如果函数内部要修改主调函数中的变量的值，就需要传址调⽤。

二、

1. 数组名的理解

在上⼀个章节我们在使⽤指针访问数组的内容时，有这样的代码：

cpp 复制代码

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

int *p = &arr[0];

这⾥我们使⽤ **&arr[0]**的⽅式拿到了数组第⼀个元素的地址，但是其实数组名本来就是地址，⽽且是数组⾸元素的地址，我们来做个测试。

cpp 复制代码

#include <stdio.h>

int main()
{
 int arr[10] = { 1,2,3,4,5,6,7,8,9,10 };
 printf("&arr[0] = %p\n", &arr[0]);
 printf("arr = %p\n", arr);
 return 0;
}

输出结果：

我们发现数组名和数组⾸元素的地址打印出的结果⼀模⼀样，数组名就是数组⾸元素(第⼀个元素)的地址。这时候有同学会有疑问？

数组名如果是数组⾸元素的地址，那下⾯的代码怎么理解呢？

cpp 复制代码

#include <stdio.h>

int main()
{
     int arr[10] = { 1,2,3,4,5,6,7,8,9,10 };
     printf("%d\n", sizeof(arr));
     return 0;
}

输出的结果是：40，如果arr是数组⾸元素的地址，那输出应该的应该是4/8才对。其实数组名就是数组⾸元素(第⼀个元素)的地址是对的，但是有两个例外：

• sizeof(数组名)，sizeof中单独放数组名，这⾥的数组名表⽰整个数组，计算的是整个数组的⼤⼩，单位是字节

• &数组名，这⾥的数组名表⽰整个数组，取出的是整个数组的地址（整个数组的地址和数组⾸元素的地址是有区别的）

除此之外，任何地⽅使⽤数组名，数组名都表⽰⾸元素的地址

再试⼀下这个代码：

cpp 复制代码

#include <stdio.h>

int main()
{
 int arr[10] = { 1,2,3,4,5,6,7,8,9,10 };
 printf("&arr[0] = %p\n", &arr[0]);
 printf("arr = %p\n", arr);
 printf("&arr = %p\n", &arr);
 return 0;
}

三个打印结果⼀模⼀样，这时候⼜纳闷了，那arr 和**&arr**有啥区别呢？

cpp 复制代码

#include <stdio.h>

int main()
{
 int arr[10] = { 1,2,3,4,5,6,7,8,9,10 };
 printf("&arr[0] = %p\n", &arr[0]);
 printf("&arr[0]+1 = %p\n", &arr[0]+1);
 printf("arr = %p\n", arr);
 printf("arr+1 = %p\n", arr+1);
 printf("&arr = %p\n", &arr);
 printf("&arr+1 = %p\n", &arr+1);
 return 0;
}

输出结果：

&arr[0] = 0077F820

&arr[0]+1 = 0077F824

arr = 0077F820

arr+1 = 0077F824

&arr = 0077F820

&arr+1 = 0077F848

这⾥我们发现**&arr[0]** 和**&arr[0]+1** 相差4个字节，arr 和arr+1 相差4个字节，是因为**&arr[0]** 和arr 都是⾸元素的地址，+1就是跳过⼀个元素。

但是**&arr** 和**&arr+** 1相差40个字节，这就是因为**&arr** 是数组的地址，+1操作是跳过整个数组的。到这⾥⼤家应该搞清楚数组名的意义了吧。

数组名是数组⾸元素的地址，但是有2个例外。

2. 使⽤指针访问数组

有了前⾯知识的⽀持，再结合数组的特点，我们就可以很⽅便的使⽤指针访问数组了。

cpp 复制代码

#include <stdio.h>

int main()
{
 int arr[10] = {0};
 //输⼊ 
int i = 0;
 int sz = sizeof(arr)/sizeof(arr[0]);
 //输⼊ 
 int* p = arr;
 for(i=0; i<sz; i++)
 {
 scanf("%d", p+i);
 //scanf("%d", arr+i);//也可以这样写 
 }
 //输出 
 for(i=0; i<sz; i++)
 {
 printf("%d ", *(p+i));
 }
 return 0;
}

这个代码搞明⽩后，我们再试⼀下，如果我们再分析⼀下，数组名arr是数组⾸元素的地址，可以赋值给p ，其实数组名arr 和p 在这⾥是等价的。那我们可以使⽤arr[i] 可以访问数组的元素，那**p[i]**是否也可以访问数组呢？

cpp 复制代码

#include <stdio.h>

int main()
{
 int arr[10] = {0};
 //输⼊ 
 int i = 0;
 int sz = sizeof(arr)/sizeof(arr[0]);
 //输⼊ 
 int* p = arr;
 for(i=0; i<sz; i++)
 {
 scanf("%d", p+i);
 //scanf("%d", arr+i);//也可以这样写 
 }
 //输出 
 for(i=0; i<sz; i++)
 {
 printf("%d ", p[i]);
 }
 return 0;
}

在第18⾏的地⽅，将***(p+i)** 换成p[i] 也是能够正常打印的，所以本质上p[i] 是等价于***(p+i)**。

同理arr[i] 应该等价于***(arr+i)**，数组元素的访问在编译器处理的时候，也是转换成⾸元素的地址+偏移量求出元素的地址，然后解引⽤来访问的。

3. ⼀维数组传参的本质

数组我们学过了，之前也讲了，数组是可以传递给函数的，这个⼩节我们讨论⼀下数组传参的本质。⾸先从⼀个问题开始，我们之前都是在函数外部计算数组的元素个数，那我们可以把数组传给⼀个函数后，函数内部求数组的元素个数吗？

cpp 复制代码

#include <stdio.h>

void test(int arr[])
{
 int sz2 = sizeof(arr)/sizeof(arr[0]);
 printf("sz2 = %d\n", sz2);
}

int main()
{
 int arr[10] = {1,2,3,4,5,6,7,8,9,10};
 int sz1 = sizeof(arr)/sizeof(arr[0]);
 printf("sz1 = %d\n", sz1);
 test(arr);
 return 0;
}

输出的结果：

我们发现在函数内部是没有正确获得数组的元素个数。这就要学习数组传参的本质了，上个⼩节我们学习了：数组名是数组⾸元素的地址；那么在数组传参的时候，传递的是数组名，也就是说本质上数组传参传递的是数组⾸元素的地址。

所以函数形参的部分理论上应该使⽤指针变量来接收⾸元素的地址。那么在函数内部我们写

sizeof(arr) 计算的是⼀个地址的⼤⼩（单位字节）⽽不是数组的⼤⼩（单位字节）。

正是因为函数的参数部分是本质是指针，所以在函数内部是没办法求的数组元素个数的。

cpp 复制代码

void test(int arr[])//参数写成数组形式，本质上还是指针 
{
 printf("%d\n", sizeof(arr));
}

void test(int* arr)//参数写成指针形式 
{
 printf("%d\n", sizeof(arr));//计算⼀个指针变量的⼤⼩ 
}

int main()
{
 int arr[10] = {1,2,3,4,5,6,7,8,9,10};
 test(arr);
 return 0;
}

总结：⼀维数组传参，形参的部分可以写成数组的形式，也可以写成指针的形式。

4. 冒泡排序

冒泡排序的核⼼思想就是：两两相邻的元素进⾏⽐较。

cpp 复制代码

void bubble_sort(int arr[], int sz)//参数接收数组元素个数 
{
 int i = 0;
 for(i=0; i<sz-1; i++)
 {
 int j = 0;
 for(j=0; j<sz-i-1; j++)
 {
 if(arr[j] > arr[j+1])
 {
 int tmp = arr[j];
 arr[j] = arr[j+1];
 arr[j+1] = tmp;
 }
 }
 }
}

int main()
{
 int arr[] = {3,1,7,5,8,9,0,2,4,6};
 int sz = sizeof(arr)/sizeof(arr[0]);
bubble_sort(arr, sz);
 int i = 0;
 for(i=0; i<sz; i++)
 {
 printf("%d ", arr[i]);
 }
 return 0;
}

//⽅法2 - 优化 

void bubble_sort(int arr[], int sz)//参数接收数组元素个数 
{
 int i = 0;
 for(i=0; i<sz-1; i++)
 {
 int flag = 1;//假设这⼀趟已经有序了 
 int j = 0;
 for(j=0; j<sz-i-1; j++)
 {
 if(arr[j] > arr[j+1])
 {
 flag = 0;//发⽣交换就说明，⽆序 
 int tmp = arr[j];
 arr[j] = arr[j+1];
 arr[j+1] = tmp;
 }
 }
 if(flag == 1)//这⼀趟没交换就说明已经有序，后续⽆序排序了 
 break;
 }
}

int main()
{
 int arr[] = {3,1,7,5,8,9,0,2,4,6};
 int sz = sizeof(arr)/sizeof(arr[0]);
 bubble_sort(arr, sz);
 int i = 0;
 for(i=0; i<sz; i++)
 {
 printf("%d ", arr[i]);
 }
 return 0;
}

5. ⼆级指针

指针变量也是变量，是变量就有地址，那指针变量的地址存放在哪⾥？这就是⼆级指针。

对于⼆级指针的运算有：

• *ppa 通过对ppa 中的地址进⾏解引⽤，这样找到的是 pa ，*ppa 其实访问的就是pa .

cpp 复制代码

int b = 20;
*ppa = &b;//等价于 pa = &b;

**ppa 先通过 *ppa 找到 pa ,然后对 pa 进⾏解引⽤操作： *pa ，那找到的是 a.

cpp 复制代码

**ppa = 30;

//等价于*pa = 30; 

//等价于a = 30;

6. 指针数组

指针数组是指针还是数组？

我们类⽐⼀下，整型数组，是存放整型的数组，字符数组是存放字符的数组。

那指针数组呢？是存放指针的数组。

指针数组的每个元素都是⽤来存放地址（指针）的。

如下图：

指针数组的每个元素是地址，⼜可以指向⼀块区域。

7. 指针数组模拟⼆维数组

cpp 复制代码

#include <stdio.h>

int main()
{
 int arr1[] = {1,2,3,4,5};
 int arr2[] = {2,3,4,5,6};
 int arr3[] = {3,4,5,6,7};
 //数组名是数组⾸元素的地址，类型是int*的，就可以存放在parr数组中 
 int* parr[3] = {arr1, arr2, arr3};
 int i = 0;
 int j = 0;
 for(i=0; i<3; i++)
 {
 for(j=0; j<5; j++)
 {
 printf("%d ", parr[i][j]);
 }
printf("\n");
 }
 return 0;
}

parr[i] 是访问parr 数组的元素，parr[i] 找到的数组元素指向了整型⼀维数组，**parr[i][j]**就是整型⼀维数组中的元素。

上述的代码模拟出⼆维数组的效果，实际上并⾮完全是⼆维数组，因为每⼀⾏并⾮是连续的。

三、

1. 字符指针变量

在指针的类型中我们知道有⼀种指针类型为字符指针char*;

⼀般使⽤:

cpp 复制代码

int main()
{
 char ch = 'w';
 char *pc = &ch;
 *pc = 'w';
 return 0;
}

还有⼀种使⽤⽅式如下：

cpp 复制代码

int main()
{
 const char* pstr = "hello bit.";//这⾥是把⼀个字符串放到pstr指针变量⾥了吗？ 
 printf("%s\n", pstr);
 return 0;
}

代码 const char* pstr = "hello bit."; 特别容易让同学以为是把字符串 hello bit 放到字符指针 pstr ⾥了，但是本质是把字符串 hello bit . ⾸字符的地址放到了pstr中。

上⾯代码的意思是把⼀个常量字符串的⾸字符h 的地址存放到指针变量pstr 中。

⼀道和字符串相关的笔试题，我们⼀起来学习⼀下：

cpp 复制代码

#include <stdio.h>

int main()
{
 char str1[] = "hello bit.";
 char str2[] = "hello bit.";
 const char *str3 = "hello bit.";
 const char *str4 = "hello bit.";
 if(str1 ==str2)
 printf("str1 and str2 are same\n");
 else

 printf("str1 and str2 are not same\n");
 
 if(str3 ==str4)
 printf("str3 and str4 are same\n");
 else

 printf("str3 and str4 are not same\n");
 
 return 0;
}

这⾥str3 和str4 指向的是⼀个同⼀个常量字符串。C/C++ 会把常量字符串存储到单独的⼀个内存区域，当⼏个指针指向同⼀个字符串的时候，他们实际会指向同⼀块内存。但是⽤相同的常量字符串去初始化不同的数组的时候就会开辟出不同的内存块。所以str1 和str2 不同，str3 和str4相同。

2. 数组指针变量

2.1 数组指针变量是什么？

之前我们学习了指针数组，指针数组是⼀种数组，数组中存放的是地址（指针）。

数组指针变量是指针变量？

还是数组？

答案是：指针变量。

我们已经熟悉：

• 整形指针变量： int * pint; 存放的是整形变量的地址，能够指向整形数据的指针。

• 浮点型指针变量： float * pf; 存放浮点型变量的地址，能够指向浮点型数据的指针。那数组指针变量应该是：存放的应该是数组的地址，能够指向数组的指针变量。

下⾯代码哪个是数组指针变量？

cpp 复制代码

int *p1[10];

int (*p2)[10];

思考⼀下：p1,p2分别是什么？

数组指针变量

cpp 复制代码

int (*p)[10];

解释：p 先和***** 结合，说明p是⼀个指针变量变量，然后指着指向的是⼀个⼤⼩为10个整型的数组。所以 p是⼀个指针，指向⼀个数组，叫数组指针。

这⾥要注意：[]的优先级要⾼于*号的，所以必须加上（）来保证p先和*结合。

2.2 数组指针变量怎么初始化

数组指针变量是⽤来存放数组地址的，那怎么获得数组的地址呢？就是我们之前学习的 &数组名。

cpp 复制代码

int arr[10] = {0};
&arr;//得到的就是数组的地址

如果要存放个数组的地址，就得存放在数组指针变量中，如下：

cpp 复制代码

int(*p)[10] = &arr;

我们调试也能看到**&arr** 和 p的类型是完全⼀致的。

数组指针类型解析：

int (*p) [10] = &arr;

| | |

| | |

| | p指向数组的元素个数

| p是数组指针变量名

p指向的数组的元素类型

3. ⼆维数组传参的本质

有了数组指针的理解，我们就能够讲⼀下⼆维数组传参的本质了。

过去我们有⼀个⼆维数组的需要传参给⼀个函数的时候，我们是这样写的：

cpp 复制代码

#include <stdio.h>

void test(int a[3][5], int r, int c)
{
 int i = 0;
 int j = 0;
for(i=0; i<r; i++)
 {
 for(j=0; j<c; j++)
 {
 printf("%d ", a[i][j]);
 }
 printf("\n");
 }
}

int main()
{
 int arr[3][5] = {{1,2,3,4,5}, {2,3,4,5,6},{3,4,5,6,7}};
 test(arr, 3, 5);
 return 0;
}

这⾥实参是⼆维数组，形参也写成⼆维数组的形式，那还有什么其他的写法吗？

⾸先我们再次理解⼀下⼆维数组，⼆维数组其实可以看做是每个元素是⼀维数组的数组，也就是⼆维数组的每个元素是⼀个⼀维数组。

那么⼆维数组的⾸元素就是第⼀⾏，是个⼀维数组。

如下图：

所以，根据数组名是数组⾸元素的地址这个规则，⼆维数组的数组名表⽰的就是第⼀⾏的地址，是⼀维数组的地址。根据上⾯的例⼦，第⼀⾏的⼀维数组的类型就是int [5] ，所以第⼀⾏的地址的类型就是数组指针类型int(*)[5] 。那就意味着**⼆维数组传参本质上也是传递了地址，传递的是第⼀⾏这个⼀维数组的地址**，那么形参也是可以写成指针形式的。如下：

cpp 复制代码

#include <stdio.h>

void test(int (*p)[5], int r, int c)
{
 int i = 0;
int j = 0;
 for(i=0; i<r; i++)
 {
 for(j=0; j<c; j++)
 {
 printf("%d ", *(*(p+i)+j));
 }
 printf("\n");
 }
}

int main()
{
 int arr[3][5] = {{1,2,3,4,5}, {2,3,4,5,6},{3,4,5,6,7}};
 test(arr, 3, 5);
 return 0;
}

总结：⼆维数组传参，形参的部分可以写成数组，也可以写成指针形式。

4. 函数指针变量

4.1 函数指针变量的创建

什么是函数指针变量呢？

根据前⾯学习整型指针，数组指针的时候，我们的类⽐关系，我们不难得出结论：

函数指针变量应该是⽤来存放函数地址的，未来通过地址能够调⽤函数的。

那么函数是否有地址呢？我们做个测试：

cpp 复制代码

#include <stdio.h>

void test()
{
 printf("hehe\n");
}

int main()
{
 printf("test: %p\n", test);
 printf("&test: %p\n", &test);
 return 0;
}

输出结果如下：

cpp 复制代码

test: 005913CA
&test: 005913CA

确实打印出来了地址，所以函数是有地址的，函数名就是函数的地址，当然也可以通过 &函数名的⽅式获得函数的地址。

如果我们要将函数的地址存放起来，就得创建函数指针变量咯，函数指针变量的写法其实和数组指针⾮常类似。如下：

cpp 复制代码

void test()
{
 printf("hehe\n");
}

void (*pf1)() = &test;

void (*pf2)()= test;

int Add(int x, int y)
{
 return x+y;
}

int(*pf3)(int, int) = Add;

int(*pf3)(int x, int y) = &Add;//x和y写上或者省略都是可以的

函数指针类型解析：

4.2 函数指针变量的使⽤

通过函数指针调⽤指针指向的函数。

cpp 复制代码

#include <stdio.h>

int Add(int x, int y)
{
 return x+y;
}

int main()
{
 int(*pf3)(int, int) = Add;
 
 printf("%d\n", (*pf3)(2, 3));
 printf("%d\n", pf3(3, 5));
 return 0;
}

输出结果：

5

8

4.3 两段有趣的代码

cpp 复制代码

(*(void (*)())0)();


void (*signal(int , void(*)(int)))(int);

4.3.1 typedef 关键字

typedef是⽤来类型重命名的，可以将复杂的类型，简单化。

⽐如，你觉得unsigned int 写起来不⽅便，如果能写成uint就⽅便多了，那么我们可以使⽤：

cpp 复制代码

typedef unsigned int uint;

//将unsigned int 重命名为uint

如果是指针类型，能否重命名呢？其实也是可以的，⽐如，将int* 重命名为 ptr_t,这样写：

cpp 复制代码

typedef int* ptr_t;

但是对于数组指针和函数指针稍微有点区别：

⽐如我们有数组指针类型 int(*)[5] ,需要重命名为 parr_t，那可以这样写：

cpp 复制代码

typedef int(*parr_t)[5]; //新的类型名必须在*的右边

函数指针类型的重命名也是⼀样的，⽐如，将**void(*)(int)**类型重命名为 pf_t ,就可以这样写：

cpp 复制代码

typedef void(*pfun_t)(int);//新的类型名必须在*的右边

那么要简化代码2，可以这样写：

cpp 复制代码

typedef void(*pfun_t)(int);

pfun_t signal(int, pfun_t);

5. 函数指针数组

数组是⼀个存放相同类型数据的存储空间，我们已经学习了指针数组，

⽐如：

cpp 复制代码

int *arr[10];

//数组的每个元素是int*

那要把函数的地址存到⼀个数组中，那这个数组就叫函数指针数组，那函数指针的数组如何定义呢？

cpp 复制代码

int (*parr1[3])();

int *parr2[3]();

int (*)() parr3[3];

答案是：parr1

parr1 先和 [] 结合，说明parr1是数组，数组的内容是什么呢？

是int (*)() 类型的函数指针。

6. 转移表

函数指针数组的⽤途：转移表

举例：计算器的⼀般实现：

cpp 复制代码

#include <stdio.h>

int add(int a, int b)
{
 return a + b;
}

int sub(int a, int b)
{
 return a - b;
}

int mul(int a, int b)
{
 return a * b;
}

int div(int a, int b)
{
 return a / b;
}

int main()
{
 int x, y;
 int input = 1;
 int ret = 0;
 do

 {
 printf("*************************\n");
 printf(" 1:add 2:sub \n");
printf(" 3:mul 4:div \n");
 printf(" 0:exit \n");
 printf("*************************\n");
 printf("请选择：");
 scanf("%d", &input);
 switch (input)
 {
 case 1:
 printf("输⼊操作数：");
 scanf("%d %d", &x, &y);
 ret = add(x, y);
 printf("ret = %d\n", ret);
 break;
 case 2:
 printf("输⼊操作数：");
 scanf("%d %d", &x, &y);
 ret = sub(x, y);
 printf("ret = %d\n", ret);
 break;
 case 3:
 printf("输⼊操作数：");
 scanf("%d %d", &x, &y);
 ret = mul(x, y);
 printf("ret = %d\n", ret);
 break;
 case 4:
 printf("输⼊操作数：");
 scanf("%d %d", &x, &y);
 ret = div(x, y);
 printf("ret = %d\n", ret);
 break;
 case 0:
 printf("退出程序\n");
 break;
 default:
 printf("选择错误\n");
 break;
 }
 } while (input);
 return 0;
}

使⽤函数指针数组的实现：

cpp 复制代码

#include <stdio.h>

int add(int a, int b)
{
 return a + b;
}

int sub(int a, int b)
{
 return a - b;
}

int mul(int a, int b)
{
 return a*b;
}

int div(int a, int b)
{
 return a / b;
}

int main()
{
 int x, y;
 int input = 1;
 int ret = 0;
 int(*p[5])(int x, int y) = { 0, add, sub, mul, div }; //转移表 
 do

 {
 printf("*************************\n");
 printf(" 1:add 2:sub \n");
 printf(" 3:mul 4:div \n");
 printf(" 0:exit \n");
 printf("*************************\n");
 printf( "请选择：" );
 scanf("%d", &input);
 if ((input <= 4 && input >= 1))
 {
 printf( "输⼊操作数：" );
 scanf( "%d %d", &x, &y);
 ret = (*p[input])(x, y);
 printf( "ret = %d\n", ret);
 }
 else if(input == 0)
 {
 printf("退出计算器\n");
 }
 else

 {
 printf( "输⼊有误\n" ); 
 }
}while (input);
 return 0;
}

四、

1. 回调函数是什么？

回调函数就是⼀个通过函数指针调⽤的函数。

如果你把函数的指针（地址）作为参数传递给另⼀个函数，当这个指针被⽤来调⽤其所指向的函数时，被调⽤的函数就是回调函数。回调函数不是由该函数的实现⽅直接调⽤，⽽是在特定的事件或条件发⽣时由另外的⼀⽅调⽤的，⽤于对该事件或条件进⾏响应。第13讲中我们写的计算机的实现的代码中，红⾊框中的代码是重复出现的，其中虽然执⾏计算的逻辑是区别的，但是输⼊输出操作是冗余的，有没有办法，简化⼀些呢？因为红⾊框中的代码，只有调⽤函数的逻辑是有差异的，我们可以把调⽤的函数的地址以参数的形式传递过去，使⽤函数指针接收，函数指针指向什么函数就调⽤什么函数，这⾥其实使⽤的就是回调函数的功能。

cpp 复制代码

//使⽤回调函数改造前 

#include <stdio.h>

int add(int a, int b)
{
 return a + b;
}

int sub(int a, int b)
{
 return a - b;
}

int mul(int a, int b)
{
 return a * b;
}

int div(int a, int b)
{
 return a / b;
}

int main()
{
 int x, y;
 int input = 1;
 int ret = 0;
 do

 {
 

printf("*************************
\n");
 printf(" 1:add 
 2:sub \n");
 printf(" 3:mul 
 4:div \n");
 

printf("*************************
\n");
 printf("请选择：");
 scanf("%d", &input);
 switch (input)
 {
 case 1:
 printf("输⼊操作数：");
 scanf("%d %d", &x, 
&y);
 ret = add(x, y);
 printf("ret = %d\n", 
ret);
 break;
 case 2:
 printf("输⼊操作数：");
 scanf("%d %d", &x, 
&y);
 ret = sub(x, y);
 printf("ret = %d\n", 
ret);
 break;
 case 3:
 printf("输⼊操作数：");
 scanf("%d %d", &x, 
&y);
 ret = mul(x, y);
printf("ret = %d\n", 
ret);
 break;
 case 4:
 printf("输⼊操作数：");
 scanf("%d %d", &x, 
&y);
 ret = div(x, y);
 printf("ret = %d\n", 
ret);
 break;
 case 0:
 printf("退出程序\n");
 break;
 default:
 printf("选择错误\n");
 break;
 }
 } while (input);
 return 0;
}

cpp 复制代码

//使⽤回到函数改造后 

#include <stdio.h>

int add(int a, int b)
{
 return a + b;
}

int sub(int a, int b)
{
 return a - b;
}

int mul(int a, int b)
{
 return a * b;
}

int div(int a, int b)
{
 return a / b;
}

void calc(int(*pf)(int, int))
{
 int ret = 0;
 int x, y;
 printf("输⼊操作数：");
 scanf("%d %d", &x, &y);
 ret = pf(x, y);
 printf("ret = %d\n", ret);
}

int main()
{
 int input = 1;
 do

 {
 

printf("*************************
\n");
 printf(" 1:add 
 2:sub \n");
 printf(" 3:mul 
 4:div \n");
 

printf("*************************
\n");
 printf("请选择：");
 scanf("%d", &input);
 switch (input)
 {
 case 1:
 calc(add);
 break;
 case 2:
 calc(sub);
 break;
 case 3:
 calc(mul);
 break;
 case 4:
 calc(div);
 break;
 case 0:
 printf("退出程序\n");
break;
 default:
 printf("选择错误\n");
 break;
 }
 } while (input);
 return 0;
}

2. qsort使⽤举例

2.1 使⽤qsort函数排序整型数据

cpp 复制代码

#include <stdio.h>

//qosrt函数的使⽤者得实现⼀个⽐较函数 

int int_cmp(const void * p1, const void * p2)
{
 return (*( int *)p1 - *(int *) p2);
}

int main()
{
 int arr[] = { 1, 3, 5, 7, 9, 2, 4, 6, 8, 0 };
 int i = 0;
 
 qsort(arr, sizeof(arr) / sizeof(arr[0]), sizeof (int), int_cmp);
 for (i = 0; i< sizeof(arr) / sizeof(arr[0]); i++)
 {
printf( "%d ", arr[i]);
 }
 printf("\n");
 return 0;
}

2.2 使⽤qsort排序结构数据

cpp 复制代码

struct Stu //学⽣

{
 char name[20];//名字 
 int age;//年龄 
};

//假设按照年龄来⽐较 

int cmp_stu_by_age(const void* e1, const void* e2)
{
 return ((struct Stu*)e1)->age - ((struct Stu*)e2)->age;
}

//strcmp - 是库函数，是专⻔⽤来⽐较两个字符串的⼤⼩的 

//假设按照名字来⽐较 

int cmp_stu_by_name(const void* e1, const void* e2)
{
 return strcmp(((struct Stu*)e1)->name, ((struct Stu*)e2)->name);
}

//按照年龄来排序 

void test2()
{
 struct Stu s[] = { {"zhangsan", 20}, {"lisi", 30}, {"wangwu", 15} };
 int sz = sizeof(s) / sizeof(s[0]);
 qsort(s, sz, sizeof(s[0]), cmp_stu_by_age);
}

//按照名字来排序 

void test3()
{
 struct Stu s[] = { {"zhangsan", 20}, {"lisi", 30}, {"wangwu", 15} };
 int sz = sizeof(s) / sizeof(s[0]);
 qsort(s, sz, sizeof(s[0]), cmp_stu_by_name);
}

int main()
{
test2();
 test3();
 return 0;
}

3. qsort函数的模拟实现

使⽤回调函数，模拟实现qsort（采⽤冒泡的⽅式）。

注意：这⾥第⼀次使⽤void* 的指针，讲解**void***的作⽤。

cpp 复制代码

#include <stdio.h>

int int_cmp(const void * p1, const void * p2)
{
 return (*( int *)p1 - *(int *) p2);
}

void _swap(void *p1, void * p2, int size)
{
 int i = 0;
 for (i = 0; i< size; i++)
 {
 char tmp = *((char *)p1 + i);
 *(( char *)p1 + i) = *((char *) p2 + i);
 *(( char *)p2 + i) = tmp;
 }
}

void bubble(void *base, int count , int size, int(*cmp )(void *, void *))
{
 int i = 0;
 int j = 0;
 for (i = 0; i< count - 1; i++)
 {
 for (j = 0; j<count-i-1; j++)
 {
 if (cmp ((char *) base + j*size , (char *)base + (j + 1)*size) > 0)
 {
 _swap(( char *)base + j*size, (char *)base + (j + 1)*size, 
size);
 }
 }
 }
}

int main()
{
 int arr[] = { 1, 3, 5, 7, 9, 2, 4, 6, 8, 0 };
 int i = 0;
 bubble(arr, sizeof(arr) / sizeof(arr[0]), sizeof (int), int_cmp);
 for (i = 0; i< sizeof(arr) / sizeof(arr[0]); i++)
 {
 printf( "%d ", arr[i]);
 }
 printf("\n");
 return 0;
}

五、

1. sizeof和strlen的对⽐

1.1 sizeo

在学习操作符的时候，我们学习了sizeof ， sizeof 计算变量所占内存内存空间⼤⼩的，单位是字节，如果操作数是类型的话，计算的是使⽤类型创建的变量所占内存空间的⼤⼩。

sizeof 只关注占⽤内存空间的⼤⼩，不在乎内存中存放什么数据。⽐如：

cpp 复制代码

#inculde <stdio.h>

int main()
{
 int a = 10;
 printf("%d\n", sizeof(a));
 printf("%d\n", sizeof a);
 printf("%d\n", sizeof(int));
 
 return 0;
}

1.2 strlen

strlen 是C语⾔库函数，功能是求字符串⻓度。函数原型如下：

cpp 复制代码

1 size_t strlen ( const char * str );

统计的是从 strlen 函数的参数 str 中这个地址开始向后， \0 之前字符串中字符的个数。

strlen 函数会⼀直向后找 \0 字符，直到找到为⽌，所以可能存在越界查找。

cpp 复制代码

#include <stdio.h>

int main()
{
 char arr1[3] = {'a', 'b', 'c'};
 char arr2[] = "abc";
 printf("%d\n", strlen(arr1));
 printf("%d\n", strlen(arr2));
 
 printf("%d\n", sizeof(arr1));
 printf("%d\n", sizeof(arr2));
 return 0;
}

1.3 sizeof 和strlen的对⽐

|-------------------------------|-----------------------------------------------|
| sizeof | strlen |
| sizeof是操作符 | strlen 是库函数，使⽤需要包含头⽂件 string.h |
| sizeof计算操作数所占内存的⼤⼩，单位是字节 | srtlen 是求字符串⻓度的，统计的是 \0 之前字符的隔个数 |
| 不关注内存中存放什么数据 | 关注内存中是否有 \0 ，如果没有**\0** ，就会持续往后找，可能会越界 |

2. 数组和指针笔试题解析

2.1 ⼀维数组

cpp 复制代码

int a[] = {1,2,3,4};

printf("%d\n",sizeof(a));

printf("%d\n",sizeof(a+0));

printf("%d\n",sizeof(*a));

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

printf("%d\n",sizeof(a[1]));

printf("%d\n",sizeof(&a));

printf("%d\n",sizeof(*&a));

printf("%d\n",sizeof(&a+1));

printf("%d\n",sizeof(&a[0]));

printf("%d\n",sizeof(&a[0]+1));

2.2 字符数组

代码1：

cpp 复制代码

char arr[] = {'a','b','c','d','e','f'};

printf("%d\n", sizeof(arr));

printf("%d\n", sizeof(arr+0));

printf("%d\n", sizeof(*arr));

printf("%d\n", sizeof(arr[1]));

printf("%d\n", sizeof(&arr));

printf("%d\n", sizeof(&arr+1));

printf("%d\n", sizeof(&arr[0]+1));

代码2：

cpp 复制代码

char arr[] = {'a','b','c','d','e','f'};

printf("%d\n", strlen(arr));

printf("%d\n", strlen(arr+0));

printf("%d\n", strlen(*arr));

printf("%d\n", strlen(arr[1]));

printf("%d\n", strlen(&arr));

printf("%d\n", strlen(&arr+1));

printf("%d\n", strlen(&arr[0]+1));

代码3：

cpp 复制代码

char arr[] = "abcdef";

printf("%d\n", sizeof(arr));

printf("%d\n", sizeof(arr+0));

printf("%d\n", sizeof(*arr));

printf("%d\n", sizeof(arr[1]));

printf("%d\n", sizeof(&arr));

printf("%d\n", sizeof(&arr+1));

printf("%d\n", sizeof(&arr[0]+1));

代码4：

cpp 复制代码

char arr[] = "abcdef";

printf("%d\n", strlen(arr));

printf("%d\n", strlen(arr+0));

printf("%d\n", strlen(*arr));

printf("%d\n", strlen(arr[1]));

printf("%d\n", strlen(&arr));

printf("%d\n", strlen(&arr+1));

printf("%d\n", strlen(&arr[0]+1));

代码5：

cpp 复制代码

char *p = "abcdef";

printf("%d\n", sizeof(p));

printf("%d\n", sizeof(p+1));

printf("%d\n", sizeof(*p));

printf("%d\n", sizeof(p[0]));

printf("%d\n", sizeof(&p));

printf("%d\n", sizeof(&p+1));

printf("%d\n", sizeof(&p[0]+1));

代码6：

cpp 复制代码

char *p = "abcdef";

printf("%d\n", strlen(p));

printf("%d\n", strlen(p+1));

printf("%d\n", strlen(*p));

printf("%d\n", strlen(p[0]));

printf("%d\n", strlen(&p));

printf("%d\n", strlen(&p+1));

printf("%d\n", strlen(&p[0]+1));

2.3 ⼆维数组

cpp 复制代码

int a[3][4] = {0};

printf("%d\n",sizeof(a));

printf("%d\n",sizeof(a[0][0]));

printf("%d\n",sizeof(a[0]));

printf("%d\n",sizeof(a[0]+1));

printf("%d\n",sizeof(*(a[0]+1)));

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

printf("%d\n",sizeof(*(a+1)));

printf("%d\n",sizeof(&a[0]+1));

printf("%d\n",sizeof(*(&a[0]+1)));

printf("%d\n",sizeof(*a));

printf("%d\n",sizeof(a[3]));

数组名的意义：

sizeof(数组名)，这⾥的数组名表⽰整个数组，计算的是整个数组的⼤⼩

&数组名，这⾥的数组名表⽰整个数组，取出的是整个数组的地址。

除此之外所有的数组名都表⽰⾸元素的地址。

3. 指针运算笔试题解析

3.1 题⽬1：

cpp 复制代码

#include <stdio.h>

int main()
{
 int a[5] = { 1, 2, 3, 4, 5 };
 int *ptr = (int *)(&a + 1);
 printf( "%d,%d", *(a + 1), *(ptr - 1));
 return 0;
}

//程序的结果是什么？

3.2 题⽬2

cpp 复制代码

//在X86环境下 

//假设结构体的⼤⼩是20个字节 

//程序输出的结果是啥？ 

struct Test

{
int Num;
 char *pcName;
 short sDate;
 char cha[2];
 short sBa[4];
}*p = (struct Test*)0x100000;

int main()
{
 printf("%p\n", p + 0x1);
 printf("%p\n", (unsigned long)p + 0x1);
 printf("%p\n", (unsigned int*)p + 0x1);
 return 0;
}

3.3 题⽬3

cpp 复制代码

#include <stdio.h>

int main()
{
 int a[3][2] = { (0, 1), (2, 3), (4, 5) };
 int *p;
 p = a[0];
 printf( "%d", p[0]);
 return 0;
}

3.4 题⽬4

cpp 复制代码

//假设环境是x86环境，程序输出的结果是啥？ 

#include <stdio.h>

int main()
{
 int a[5][5];
 int(*p)[4];
 p = a;
 printf( "%p,%d\n", &p[4][2] - &a[4][2], &p[4][2] - &a[4][2]);
 return 0;
}

3.5 题⽬5

cpp 复制代码

#include <stdio.h>

int main()
{
 int aa[2][5] = { 1, 2, 3, 4, 5, 6, 7, 8, 9, 10 };
 int *ptr1 = (int *)(&aa + 1);
 int *ptr2 = (int *)(*(aa + 1));
 printf( "%d,%d", *(ptr1 - 1), *(ptr2 - 1));
 return 0;
}

3.6 题⽬6

cpp 复制代码

#include <stdio.h>

int main()
{
 char *a[] = {"work","at","alibaba"};
 char**pa = a;
 pa++;
 printf("%s\n", *pa);
 return 0;
}

3.7 题⽬7

cpp 复制代码

#include <stdio.h>

int main()
{
 char *c[] = {"ENTER","NEW","POINT","FIRST"};
 char**cp[] = {c+3,c+2,c+1,c};
 char***cpp = cp;
 printf("%s\n", **++cpp);
 printf("%s\n", *--*++cpp+3);
 printf("%s\n", *cpp[-2]+3);
 printf("%s\n", cpp[-1][-1]+1);
 return 0;
}