进阶指针（一）

✨博客主页：小钱编程成长记
🎈博客专栏：进阶C语言

0.回顾初阶指针

1. 指针就是个变量，用来存放地址，地址唯一标识一块内存空间。（内存单元数有编号的，编号=地址=指针）
2. 指针的大小是固定的4/8个字节（32位平台/64位平台）。
3. 指针是有类型的，指针的类型决定了指针的±整数的步长，指针解引用操作的时候的权限。
4. 指针的运算。

1.字符指针

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

它有两种使用方式：

1. 指向字符
2. 指向字符串（实际上指向的是首字符，但因为字符串中的字符都是连续的，所以也可以说是指向字符串）

指针指向字符：

int main()
{
  char ch = 'w';
  char *pc = &ch;
  *pc = 'w';
  return 0;
}
1
2
3
4
5
6
7

指针指向字符串：

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

1
2
3
4
5
6
7

• const char* pstr = “abcdef”;
  这里不是把一个字符串放到pstr指针变量里，而是将字符串的首字符的地址放到了pstr里。因为当字符串作为一个表达式时，结果是首字符的地址。

• const *pstr = “abcdef” 和 char arr[] = “abcdef” 在内存中存储的都是abcdef\0 ；

• 因为"abcdef” 和 arr 表示的都是字符串的首字符地址，所以我们可以将常量字符串想象成数组名，“abcdef” == arr。
  
  如下所示：
  
  有些朋友可能会发现，为什么指针指向常量字符串时前面要加上const？比如：const char* pstr = “abcdef”;
  原因是：常量字符串在内存中不能被修改，若修改会出现写入错误（这个错误很难被及时发现）。如下所示：
  
  用const修饰指针变量，使其变成常变量，不能被修改，即使不小心修改了，也能在编译期间及时发现错误。如下所示：

1.1 相关面试题

