深度剖析指针的进阶——C语言的进阶篇

大家好我是沐曦希

---

前言

指针的概念：

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

指针又分为字符指针，整型指针，函数指针，数组指针等。

char* pc = 'w';
//字符指针
int a = 10;
int* pi = a;
//整型指针
#include
int Add(int x, int y)
{
	return x + y;
}
int main()
{
	int (*p)(int x, int y) = Add;//函数指针
	//int (*p)(int, int) = &Add;
	//函数在定义后就有地址，不管有没有定义，放在代码区，只读不能改。
	return 0;
}
int arr[5] = { 0 };
int (*p)[5] = &arr;
//数组指针
int* arr[5] = { 0 };
//指针数组

2.字符指针

在指针的类型中我们知道有一种指针类型为字符指针 char* （C语言指针初阶详解）
有两种使用方式：
第一种用法：指向字符（可以改变字符常量}

#include
int main()
{
	char ch = 'w';
	printf("%c\n", ch);
	char* pch = &ch;//将ch的地址保存在指针变量pch中
	*pch = 'a';//通过解引用指针变量pch来找到ch，并改变ch的值。
	printf("%c\n", ch);
	printf("%p\n", &ch);
	printf("%c\n", *pch);
	printf("%p\n", pch);
	return 0;
}

第二种用法：指向字符串（不可以改变字符串常量）

#include
int main()
{
	const char* p = "abc";//这里是把字符串首字母a的地址存放在字符指针变量p中
	printf("%s\n", p);//通过字符串的首字母a的地址打印字符串
	return 0;
}

需要注意的是：此时字符串常量是不能改变的。

#include
int main()
{
	char* p = "abc";
	*p = 'w';//error
	printf("%s\n", p);
	return 0;
}

代码 const char* p = “abc”;
特别容易以为是把字符串abc放到字符指针 p 里了，但是本质是把字符串 abc 首字符的地址放到了p中。

练习

#include
int main()
{
	int* p1 = "hello world";
	int* p2 = "hello world";
	int arr1[] = { "hello world" };
	int arr2[] = { "hello world" };
	if (p1 == p2)
		printf("p1 and p2 are same\n");
	else
		printf("p1 and p2 are not same\n");
	if (arr1 == arr2)
		printf("arr1 and arr2 are same\n");
	else
		printf("arr1 and arr2 are not same\n");
	return 0;
}

这里p1和p2指向的是一个同一个常量字符串。C/C++会把常量字符串存储到单独的一个内存区域。当几个指针指向同一个字符串的时候，他们实际会指向同一块内存。
但是用相同的常量字符串去初始化不同的数组的时候就会开辟出不同的内存块。所以arr1和arr2不同，p1和p2相同。

3.指针数组

在（C语言指针初阶详解）学了指针数组，指针数组是一个存放指针的数组。

//数组
int arr1[10];//整型数组
char arr2[5];//字符数组
//指针数组
int* arr3[6];//存放整形指针的数组
char* arr4[5];//存放字符指针的数组

运用指针数组来模拟二维数组

#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* parr[] = { arr1,arr2,arr3 };
	int i = 0;
	for (i = 0; i < 3; i++)
	{
		int j = 0;
		for (j = 0; j < 5; j++)
		{
			printf("%d ", *(parr[i] + j));
		}
		printf("\n");
	}
	return 0;
}

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

注：二级指针专门用来存储一级指针的地址。

数组指针

数组指针的定义

数组指针是指针。
整形指针： int * pint; 能够指向整形数据的指针。
浮点型指针： float * pf; 能够指向浮点型数据的指针。
那数组指针应该是：能够指向数组的指针。

int* p[10];//指针数组
int (*p2)[10];//数组指针，p2可以指向一个数组，该数组有10个元素，每个元素是int类型
//p先和*结合，说明p是一个指针变量，然后指向的是一个大小为40的整型数组，深渊p是一个指针，指向一个数组，叫数组指针
//p的类型是 int(*)[10]
//[]的优先级要高于*号的，深渊必须加上()来保证p先和*结合

&数组名VS数组名

int arr[10];

arr 和 &arr 分别是啥？
我们知道arr是数组名，数组名表示数组首元素的地址。
那&arr数组名到底是啥？

