【C语言指针进阶（1）】字符指针，指针数组，数组指针，一级指针和二级指针

提示：下面是章节目录，点击目录跳转到相应模块

---

前言

本章重点：数组指针和指针数组的区别？数组传参和一级/二级指针传参传递的是什么参数？

---

一、基本指针重拾

1.1 指针的概念

1. 指针就是一个变量，用来存放地址，地址唯一标识一块内存空间。
2. 指针的大小4/8个字节（X86系统占4个字节，X64系统占8个字节）
   指针是有类型的，指针的类型决定了指针的±整数的步长，指针解引用操作的所能访问的字节大小。

1.2 字符指针

进阶使用：

#include <stdio.h>

int main()
{
	const char* string = "Hello, world!";
	printf("%s\n", string);

	return 0;
}

我们打开调试窗口可以看到字符指针指向的那片内存的内容。
【调试小技巧】
四、如何查看局部变量的值
我们发现：字符指针string指向的内容是字符串的第一个字母：H。*string == ‘H’, 所以string的值是字符串的地址，*string != "Hello, world!"并不是字符串的整个内容。

我们来看这个例子：

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

输出结果：

分析：
str1 和 str2 是两个字符数组，他们在内存中分别开辟了两个空间，两块空间的地址不同。
str3 和 str4 是两个指针，他们都指向了一个不可变的常量字符串“Hello, bit.”, 所以地址相同。

二、指针数组和数组指针

2.1 指针数组

保存字符的数组叫字符数组
保存整型的数组叫整型数组
保存浮点型的数组叫浮点型数组
那么保存指针的数组叫什么呢？

• 指针数组
• 顾名思义：指针数组就是用来存放指针的数组，数组中的每一个元素都是一个指针。
• 本质是一个数组，只不过数组里面存放的是指针。

char arr1[10];//字符数组，数组的每个元素都是 char 类型
int arr2[10];//整型数组，数组的每个元素都是 int 类型
double arr3[10];//浮点型数组，数组的每个元素都是 double 类型
int* arr2[10]; //指针数组，数组的每个元素都是 int *类型， 都是指针。

2.2 数组指针

指向字符的指针叫字符指针
指向整型的指针叫整型指针
指向浮点型的指针叫浮点型指针
那么指向数组的指针叫什么呢？

• 数组指针
• 顾名思义：数组指针就是指向数组的指针，本质是一个指针。

char* p1 = NULL;//字符指针
int* p2 = NULL;//整型指针
float* p3 = NULL;//浮点型指针
int (*p4)[10] = NULL;//数组指针

• 数组指针的类型是 int (*)[N];
• ( * )代表p4这个变量是一个指针，带括号是因为[] 的优先级比的优先级高，如果不加（），则int p4[10] ; p4先和[10]结合, 表示了一个数组, 这个数组存放元素的类型是int * 。所以要加括号，使先和p4结合，p4使一个指针，再和[10]结合，是一个指向数组的指针，指针的类型是int () [N]。N,代表这个指针指向数组的元素个数。

2.3 指针数组与数组指针的区别？

指针数组：本质是一个数组，数组里存放的是指针变量。
数组指针：本质是一个指针，这个指针指向的是一个数组。

解释:

#include <stdio.h>

int main()
{
	int* p1[10]; //指针数组，p1是数组名， 数组有10个元素，
	//每个元素都是int* 类型的指针

	int(*p2)[10];//数组指针，p2是指针变量，p2指向有10个int类型元素的数组
	//p2的类型是：int (*)[10];
	//p2先与*结合，说明p2是一个指针，然后指向一个数组，这个数组含有10个元素，
	//每个元素都是int 类型，所以p2叫数组指针。

	return 0;
}

应用：
数组指针一般应用在二维数组的传参中，二维数组的数组名是数组首元素的地址，首元素是一个一维数组，形参用数组指针接收。

#include <stdio.h>

void print(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("\n");
	}
}

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

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

	print(arr, 3, 5);
	//arr代表数组首元素的地址, 二维数组的首元素是第一行数据，也就是一个一维数组
	//传递的是一个一维数组的地址，首元素是int类型的一维数组，他的地址是：int(*)[5]类型
	//所以形参用int(*)[5] 类型的数组指针接收。
	return 0;
}

易混淆

int arr[5];	
	//arr是数组，数组中有5个元素，每个元素都是int类型
	int* parr1[10];
	//parr1是指针数组， 数组中有10个元素，每个元素都是int*类型
	int(*parr2)[10];
	//parr2是数组指针，指针指向一个数组，这个数组有10个元素， 每个元素是int类型。
	//(指针指向一个含有10个元素的整型数组。)
	int(*parr3[10])[5];
	//parr3是一个包含5个数组指针的指针数组
	//分解来看：
	//parr3是一个变量名，[]优先级比*高，所以parr3是一个数组, 这个数组的元素有10个
	//每个元素都是一个指向含有5个整型元素的数组的指针，叫数组指针，
	//他的类型是：int (*)[5]。去除变量名parr3[10]，剩下的就是变量的类型。