//在《剑指offer》一书中有这样一道题
#include 
int main()
{
	char str1[] = "hello";
	char str2[] = "hello";
	const char* str3 = "hello";
	const char* str4 = "hello";
	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;
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19

结果为：

为什么呢？

1. 把常量字符串放到字符数组中，字符数组中存放的是字符。
   每个数组创建时在内存中开辟的空间并不同，所以用相同的常量字符串去初始化不同的数组的时候就会开辟出不同的内存块。（几个 数组的内容可能会相同，但每个数组在内存中的地址一定不同）
   所以str1和str2代表的首字符地址不同。
2. C/C++会把常量字符串存储到一个单独的内存区域。因为常量字符串不能被修改，没必要保存多份，所以在内存中只存储一份。
   当几个指针指向同一个字符串时，实际上它们指向的也是同一个地址。

2.数组指针

在初阶指针中我们也学了指针数组。指针数组是一个存放指针的数组，存放在数组中的元素都是指针类型的。
我们来复习一下下面的指针数组是什么意思？

int* arr1[10]; //整形指针的数组
char *arr2[4]; //一级字符指针的数组
char **arr3[5];//二级字符指针的数组
1
2
3

指针数组的使用场景举例：

//模拟二维数组
#include 
int main()
{
	int arr1[] = { 1,2,3,4,5 };
	int arr2[] = { 2,3,4,5,6 };
	int arr3[] = { 3,4,5,6,7 };
	int* arr[] = { arr1, arr2, arr3 };
	int i = 0;
	for (i = 0; i < 3; i++)
	{
		int j = 0;
		for (j = 0; j < 5; j++)
		{
			printf("%d ", arr[i][j]);
		}
		printf("\n");
	}
	return 0;
}

//一次性打印多个字符串
#include 
int main()
{
	char* arr[3] = { "hello", "hello", "C++" };
	int i = 0;
	for (i = 0; i < 3; i++)
	{
		printf("%s ", arr[i]);
	}
	return 0;
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33

3.指针数组

3.1 数组指针的定义

数组指针是指针？还是数组？
答案是：指针。
我们已经知道：
整型指针： int * pint; 能够指向整型数据的指针。
浮点型指针： float * pf; 能够指向浮点型数据的指针。
那数组指针应该是：能够指向数组的指针。

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

int *p1[10];//p1是指针数组名
int (*p2)[10];//p2是数组指针
1
2

解释：

int (*p)[10];
//解释：p先和*结合，说明p是一个指针变量，然后指向的是一个大小为10个整型的数组。所以p是一个指针，指向一个数组，叫数组指针。
//注意：必须明确指针指向的数组有几个元素，不写时，默认为0，与真实数组的元素个数不同，会出错。
//指向的数组的元素个数不同，数组指针的类型也不同。
1
2
3
4

3.2 &数组名VS数组名

arr和&arr分别是什么？

我们知道arr是数组名，数组名表示的是数组的首元素地址。
那&arr数组名是什么呢？
我们先来看一段代码和运行结果：

数组名和&数组名打印的地址是一样的。
难道两个是一样的吗？
我们再来看一段代码和运行结果：

根据上面的代码我们发现，其实&arr和arr，虽然值是一样的，但是意义是不一样的。
实际上： &arr 表示的是数组的地址，而不是数组首元素的地址。
本例中 &arr 的类型是： int(*)[10] ，是一种数组指针类型， 数组的地址+1，跳过整个数组的大小，所以 &arr+1 相对于 &arr 的差值是40

3.3 数组指针的使用

数组指针指向的是数组，那么数组指针中存放的应该是数组的地址。

#include 
int main()
{
	int arr[10] = { 1,2,3,4,5,6,7,8,9,0 };
	int(*p)[10] = &arr;//把数组arr的地址赋值给数组指针变量p
	return 0;
}
1
2
3
4
5
6
7

小提示：

printf("%d\n", (*p)[i]);//(*p) == *(&arr) == arr
printf("%d\n", p[i]);//p[i] == *(p+i) 因为p = &arr,所以p+i等于跳过了i个数组
1
2

数组指针主要应用于二维数组的传参：

#include 

void print_arr1(int(*arr)[5], int row, int col)//arr是数组指针
{
    int i = 0;
    for (i = 0; i < row; i++)
    {
        int j = 0;
        for (j = 0; j < col; j++)
        {
            printf("%d ", arr[i][j]);
            //arr[i][j] == (*(arr+i))[j], 
            //arr+i相当于二维数组的第i行的一维数组的地址，
            //*(arr+i)相当于二维数组的第i行的一维数组的首元素地址。
        }
        printf("\n");
    }
}

int main()
{
    int arr[3][5] = { 1,2,3,4,5,6,7,8,9,10 };
    print_arr1(arr, 3, 5);
    //数组名arr，表示首元素的地址
    //但是二维数组的首元素是二维数组的第一行
    //所以这里传递的arr，其实相当于第一行的地址，是一维数组的地址
    //可以数组指针来接收

    return 0;
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30

4.数组传参和指针传参

4.1 一维数组传参

#include 
void test(int arr[])//形参是数组的形式，但并不会真正创建一个数组，所以大小没有意义，可以随便写，也可以不写。数组形式的本质还是指针。
{}
void test(int arr[10])//形参是数组
{}
void test(int* arr)//形参是指针
{}

void test2(int* arr[20])//形参是指针数组
{}
void test2(int** arr)//形参是指针（元素）的指针，二级指针。
{}
int main()
{
	int arr[10] = { 0 };
	int* arr2[20] = { 0 };
	test(arr);
	test2(arr2);
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19

4.2 二维数组传参

void test(int arr[3][5])
{}
void test(int arr[][5])//行可以省略，但列不能省略，因为若不确定列，数据连续存储后，就无法正确拆开连续存储的数据排成几行输出。
{}

void test(int(*arr)[5])//因为二维数组的首元素是一维数组，所以形参用指针时要用数组指针。
{}

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

4.3 一级指针传参

#include 
void print(int* p, int sz)
{
	int i = 0;
	for (i = 0; i < sz; i++)
	{
		printf("%d\n", *(p + i));
	}
}
int main()
{
	int arr[10] = { 1,2,3,4,5,6,7,8,9 };
	int* p = arr;
	int sz = sizeof(arr) / sizeof(arr[0]);
	//一级指针p，传给函数，形参写成一级指针就行了。
	print(p, sz);
	return 0;
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18

思考：

当一个函数的参数部分为一级指针的时候，函数能接收什么参数？

例如：

void test1(int *p)//test1函数能接收什么参数？
{}

int main()
{
	int a = 10;
	test1(&a);//传整型变量的地址
	int* pa = &a;
	test1(pa);//传整型指针
	int arr[10] = { 1,2,3,4,5,6,7,8,9,0 };
	test1(arr);//传整形一维数组的数组名
	return 0;
}
1
2
3
4
5
6
7
8
9
10
11
12
13

4.4 二级指针传参

#include 
void test(int** ptr)
{
	printf("num = %d\n", **ptr);
}
int main()
{
	int n = 10;
	int* p = &n;
	int** pp = &p;
	test(pp);
	test(&p);
	return 0;
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14

思考：

当函数的参数为二级指针的时候，可以接收什么参数？

例如：

void test(char** p)
{}


int main()
{
	char c = 'b';
	char* pc = &c;
	char** ppc = &pc;
	char* arr[10];
	test(&pc);//指针的地址
	test(ppc);//二级指针
	test(arr);//指针数组的数组名：首元素（指针）的地址
	return 0;
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15

5.函数指针

我们先来看一段代码：

#include 

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

int main()
{
	printf("%p\n", &Add);
	printf("%p\n", Add);
	return 0;
}
1
2
3
4
5
6
7
8
9
10
11
12
13

由此可见：
&函数名和函数名都是函数的地址

int (*pf1)(int, int) = Add;//pf1就是函数指针变量
1

pf1先和*结合，说明pf1是指针，指向的是一个函数，指向的函数有两个参数，参数类型都是int，返回类型为int

举例：

#include 

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

int main()
{
	int (*pf1)(int, int) = &Add;
	int ret1 = (*pf1)(2, 3);//函数名是地址，地址也是函数名，所以写不写*都行，*几乎是个摆设，写几个都行。
	int ret11 = (pf1)(2, 3);

	//int ret3 = &Add(2, 3);//错误，因为Add会先与()结合，&取得是函数调用的返回值，但函数调用并不返回具体的变量或内存位置，所以出错。
	int ret3 = (&Add)(2, 3);																	//& 取的内容，必须是 = 左边出现过的或函数名(函数指示符)。

	int (*pf2)(int, int) = Add;
	int ret2 = (*pf2)(2, 3);
	int ret22 = (pf2)(2, 3);
	int ret33 = Add(2, 3);

	printf("%d\n", ret1);
	printf("%d\n", ret11);
	printf("%d\n", ret3);
	printf("%d\n", ret2);
	printf("%d\n", ret22);
	printf("%d\n", ret33);

	return 0;
}

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31

小知识：

int ret3 = &Add(2, 3); 错误，因为Add会先与()结合，&取得是函数调用的返回值，但函数调用并不返回具体的变量或内存位置，所以出错。
& 取的内容，必须是 = 左边出现过的 或 函数名(函数指示符)。

5.1 两段有趣的代码

《C陷阱和缺陷》一书中提及这两个代码：

代码1：
(*(void (*)())0)();
void (*)()是一个函数指针类型，(void ( * )())0 是把0强转成这种函数指针类型的数据。这个代码是用来调用0地址处的函数。这个函数没有参数，返回类型是void。（ *函数地址0的操作可写可不写，因为函数地址也就相当于函数名）

代码2：
void (*signal(int, void(*)(int)))(int);

• 这个代码是一次函数声明，声明的是signal函数，signal函数的参数有2个；第一个是int类型，第二个是函数指针类型，该类型是void ( * )(int)；该函数指针指向的函数，参数是int类型的，返回类型是void。
• signal函数的返回类型也是函数指针类型，该类型是void (*)(int)，该函数指针指向的函数，参数是int，返回类型是void。

疑问：

代码2太复杂了，能否简化呢？
可以用typedef类型重命名来解决:

》》与函数指针类型相关的内容，不能写在类型的左/右边，只能写在类型中 * 的后面。
typedef void (*pfun_t)(int);//类型重命名
pfun_t signal(int, pfun_t);//函数调用
然而：
typedef void (*)(int) pfun_t;//错误
void (*)(int) signed(int, void (*)(int))//错误

总结

本片文章我们回顾了初阶指针，又学习了两种字符指针、指针数组、数组指针及其使用、一维二维的数组传参和指针传参、函数指针。感谢大家的阅读！大家一起进步。如果文章有错误的地方，欢迎大家在评论区指正。

点赞收藏加关注，C语言学习不迷路！