你要悄悄努力，然后成为C语言高手--指针进阶（1）之字符指针、指针数组、数组指针

学习难吗？难！但又不难，不难的是你可以学习到知识，难的是你学的的知识会忘，所以，温故而知新就显的很重要了！( •̀ ω •́ )✧
今天我们一起来学习指针的进阶！

首先，如果我们先来聊一聊指针的一些基础概念。

1.我们口头上常说的指针指的是指针变量，用来存放地址，地址唯一标识一块内存空间（可以这样理解这句话：内存会划分为小的内存单元，每个内存单元都会有一个编号，这个编号被称为地址，也叫指针。内存编号 = 地址 = 指针 。指针或地址要存储，就可以存放到指针变量中。
2.指针的大小是固定的4个字节（32位平台 X86）或 8个字节 （64位平台 X64)。
3.指针是有类型的，指针的类型决定了指针± 整数的步长，指针解引用操作的时候的权限。
4.指针的运算。（指针±整数，指针-指针，指针的关系运算）。

1.字符指针

**字符指针：**指向字符的指针，存储的是字符变量的地址。
先看一个比较熟悉的字符指针

int main()
{
	char ch = 'w';// 字符存放到字符变量中
	char* pc = &ch;  //字符变量的地址存放到字符指针中
	*pc = 'a';  // 通过解引用操作符将其修改成 'a'
	printf("%c\n", ch); 
	return 0;
}

接着往下：

char* p = “abcdefghijk”;
p是一个字符指针，指针的大小要么是4个字节要么是8个字节,显然，p不可能存放这一串字符串，空间不够，实际上，p存放的是字符串首元素的地址。即‘a’的地址。字符串的字符与数组类似，在内存中是连续存储的，打印一个字符串只需要知道字符串首元素的地址即可。
当然， "abcdefghijk"是一个常量字符串，存放在内存的常量区，它是只读的，不能修改。

int main()
{
	char* p = "abcdefghijk";
	//*p = 'w'; // 错误，常量字符串不允许修改。
	printf("%c\n", *p);
	printf("%s\n", p);
	return 0;
}

运行结果：

对于内存的常量区只读，我们在来看一道题：

int main()
{
	const char* p1 = "abcdef";
	const char* p2 = "abcdef";

	char arr1[] = "abcdef";
	char arr2[] = "abcdef";

	if (p1 == p2)
	{
		printf("p1 = p2\n");
	}
	else
	{
		printf("p1 != p2\n");
	}
	if (arr1 == arr2)
	{
		printf("arr1 = arr2\n");
	}
	else
	{
		printf("arr1 != arr2\n");
	}
	return 0;
}

大家的答案是啥？正确答案如下：

2.指针数组

指针数组：存放指针的数组

int main()
{
	int a = 10;
	int b = 20;
	int c = 30;
	int* p1 = &a;
	int* p2 = &b;
	int* p3 = &c;

	int* arr[3] = { &a, &b, &c }; //这里的arr就是一个指针数组，数组类型为int* [3]

	for (int i = 0; i < 3; i++)
	{
		printf("%d ", *arr[i]);
	}
	printf("\n");
	return 0;
}

用指针数组弄一个模拟二维数组，这里只是模拟正真的二维数组在内存中是连续存放的，一个元素是一行。
例如： int arr[3] [5] = { { 1, 2, 3, 4, 5 }, { 2, 3, 4, 5, 6 }, { 3, 4, 5, 6, 7 } };

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[3] = { arr1, arr2, arr3 };

	for (int i = 0; i < 3; i++)
	{
		for (int j = 0; j < 5; j++)
		{
			//printf("%d ", parr[i][j]);
			printf("%d ", *(parr[i] + j));
		}
		printf("\n");
	}
	return 0;
}

图示：

3.数组指针

3.1数组指针

数组指针是数组还是指针，答案是指针。
数组指针：一个指向数组的指针。
来，判断一下：

int main()
{
	int* p1[10];
	int(*p2)[10];
	return 0;
}

答案：p1是一个大小为十个元素，每个元素是整型指针的数组，p2是一个指向大小为十个元素，每个元素是整型的指针,指针类型为int (*) [10]。

注意：[ ]的优先级高于 * ，*p2要加括号，不然p2会先跟[ ]结合，就成数组了。

3.2 &数组名 VS 数组名

通常情况下，我们说的数组名是数组首元素的地址
但是有两个情况例外：
1.sizeof(数组名)，这里的数组名表示整个数组，sizeof(数组名）计算的是整个数组的大小。
2.&数组名，这里的数组名表示整个数组，&数组名，取出的是整个数组的地址。

int main()
{
	int arr[10] = { 0 };
	printf("%p\n", arr);
	printf("%p\n", arr+1);

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

	printf("%p\n", &arr);
	printf("%p\n", &arr + 1);
	return 0;
}

运行结果：

3.3数组指针的使用

1.一维数组传参传的是整个数组的地址的时候，处理如下

void print1(int(*p)[10], int sz)
{
	for (int i = 0; i < sz; i++)
	{
		//*p相当于数组名，数组名有是首元素的地址
		printf("%d ", *(*p + i));
	}
	printf("\n");
}

int main()
{
	int arr[] = { 1, 2, 3, 4, 5, 6, 7, 8, 9, 10 };
	int sz = sizeof(arr) / sizeof(arr[0]);
	//写一个函数打印arr数组的内容

	print1(&arr, sz);
	return 0;
}

2.二维数组传参传的是首元素地址的时候，处理如下：

void print(int(*p)[5], int c, int r)
{
	for (int i = 0; i < c; i++)
	{
		for (int j = 0; j < r; 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 } };
	// 写一个函数，打印arr这个数组
	print(arr, 3, 5);
	return 0;
}

对于这行代码的理解：printf("%d ",*(*(p+i)+j));  p指向的是二维数组的首元素，存放的是{ 1, 2, 3, 4, 5 }的地址，即一维数组的地址，p+i 可以得到二维数组每个元素的地址，*（p+i)表示二维数组每一行的首元素地址，*（p+i）+j,表示二维数组的每一行的数据的地址，在解引用即可，*(*（p+i)+j),与p[i][j] 是等价的。

小知识
arr[i] 相当于*（arr + i)
arr[i] [j] 相当于 * ( arr + i ) [ j ] ,* ( * ( arr + i ) + j );

如果对您有所帮助，可以点个赞和关注哦，让我们一起学习和提高😘，加油，加油，加油！！！