【C语言进阶学习】二、指针的进阶（1）

我们在之前学习指针初阶的时候，可以了解指针的一些基础概念：
1、指针就是一个变量，用来存放地址的，地址唯一标识一块内存空间。
2、指针的大小是固定的4/8个字节（32位平台/64位平台）。
3、指针是有类型，指针的类型决定了指针的±整数的步长，指针解引用操作的时候的权限
4、指针的运算。

记忆不大清楚的可以点击此处去复习一下：初阶指针
接下来我们将进一步深度学习指针：

---

一、字符指针

在指针的类型中我们知道有一种指针类型为字符指针char*;
我们在使用字符指针的时候，一般有以下两种使用场景：
一般使用：

还有一种使用方式如下：

这种方式是将字符串的第一个字符的地址放到指针中，通过指针可以找到该字符串。
这种使用方式有一个注意点：由于这个字符串是一个常量字符串，是无法通过解引用对字符串进行修改。
如图：

如果说我们想要修改这个字符串，可以将其放入数组中，然后再去修改：

为了加深理解，我们来做一道题：
想一想下方输出结果是什么？

#include <stdio.h>
int main()
{
	char str1[] = "hello bit.";
	char str2[] = "hello bit.";
	char *str3 = "hello bit.";
	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;
}

运行结果：

代码分析：
因为str1和str2分别是两个独立的数组，他们是需要独立开辟内存空间的，两者没有任何关联，所以在内存空间所在位置是不同的。而这里的数组名代表数组首元素的地址，所以 str1 != str2 .

我们都知道str3和str4都是char类型的指针，而它们都指向一个常量字符串 “hello bit.”。既然是常量字符串，所以不能被修改，在内存空间所占位置固定，char* str3 = “hello bit.”; 是将该常量字符串的首地址放到字符指针str3中，char* str4 = “hello bit.”;是将该常量字符串的首地址放到字符指针str4中。也就是说str3和str4存放都是常量字符串"hello bit."的首地址，所以 str3 == str4。（注意：同样的常量字符串只会存一份，不会同时存两份，所以不会开辟不同的空间来存储。）

我们画个图来便于理解：

注: char* str3= “hello bit.”; 这种写法本身也不严谨，在有些编译器中会报错或者警告，严谨的写法应该是:
const char* str3= “hello bit.”; （指向常量字符串的指针最好加上const!）

二、指针数组

指针数组我们在指针初阶中讲解到过 ，这里我们再来进行复习一下。指针数组的使用。

整型数组 - - - 存放整型的数组

int arr4[10];

字符数组 - - - 存放字符的数组

char arr[5];

指针数组 - - - 存放指针的数组

int* arr1[5];//arr1是存放整形指针的数组
char* arr2[5];//arr2是存放字符指针的数组

了解这些之后，请看下面例子，来熟悉指针数组的使用

举例1：

#include <stdio.h>
int main()
{
	int a = 10;
	int b = 20;
	int c = 30;
	int d = 40;
	              //int* int* int* int*
	int* arr2[4] = {&a, &b, &c, &d};//arr2就是整型指针的数组
	int i = 0;
	for (i = 0; i < 4; i++)
	{
		printf("%d ", *(arr2[i]));
	}
	return 0;
}

运行结果：

举例2：
我们知道数组名可以代表数组首元素的地址，那数组名作为指针数组的元素后，该如何访问数组内的元素呢？请看下面这段代码：

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

	int i = 0;
	for (i = 0; i < 3; i++)//获取parr数组的元素
	{
		int j = 0;
		for (j = 0; j < 5; j++)//遍历arr内的元素
		{
			printf("%d ", parr[i][j]);//p[i] == *(p+i)
			//parr[i][j] == *(parr[i]+j)
		}
		printf("\n");
	}
	return 0;
}

运行结果：

举例3：

#include <stdio.h>
int main()
{
	const char* arr[5] = {"abcdef", "bcdefg", "hehe", "haha", "zhangsan"};
	//字符指针数组，每个元素都是char*类型，都指向一个常量字符串，所以前面加了const
	int i = 0;
	for (i = 0; i < 5; i++)
	{
		printf("%s\n", arr[i]);
		//字符指针数组中，每个元素本质上存放的都是每个常量字符串的首字符的地址
		//所以arr[i]无需解引用操作符（*）
	}
	return 0;
}

运行结果：

---

三、数组指针

1.数组指针的定义
数组指针是指针？还是数组？
答案是∶指针

我们已经熟悉：
整型指针 - - - 指向整型的指针

int a = 10;
int* pa = &a;

字符指针 - - - 指向字符的指针

char ch = 'w';
char* pc = &ch;

所以我们可以推理出
数组指针 - - - 指向数组的指针

#include<stdio.h>
int main()
{
	int arr[10] = { 1,2,3,4,5,6,7,8,9,10 };
	//int* p = arr;// 数组名是首元素地址
	//数组指针 存放数组的指针变量
	int(*p)[10] = &arr;//(*p)代表p是指针变量
	//该指针指向了一个数组，数组10个元素，每个元素的类型是int
	//如果不用括号将*p括起来，写成int* p[10]，这是指针数组
	return 0;
}

