【C语言】＜指针最详解＞最速传说と疾走の猛虎！指针纯一郎です-CSDN博客

本文链接：https://blog.csdn.net/m0_71132755/article/details/135622654

【C语言】<深入理解指针>

1. 内存和地址
- 1.1 内存
- 1.2 究竟应该如何理解编址
2. 指针变量和地址
- 2.1 取地址操作符（&）
- 2.2 指针变量和解引用操作符（*）
- 2.3 指针变量的大小
3. 指针变量类型的意义
- 3.1 指针的解引用
- 3.2 指针 +- 整数
- 3.3 void* 指针
4. const 修饰指针
- 4.1 const修饰变量
- 4.2 const修饰指针变量
5. 指针运算
- 5.1 指针 +- 整数
- 5.2 指针 - 指针
- 5.3 指针指向的空间释放
6. 野指针
- 6.1 野指针形成原因
- 6.2 如何规避野指针
7. 二级指针
8. assert 断言
9. 指针的使用和传址的调用
- 9.1 strlen的模拟实现
- 9.2 传值调用与传址调用
10. 数组名的理解
- 10.1. 使用指针访问数组
- 10.2. 一维数组传参本质
11. 指针数组
- 11.1 指针数组模拟二维数组
12. 指针变量
- 12.1 字符指针变量
- 12.2 数组指针变量
- - 12.2.1 数组指针变量是什么
  - 12.2.2 数组指针变量怎么初始化
- 12.3 函数指针变量
- 12.4 二维数组传参的本质
13. 指针应用（转移表）

1. 内存和地址

1.1 内存

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

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

一楼：101，102，103…
二楼：201，202，203…
…

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

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

如果把上面的例子对照到计算中，又是怎么样呢？

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

其实也是把内存划分为一个个的内存单元，每个内存单元的大小取1个字节。

计算机中常见的单位（补充）：
一个比特位可以存储一个二进制的位1或0

bit - 比特位
byte - 字节
KB
MB
GB
TB
PB

1 byte = 8bit
1KB = 1024byte
1MB = 1024KB
1GB = 1024MB
1TB = 1024GB
1PB = 1024TB

其中，每个内存单元，相当于一个学生宿舍，一个字节空间里面能放8个比特位，就好比有些学校同学住的八人间，每个人是一个比特位。

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

生活中我们把门牌号也叫地址，在计算机中我们把内存单元的编号也称为地址。C语言中给地址起了新的名字叫：指针。
在这里插入图片描述
所以我们可以理解为：

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

1.2 究竟应该如何理解编址

CPU访问内存中的某个字节空间，必须知道这个字节空间在内存的什么位置，而因为内存中字节很多，所以需要给内存进行编址（就如同宿舍很多，需要给宿舍编号一样）。

计算机中的编址，并不是把每个字节的地址记录下来，而是通过硬件设计完成的。

钢琴、吉他上面没有写上“ 都瑞咪发嗦啦 ”这样的信息，但是演奏者照样能够准确找到每一个琴弦的每一个位置，这是为什么？因为制造商已经在乐器硬件层面上设计好了，并且所有的演奏者都知道。本站及是一种约定出来的共识！

硬件编址也是如此
首先，必须理解，计算机内是有很多的硬件单元，而硬件单元是要相互协同工作的。所谓的协同，至少相互之间要能够进行数据传递。

但是硬件与硬件之间是相互独立的，那么如何通信呢？答案很简单，用“ 线 ”连起来。

而CPU和内存之间也是有大量的数据交互的，所以，两者必须也用线连起来。

不过，我们今天关心一组线，叫做地址总线。
在这里插入图片描述
我们可以简单理解，32位机器有32根地址总线，每根线只有两态，表示0，1【电脉冲有无】，那么一根线，就能表示两种含义，两根线就能表示四种含义，依次类推。32根地址线，就能表示2^32种含义，每一种含义都代表一个地址。

地址信息被下达给内，在内存上，就可以找到改地址对应的数据，将数据在通过数据总线传入CPU内寄存器。

