指针进阶（一）

前言

指针的主题，我们在初级阶段的《指针》章节已经接触过了，我们知道了指针的概念：

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

1. 字符指针

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

#include
int main()
{
	char ch = 'w';
	char* pc = &ch;
	printf("%c\n", *pc);
	return 0;
}
1
2
3
4
5
6
7
8

😊另一种使用：

#include
int main()
{
	const char* p = "abcdef";
	//给出指针首地址，打印整个字符串
	printf("%s\n", p);
	//指针解引用，打印1个字符
	printf("%c\n", *p);
	return 0;
}
1
2
3
4
5
6
7
8
9
10

😉如何理解上面代码呢？

const char* p = "abcdef";//实质:将“abcdef"首字符放入p中
1

so给出首地址即能打印出整个字符串，%c只能打印出a

面试题

🤓让我们看如下代码：

代码演示：
#include 
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;
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20

🏅输出结果：

🤔为什么str1和str2不相同，str3和str4相同呢？

这里str3和str4指向的是一个同一个常量字符串。C/C++会把常量字符串存储到单独的一个内存区域，当几个指针。指向同一个字符串的时候，他们实际会指向同一块内存。但是用相同的常量字符串去初始化不同的数组的时候就会开辟出不同的内存块。所以str1和str2不同，str3和str4不同
😁看以下图片更清晰理解

🧐若我们比较取地址&str3，&str4:

//代码演示：
#include
int main()
{

	const char* str3 = "hello bit.";
	const char* str4 = "hello bit.";
	if (&str3 == &str4)
	{
		printf("Yes\n");
	}
	else
	{
		printf("No\n");
	}
	return 0;
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17

🏅运行结果：

2. 指针数组

在《指针初阶》章节我们也学了指针数组，指针数组是一个存放指针的数组。
🧐这里我们再复习一下，下面指针数组是什么意思？

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

👀指针数组一般不用于一维数组：

代码演示：
int main()
{
	int a = 1;
	int b = 2;
	int c = 3;
	int d = 4;
	//不会这样使用的
	int* arr[] = { &a, &b, &c, &d };
	return 0;
}
1
2
3
4
5
6
7
8
9
10
11

可以使用指针数组模拟一个二维数组

代码演示：
int main()
{
	int arr1[] = { 1,2,3,4,5 };
	int arr2[] = { 2,3,4,5,6 };
	int arr3[] = { 3,4,5,6,7 };
	        //int*  int*  int*
	//指针数组
	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;
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22

🏅运行结果：

🤠指针数组还可以这样用：

代码演示
#include
int main()
{
	//指针数组
	char* arr[5] = {"hello bit", "hehe", "penggeC", "bitejiuyeke", "C++"};

	int i = 0;
	for (i = 0; i < 5; i++)
	{
		printf("%s\n", arr[i]);
	}

	return 0;
}

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16

🏅运行结果：

3. 数组指针

3.1 数组指针的定义

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

int *p1[10];
int (*p2)[10];
//p1, p2分别是什么？
1
2
3

♥️解释：

int (*p)[10];
//解释：p先和*结合，说明p是一个指针变量，然后指着指向的是一个大小为10个整型的数组。所以p是一个指针，指向一个数组，叫数组指针。
//这里要注意：[]的优先级要高于*号的，所以必须加上（）来保证p先和*结合。
1
2
3

3.2 &数组名VS数组名

数组名理解：
数组名是数组首元素的地址
但是存在2个例外：

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

//代码案例
#include
int main()
{
	int arr[10];
	printf("%p\n", arr);//int*
	printf("%p\n", arr+1);

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

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

	//指针类型决定了指针+1，到底+几个字节

	return 0;
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18

🏅分析案例

本例中 &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
8

😸一个数组指针的使用：

void print(int arr[3][5], int r, int c)
{
	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");
	}
}
int main()
{
	int arr[3][5] = { {1,2,3,4,5},{2,3,4,5,6},{3,4,5,6,7} };
	print(arr, 3, 5);

	return 0;
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20

#include
void print(int (*p)[5], int r, int c)
{
	int i = 0;
	for (i = 0; i < 3; i++)
	{
		int j = 0;
		for (j = 0; j < 5; 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} };
	print(arr, 3, 5);

	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

😽学了指针数组和数组指针我们来一起回顾并看看下面代码的意思：

int arr[5];
int *parr1[10];
int (*parr2)[10];
int (*parr3[10])[5];
1
2
3
4

🥳解析：

4. 数组传参和指针传参

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

4.1 一维数组传参

#include 
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);
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18

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);
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22

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
19

🏅运行结果：

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

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

test(arr);//传整型一维数组的数组名
test(&a);//传整型变量的地址
test(ptr);//传整型指针
1
2
3
4
5
6
7
8
9
10

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
15

🏅运行结果：

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

void test(int** p)
{
}

int n = 10;
int* p = &n;
int** pp = &p;
int* arr[6];

test(&p);
test(pp);
test(arr);
1
2
3
4
5
6
7
8
9
10
11
12

💘不知不觉，指针进阶（一）以告一段落。通读全文的你肯定收获满满，不久的将来会继续更新指针进阶的内容，让我们继续为C语言学习共同奋进!!!