为了更好理解数组指针，再看下面几个例子：

//1:
char arr1[5] = {0};
char(*pa)[5] = &arr1;
//2:
int arr2[10] = {0};
int(*p)[10] = &arr2;
//解释: p先和*结合，说明p是一个指针变量，然后指着指向的是一个大小为10个整型的数组。所以p是一个指针，指向一个数组，叫数组指针。
//这里要注意:[]的优先级要高于*号的，所以必须加上()来保证p先和*结合。
//3:
char* ch[8];//字符指针数组 -- 存放字符地址的数组
char* (*pc)[8] = &ch;

2、&数组名 与 数组名
关于数组名，我们再以往博客中涉及到过，也已经讲解过了，这里我们再详细讲解一下：

我们经常说数组名是首元素地址，但有两个例外：

1. sizeof(数组名)， 这里的数组名是表示整个数组的，sizeof(数组名)计算的是整个数组的大小，单位是字节
2. &数组名， 这里的数组名不是首元素的地址，而是表示整个数组，所以取出的是整个数组的地址

请看下面代码，来了解这两者的区别吧：

#include <stdio.h>
int main()
{
	int arr[10] = {0};
	//arr;//数组名是首元素的地址
	//&arr[0];//是首元素的地址
	//&arr;//取出整个数组的地址

	printf("arr = %p\n", arr);
	printf("arr+1 = %p\n", arr + 1);

	printf("\n");

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

	printf("\n");

	printf("&arr = %p\n", &arr);
	printf("&arr+1 = %p\n", &arr + 1);

	return 0;
}

运行结果：

我们从运行结果可以发现，红色方框内的地址都是一样的，所以可以证明数组名是首元素地址，但为什么 &arr 的地址也是相同的呢？是不是数组名arr和 &arr 也是一样的？

其实不是的，虽然它们的地址相同，但它们所代表的意义却不相同，当我们给它们分别加上1就可以发现，它们发生了很大的改变。

从图中可以看出，arr+1 与 &arr[0]+1 只在原有的基础上增加了4个字节，意思就是跳过了一个整型。而 &arr+1 却增加了28个字节，这里的28是16进制的，转化成十进制就是40个字节，也就是说它跳过了整个数组。

我们进行画图来助于理解：

这里我们用指针表示，如下：

int* p1 = arr; 
//这里数组名表示数组首元素的地址，所指向的内容是int类型，所以放到整型指针中
//p1+1 表示跳过一个int类型的长度，也就是4个字节

int* p2 = &arr[0] ;
//数组首元素的地址，所指向的内容是int类型，所以放到整型指针中
//p2+1表示跳过一个char类型的长度，也就是1个字节

int(*p3)[10] = &arr;
//取出整个数组的地址，所以放到数组指针中
//p3+1表示跳过一个具有10个整型长度的数组，也就是4*10=40个字节

数组指针的使用
请看下面例子：

#include <stdio.h>
void print1(int arr[], int sz)//以数组形式
{
	int i = 0;
	for (i = 0; i < sz; i++)
	{
		printf("%d ", arr[i]);
	}
}
void print2(int* arr, int sz)//以指针形式
{
	int i = 0;
	for (i = 0; i < sz; i++)
	{
		printf("%d ", *(arr + i));
	}
}
int main()
{
	int arr[10] = {1,2,3,4,5,6,7,8,9,10};
	int sz = sizeof(arr) / sizeof(arr[0]);

	//打印arr数组的内容
	print1(arr, sz);
	print2(arr, sz);
	return 0;
}

这两种打印数组内容的形式，是我们经常使用的两种形式，其实这两种方式是等价的，第一种更好让初学者理解。
这两种都是以数组名作为参数，那如果我将整个数组传过去呢？那将如何打印数组内容？

#include <stdio.h>
void print4(int (*parr)[10], int sz)//传过来的是整个数组的地址
{
	//*(parr + 0);//parr[0]
	int i = 0;
	for (i = 0; i < sz; i++)
	{
		//printf("%d ", parr[0][i]);
		//printf("%d ", (*(parr + 0))[i]);
		printf("%d ", (*parr)[i]);//(*parr) 相当于 parr指向的数组的数组名
		
		//千万不能写成这种形式：parr[i]
		//因为 parr[i] == *(parr+i)，这就相当于跳过整个数组，当i自增后，就会造成非法访问内存，所打印的值并非是我们想要的
	}
}
int main()
{
	int arr[10] = {1,2,3,4,5,6,7,8,9,10};
	int sz = sizeof(arr) / sizeof(arr[0]);

	//打印arr数组的内容
	print4(&arr, sz);
	return 0;
}

通过数组指针解引用找到数组，再用方括号[ ]，去找到数组中的每个元素。这种并非数组指针的常用方式，因为用起来很“别扭”。

数组指针的使用，一般常见于二维数组及其以上
请看下面例子：
我们通常编写一个函数来打印二维数组的内容，一般会像下面这样写：