2. 指针变量和地址

2.1 取地址操作符（&）

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

#include <stdio.h>
int main()
{
    int a = 10;
    return 0;
}

在这里插入图片描述
比如，上述的代码就是创建了整型变量a，内存中申请4个字节，用于存放整数10，其中每个字节都有地址，上图中4个字节的地址分别是：

0x006FFD70
0x006FFD71
0x006FFD72
0x006FFD73

那我们如何能得到a的地址呢？
这里就得学习一个操作符（&）- 取地址符

#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，这个数值有时候也是需要存储起来，方便后期再使用的，那我们把这样的地址存放在哪里呢？答案是：指针变量中。

比如：

#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语言中其实也是一样的，我们只要拿到了地址（指针），就可以通过地址（指针）找到地址（指针）指向的对象，这里必须学习一个操作符，解引用操作符（*）。

#include <stdio.h>

int main()
{
    int a = 100;
    int *pa = &a;
    *pa = 0;
    printf("%d",a);//这里打印出来的a就是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个字节。

#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 指针的解引用

对比，下面两段代码，主要在调试时观察内存的变化。

//代码1
#include <stdio.h>
int main()
{
    int n = 0x11223344;
    int *p1 = &n;
    *pi = 0;
    return 0；
}

//代码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的指针解引用就只能访问1个字节，而int的指针的解引用就可以访问4个字节.

3.2 指针 ± 整数

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

#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个字节。这就是指针变量的类型差异带来的变化。

**结论：**指针的类型决定了指针向前或者向后走一步有多大（距离）。

3.3 void* 指针

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

举例：

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

在上面的代码中，将一个int类型的变量的地址赋值给一个char类型的指针变量。编译器给出了一个警告（如下图），是因为类型不兼容。而使用void类型就不会有这样的问题。
在这里插入图片描述
使用void*类型的指针接收地址：

#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的作用。

#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，那就可以做到了，虽然这样做是在打破语法规则。

#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修饰指针变量

#include <stdio.h>

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

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

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

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 指针 ± 整数

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

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

数组元素和下标

#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 指针 - 指针

//指针-指针
#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 指针指向的空间释放

//指针的关系运算
#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 野指针形成原因

1. 指针未初始化

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

2. 指针越界访问

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

3. 指针指向的空间释放

#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也是一个地址，这个地址是无法使用的，读写该地址都会报错。

 #ifdef __cplusplus
 #define NULL 0
 #else
 #define NULL ((void *)0)
 #endif

初始化如下：

#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，看看是不是被拴起来的野狗，如果是，就不能直接使用，如果不是，我们再去使用它。

#include <stdio.h>

int main()
{
	int i = 0;
	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. 二级指针

指针变量也是变量，是变量就有地址，那指针变量的地址存放在哪里？

这就是二级指针

二级指针画图
对于二级指针的运算有：

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

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

*ppa 先通过ppa找到pa，然后对pa进行解引用操作：*pa，那找到的是a

  **ppa = 30;
  //等价于*pa = 30;
  //等价于a = 30;

8. assert 断言

assert.h 头文件定义了宏assert()，用于在运行时确保程序符合指定条件，如果不符合，就报错然后终止运行。这个宏常常被称为“断言”。

  assert(p != NULL);

上面代码在程序运行到这一行语句的时候，验证变量p是否等于NULL。如果确实不等于NULL，程序继续运行，否则就会终止运行，并且给出报错信息提示。

assert() 宏接受一个表达式作为参数。如果该表达式为真（返回值非0），assert() 不会产生任何作用，程序继续运行。如果表达式返回为假（返回值为0），assert() 就会报错，在标准错误流 stderr 中写入一条错误信息，显示没有通过的表达式，以及包含整个表达式的文件名和行号。

assert() 的使用对程序员是非常友好的，使用assert() 有几个好处：它不仅能自动识别文件和出问题的行号，还有一种无需更改代码就能开启或关闭assert() 的机制。如果已经确定程序没有问题，不需要再做断言，就在 #include <assert.h> 语句的前面，定义一个宏NDBUG。

  #define NDEBUG
  #include <assert.h>

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

**assert() **的缺点是，因为引入了额外的检查，增加了程序的运行时间。

一般我们可以在 Debug 中使用，在 Release 版本中选择禁用 assert 就行，在VS这样的集成开发环境中，在 Release 版本中，直接就是优化掉了。这样在debug版本写有利于程序员排查问题，在Release版本不影响用户使用时程序的效率。

9. 指针的使用和传址的调用

9.1 strlen的模拟实现

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

函数原型如下：

  size_t strlen ( const char * str );

参数 str 接收一个字符串的起始地址，然后开始统计字符串中 \0 之前的字符个数，最终返回长度。

如果要模拟实现只要从起始地址开始向后逐个字符的遍历，只要不是 \0 字符，计数器就+1，这样直到 \0 就停止。

参考代码如下：

#include <stdio.h>

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

9.2 传值调用与传址调用

学习指针的目的是使用指针解决问题，那什么问题，非指针不可呢？

例如：写一个函数，交换两个整型变量的值

一番思考后，我们可能写出这样的代码：

#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，并达到交换的效果就好了。

#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);
	Swap1(&a, &b);
	printf("交换后：a=%d b=%d\n", a, b);
	return 0;
}

首先看输出结果：
在这里插入图片描述
我们可以看到实现成Swap2的方式，顺利完成了任务，这里调用Swap2函数的时候是将变量的地址传递给了函数，这种函数调用方式叫：传址调用。

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

10. 数组名的理解

在上一个章节我们在使用指针访问数组的时候，有这样的代码：

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

这里我们使用 &arr[0] 的方式拿到了数组第一个元素的地址，但是其实数组名本来就是地址，而且是数组首元素的地址，我们来做个测试。

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

输出结果：
在这里插入图片描述
我们发现数组名和数组首元素的地址结果是一模一样的，数组名就是数组首元素（第一个元素）的地址。

这时候有同学会有疑问，数组名如果是数组首元素的地址，那下面这段代码该怎么理解呢？

#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中单独放数组名，这里的数组名表示整个数组，计算的是整个数组的大小，单位是字节
&数组名 ，这里的数组名表示整个数组，取出的是整个数组的地址（整个数组的地址和数组首元素的地址是有区别的）

除此之外，任何地方使用数组名，数组名都表示首元素的地址。

这时就会有好奇的同学，再试一下整个代码：

#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有啥区别呢？

#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[0]和arr都是首元素的地址，+1就是跳过一个元素。

但是&arr和&arr+1相差40个字节，这就是因为&arr是整个数组的地址，+1操作是跳过整个数组的。

到这里大家应该搞清楚数组名的意义了吧。

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

10.1. 使用指针访问数组

有了前面知识的支持，再结合数组的特点，我们就可以很方便的使用指针访问数组了。

#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]是否也可以访问数组呢？

#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)，数组元素的访问在编译器处理的时候，也是转换成首元素地址+偏移量求出元素的地址，然后解引用来访问的。

10.2. 一维数组传参本质

数组我们学过了，之前也讲过了，数组是可以传递给函数的，这个小节我们讨论一下数组传参的本质。

首先从一个问题开始，我们之前都是在函数外部计算数组的元素个数，那我们可以把函数传给一个函数后，在函数内部求元素个数吗？

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

输出的结果（32位下）：
在这里插入图片描述
我们发现在函数内部是没有正确获得数组的元素个数。

这就要学习数组传参的本质了，上面我们学习了：数组名是数组首元素的地址；那么在数组传参的时候，传递的是数组名，也就是说本质上数组传参传递的是数组首元素的地址 。

所以函数形参的部分理论上应该使用指针变量来接收首元素的地址。那么在函数内部我们写sizeof(arr)计算的是一个地址的大小（单位字节）而不是数组的大小（单位字节）。正是因为函数的参数部分的本质是指针，所以在函数内部是没办法求数组元素个数的。

#include <stdio.h>

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

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

11. 指针数组

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

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

那指针数组呢？是存放指针的数组
整型数组和字符数组
指针数组的每个元素都是用来存放地址（指针）的。

如下图：

指针数组的每个元素是地址，又可以指向一个区域。

11.1 指针数组模拟二维数组

#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数组的画图演示
parr[i]是访问parr数组的元素，parr[i]找到的数组元素指向了整型一维数组，parr[i][j]就是整型一维数组中的元素。

上述的代码模拟出二维数组的效果，实际上并非完全是二维数组，因为每一行并非是连续的。

12. 指针变量

12.1 字符指针变量

在指针的类型中我们知道有一种指针类型为字符指针char*;
一般使用：

#include <stdio.h>

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

还有一种使用的方法如下：

#include <stdio.h>

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

代码 const char* pstr = “Hello NineSense”; 特别容易让同学以为是把字符串Hello NineSense放到字符指针pstr里面了，但是本质上是把字符串Hello NineSense的首字符的地址放到了pstr中。
在这里插入图片描述
上面代码的意思是把一个常量字符串的首字符H的地址存放到指针变量pstr中。

《剑指offer》中收录了一道和字符串相关的笔试题，让我们一起来学习一下：

#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相同。

12.2 数组指针变量

12.2.1 数组指针变量是什么

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

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

答案是：指针变量。

我们已经熟悉：

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

那数组指针变量：存放的应该是数组的地址，能够指向数组的指针变量。

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

  int *p1[10];
  int (*p2)[10];

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

数组指针变量

  int (*p)[10];

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

这里要注意：[ ]的优先级要高于*号，所以必须加上()来保证p先和*结合。

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

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

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

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

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

在这里插入图片描述
我们调试也能看到&arr和p的类型是完全一致的。

数组指针类型解析：

12.3 函数指针变量

12.3.1 函数指针变量的创建

什么是函数指针变量呢？

根据前面学习整形指针，数组指针的时候，我们类比关系，不难得出结论：
函数指针变量应该是用来存放函数地址的，未来通过地址能够调用函数的。

那么函数是否有地址呢？

我们做个测试：

#include <stdio.h>

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

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

输出结果如下：

test: 005913CA
&test: 005913CA

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

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

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写上或者省略都是可以的

函数指针类型解析
在这里插入图片描述

12.3.2 函数指针变量的使用

通过函数指针调用指针指向的函数：

#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

12.3.3 两段有趣的代码

代码1:

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

代码2：

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

两段代码均出自：《C陷阱和缺陷》这本书

12.3.3.1 typedef关键字

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

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

typedef unsigned int uint;
//将unsigned int 重命名为uint

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

typedef int* ptr_t;

但是对于数组指针和函数指针稍微有点区别：
比如我们有数组指针类型 int(*)[5] ，需要重命名为 parr_t ，那可以这样写：

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

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

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

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

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

12.3.4 函数指针数组

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

比如：

int *arr[10];
//数组的每个元素是int*

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

int (*parr1[3])();
int *parr2[3]();
int (*)() parr3[3];

答案是：parr1

parr1先和 [ ] 结合，说明parr1是数组，数组的内容是什么呢？是 int(*)() 类型的函数指针。

12.4 二维数组传参的本质

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

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

#include <stdio.h>

void test(int a[3][5], int row, int col)
{
	int i = 0;
	int j = 0;
	for (i = 0; i < row; i++)
	{
		for (j = 0; j < col; 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]。那就意味着二维数组传参本质上也是传递了地址，传递的是第一行这个一维数组的地址，那么形参也可以写成指针形式的。如下：

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

**总结：**二维数组传参，形参的部分可以写成数组，也可以写成指针类型。

13. 指针应用（转移表）

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

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

#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;
	printf("********************\n");
	printf(" 1:add      2:sub \n\n");
	printf(" 3:mul      4:div \n\n");
	printf(" 0:exit \n");
	printf("********************\n");
	printf("请选择：");
	while(input)
	{
		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;
		}
	} 
	return 0;
}

使用函数指针数组实现：

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