数组名表示首元素的地址。但是有两个例外：
1，sizeof（数组名），这里的数组明表示整个数组，计算的是整个数组的大小，单位字节。
2，&数组名，这里的数组表示的依然是整个数组，所以&数组名取得是整个数组的地址
例如：

int main()
{
	int arr[10] = { 0 };
	printf("arr = %p\n", arr);
	printf("arr + 1 = %p\n", arr + 1);
	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);
	int sz = sizeof(arr);
	printf("sz = %d\n", sz);
	return 0;
}

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

数组指针的使用

那数组指针是怎么使用的呢？
既然数组指针指向的是数组，那数组指针中存放的应该是数组的地址。

char* arr[5] = { 0 };
	char* (*p)[5] = &arr;

别扭的用法（一般很少用）：

#include
int main()
{
	int arr[] = { 1,2,3,4,5,6,7,8,9,10 };
	int(*p)[10] = &arr;//必须写清多少个元素
	//p是指向数组的，*p其实相当于数组名
	//数组名又是数组的首元素的地址
	//所以*p本质上是数组的首元素的地址
	int i = 0;
	int sz = sizeof(arr) / sizeof(arr[0]);
	for (i = 0; i < sz; i++)
	{
		printf("%d ", *(*p + i));
	}
	return 0;
}

数组指针一般用于二维以上的数组。一般用法：

#include
void print1(int(*p)[5], int r, int c)
{
	int i = 0;
	for (i = 0; i < r; i++)
	{
		int j = 0;
		for (j = 0; j < c; j++)
		{
			printf("%d ", *(*p + i) + j);//printf("%d ", p[i][j]);
		}
		printf("\n");
	}
}
int main()
{
	int arr[3][5] = { 2,3,4,5,6,3,4,5,6,7,4,5,6,7,8 };
	print1(arr, 3, 5);
	return 0;
}

二维数组中数组名表示第一行的地址，第一行的地址是一个二维数组的地址。
上面代码中的

int (*p)[5];
//p的类型是: int(*)[5]
//p是指向一个整型数组的，该数组有五个元素，int[5]
//p+1->跳过一个5个int类型的元素的数组
int arr[10];//&arr-->int(*)[10]//arr-->int*
int (*p)[10] = &arr;//指针变量p的类型：int (*)[10]//&arr+1跳过40个字节
int* p2;//p2+1跳过一个整型

int data[10]={1,2,3,4,5,6,7,8,9,10};
print3(data);
print4(&data);
void print3(int* p)
{}
void print4(int (*p)[10])
{}

int arr[5];//整型数组
int *parr1[10];//整形指针数组
int (*parr2)[10];//parr2是数组指针
int (*parr3[10])[5]={&arr1,&arr2,&arr3};//parr3是存放数组指针的数组

数组参数、指针参数

在写代码的时候难免要把【数组】或者【指针】传给函数，那函数的参数该如何设计呢？

一维数组传参

#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,10 };
	int* p = arr;
	int sz = sizeof(arr) / sizeof(arr[0]);
	//一级指针，传给函数
	print(p, sz);
	return 0;
}

二维数组传参

void test(int arr[3][5])//ok
{}
void test(int arr[][])//error
{}
void test(int arr[][5])//ok
{}
//总结：二维数组传参，函数形参的设计只能省略第一个[]的数字。
//因为对一个二维数组，可以不知道有多少行，但是必须知道一行多少元素。
//这样才方便运算。
void test(int* arr)//erroe
{}
void test(int* arr[5])//error
{}
void test(int(*arr)[5])//ok
{}
void test(int** arr)//error
{}
int main()
{
	int arr[3][5] = { 0 };
	test(arr);
}

一级指针传参

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

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

void print(int* p)
{}
int a=10;
int *ptr=&a;
int arr[10];
print(&a);
print(ptr);
print(arr);

二级指针传参

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

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

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

4.写在最后

友友们觉得不错的可以给个关注，点赞或者收藏哦！感谢各位友友们的支持。

你的❤️点赞是我创作的动力的源泉
你的✨收藏是我奋斗的方向
你的关注是对我最大的支持
你的✏️评论是我前进的明灯
创作不易，希望大佬你支持一下小沐吧