三、数组传参和指针传参

3.1 数组传参

一维数组的传参：

#include <stdio.h>
void test(int arr[])//ok?---ok
{}
void test(int arr[10])//ok?---ok
{}
void test(int* arr)//ok?---ok
{}

void test2(int* arr[20])//ok?---ok
{}
void test2(int** arr)//ok?---ok
{}

int main()
{
	int arr[10] = { 0 };
	int* arr2[20] = { 0 };
	test(arr);
	//arr是一个数组，传过去的是一个数组，形参用数组相同类型的数组接收，没问题
	//arr也是一维数组的首元素的地址，首元素是int类型，int类型变量的地址为int*, 形参使用int*类型的指针接收，没问题
	test2(arr2);
	//arr2是一个指针数组，（数组的每个元素都是一个指针）传过去的是一个数组，形参用数组相同类型的数组接收，没问题
	//arr2也是一个一维数组首元素的地址，首元素是int* 类型，int* 类型变量的地址是int**, 形参使用int**类型的指针接收，没问题
}

二维数组的传参：

void test(int arr[3][5])//ok？---ok
{}
void test(int arr[][])//ok？---no
{}
void test(int arr[][5])//ok？---ok
{}
//总结：二维数组传参，函数形参的设计只能省略第一个[]的数字。
//因为对一个二维数组，可以不知道有多少行，但是必须知道一行多少元素。
//这样才方便运算。
void test(int* arr)//ok？--- No -- int 类型的指针只能指向int类型的数据
{}
void test(int* arr[5])//ok？-- No -- arr是一个数组，这个数组的每个元素都是int*类型的指针
{}
void test(int(*arr)[5])//ok？--- ok --- arr是一个指针，指针的类型是int (*)[5]
{}
void test(int** arr)//ok？--- No --- arr是一个二级指针，指向一个一级指针，保存的是一级指针的地址。
{}

int main()
{
	int arr[3][5] = { 0 };
	test(arr);
	//首先我们要明白二维数组的首元素是二维数组的第一行数据，第一行的一整个数组是二维数组的首元素。
	//arr是一个二维数组，形参用二维数组接收，没问题
	//arr是二维数组的首元素的地址，首元素是一个一维数组，所以传递的是数组的地址，数组的地址是：int (*)[5]类型，
	//所以形参使用int(*)[5]类型的指针接收，没问题

}

3.2 指针传参

给你一个以一级指针为形参的函数，你知道他的调用处可以传递什么参数吗？

#include <stdio.h>

//print 有两个参数，第二个参数好理解，只需传递一个整型数据
//那第一个参数可以传哪些数据呢？
//int* p , p是一个指针变量, 所以可以接收一个变量的地址，可以接收一个同类型的指针变量， 
//可以接收一个一维整型数组，因为数组名是数组首元素的地址，数组首元素是int类型的变量，他的地址是int*类型
void print(int* p, int sz)
{
	int i = 0;
	for (i = 0; i < sz; i++)
	{
		printf("%d ", *(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]);
	//一级指针p，传给函数
	print(p, sz);
	printf("\n");
	//arr是数组首元素的地址
	print(arr, sz);

	return 0;
}

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

#include <stdio.h>

void test(int* p)
{	
	printf("%d\n", *p);
}
//test函数能接收什么参数？
//1. test(&n);//变量的地址
//2. test(p);//以及指针变量
//3. test(arr);//一维数组的数组名

int main()
{
	int n = 10;
	test(&n);

	int* p = &n;
	test(p);

	int arr[] = {1,2,3,4};
	test(arr);

	return 0;
}

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

#include <stdio.h>

void test(int** ptr)
{
	printf("num = %d\n", **ptr);
}
//test有一个二级指针参数ptr
//int* p = &n; 
//1. test(pp); //传递二级指针
//2. test(&p); //传递一级指针的地址
//3. test(arr);//传递指针数组， 数组名表示数组首元素的地址，首元素是int*类型，形参使用二级指针接收

int main()
{
	int n = 10;
	int* p = &n;
	test(&p);//一级指针的地址

	int** pp = &p;
	test(pp);//二级指针

	int n2 = 20;
	int* arr[] = {&n, &n2};
	test(arr);//指针数组

	return 0;
}

五、总结

理解指针数组和数组指针的区别，以及数组传参和指针传参都可以传递什么参数？