#include <stdio.h>
void print1(int arr[3][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 ", arr[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 };
	//二维数组传参
	print1(arr, 3, 5);
	return 0;
}

这是我们以前的写法，其实还有一种写法，如下：
我们知道，二维数组传参，传数组名时，数组名代表首元素地址，那么二维数组的首元素地址指的是什么呢？

其实二维数组的首元素地址是二维数组第一行的地址，而二维数组的每一行又可以看作一个一维数组，所以二维数组数组名传参时，我们可以认为传过来的是一个一维数组的地址，既然是数组的地址，那我们就需要用数组指针来接收。

代码如下：

//数组指针
void print2( 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("%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 };
	//二维数组传参
	//print1(arr, 3, 5);
	print2(arr, 3, 5);
	//arr 是数组名，数组名是首元素地址
	//但是二维数组的首元素是二维数组的第一行
    //所以这里传递的arr，其实相当于第一行的地址，是一维数组的地址
    //可以数组指针来接收
	return 0;
}

注意：对一个存放数组地址的指针进行解引用操作，找到的是这个数组，也就是这个数组的数组名，数组名这时候又表示数组首元素地址！

*(p + i)：相当于拿到了一行
相当于这一行的数组名
(*p + i)[j] <===> * ( *(p + i) + j))

---

当我们学完了指针数组和数组指针后我们来一起看看下面代码的意思：

int arr[5];
//arr是一个整型数组，数组有5个元素，每个元素类型是int
//arr数组的类型是  int [5]  --- 去掉变量名，剩下的就是变量的类型

int *parr1[10];
//parr1是一个存放指针的数组（指针数组）
//数组有10个元素，每个元素的类型是int*
//parr1数组的类型是 int* [10]

int(*parr2)[10];
//parr2是一个指向数组的指针（数组指针）
//该指针指向的数组有10个元素，每个元素类型是int
//parr2指针的类型是 int(*)[10]

int(*parr3[10])[5];
//parr3是一个数组，数组有10个元素
//每个元素是一个数组指针，该指针指向一个数组，数组有5个元素，每个元素类型是int
//所以parr3是一个存放数组指针的数组

我们画个图来进行理解int(*parr3[10])[5]

四、数组传参和指针传参

4.1 一维数组传参

#include <stdio.h>
void test(int arr[])//ok? 
{}
void test(int arr[10]) //ok?
{}
void test(int* arr)//ok?
{}
void test2(int* arr[20])//ok?
{}
void test2(int** arr) // ok ? 
{}
int main()
{
	int arr[10] = { 0 };
	int* arr2[20] = { 0 };
	test(arr);
	test2(arr2);
}

答案：以上五种传参方式均ok
注意：一维数组传参可以传数组形式，也可以传指针形式，传数组形式的时候数组元素的个数可以不写，也可以写，传指针的时候要注意指针的类型，也就是指针指向什么类型的元素，比如说指针指向int类型元素，那么指针的类型就是
int* 。

4.2 二维数组传参

void test(int arr[3][5])//ok ?
{}
//可以
void test(int arr[][])//ok ?
{}
//不可以，行可以省略，列不可以，第一个[ ]内容可以不写，第二个[ ]要写
void test(int arr[][5])//ok ?
{}
//可以
void test(int* arr)// ok ? 
{}
//不可以
void test(int* arr[5])//ok ?
{}
//不可以
void test(int(*arr)[5])//ok ?
{}
//可以
void test(int** arr)// ok ? 
{}
//不可以
int main()
{
	int arr[3][5] = { 0 };
	test(arr);
}

总结:二维数组传参，函数形参的设计只能省略第一个[ ]的数字。
因为对一个二维数组，可以不知道有多少行，但是必须知道一行多少元素。
这样才方便运算。
二维数组传参也能写成指针的形式，指针的类型应该是数组指针。

4.3 一级指针传参

这里的指针传参可以用数组去接收吗？

经过实验我们可以看到这样做是没问题的，指针传参可以用数组去接收！

当一个函数的参数部分为一级指针的时候，函数能接收什么参数 ?
例如：int * p

void test1(int* p)
{
}
int main()
{
	int a = 10;
	int* pa = &a;
	int arr[10] = { 0 };
	test1(&a);
	test1(pa);
	test1(arr);
	return 0;
}

再例如：char* p

void test2(char* p)
{
}
int main()
{
	char a = 'W';
	char* pa = &a;
	char arr[10] = { 0 };
	test2(&a);
	test2(pa);
	test2(arr);
	return 0;
}

注意：
int* p1;
int* p2;
*靠近int 或者靠近变量p实际的意义和效果没区别，是一样的。 一般我们习惯用int p2这种写法，这样可以明确表示指针变量p2的类型。

4.4 二级指针传参

void test(int** p)
{
}
int main()
{
	int* p1;
	int** ptr;
	int* arr[5];
	test(&p1);//一级指针取地址
	test(ptr);//二级指针
	test2(arr);//一级指针数组的首元素
	return 0;
}