• 指针进阶（1）

    指针的主题，我们在初级阶段的《指针》章节已经接触过了，我们知道了指针的概念：
    1. 指针就是个变量，用来存放地址，地址唯一标识一块内存空间。
    2. 指针的大小是固定的4/8个字节（32位平台/64位平台）。
    3. 指针是有类型，指针的类型决定了指针的+-整数的步长，指针解引用操作的时候的权限。
    4. 指针的运算。
    这个章节，我们继续探讨指针的高级主题。

     1. 字符指针

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

    1. #define _CRT_SECURE_NO_WARNINGS 1
    2. int main()
    3. {
    4. 	char ch = 'w';
    5. 	char* pc = &ch;
    6. 	*pc = 'w';
    7. 	return 0;
    8. }

    还有一种使用方式如下：

    这种方法其实是把首字符a的地址赋给了pstr，跟数组其实是差不多的。

    1. #define _CRT_SECURE_NO_WARNINGS 1
    2. int main()
    3. {
    4. 	const char* pstr = "abcdef";//这里是把一个字符串放到pstr指针变量里了吗？
    5. 	printf("%s\n", pstr);
    6. 	return 0;
    7. }

     下面这种写法是有一点风险的，abcdef是常量字符串，是不能被修改的，当我们去修改他的时候，就会发生错误，所以我们最好在char前加const修饰一下。如果用%c来打印的话，只能获得a，一个字符。

    1. #define _CRT_SECURE_NO_WARNINGS 1
    2. #include
    3. int main()
    4. {
    5. 	char* pstr = "abcdef";//这里是把一个字符串放到pstr指针变量里了吗？
    6. 	*pstr = 'abc';
    7. 	printf("%s\n", pstr);
    8. 	return 0;
    9. }

     面试题：

    1. #define _CRT_SECURE_NO_WARNINGS 1
    2. #include
    3. int main()
    4. {
    5. 	char str1[] = "abcdef";
    6. 	char str2[] = "abcdef";
    7. 	const char* str3 = abcdef";
    8. 	const char* str4 = "abcdef";
    9. 	if (str1 == str2)
    10. 		printf("str1 and str2 are same\n");
    11. 	else
    12. 		printf("str1 and str2 are not same\n");
    13. 	if (str3 == str4)
    14. 		printf("str3 and str4 are same\n");
    15. 	else
    16. 		printf("str3 and str4 are not same\n");
    17. 	return 0;
    18. }

     这里我们需要注意的是==比的是地址是否相同，这里str3和str4指向的是一个同一个常量字符串。C/C++会把常量字符串存储到单独的一个内存区域，当几个指针。指向同一个字符串的时候，他们实际会指向同一块内存。但是用相同的常量字符串去初始化不同的数组的时候就会开辟出不同的内存块。所以str1和str2不同，str3和str4不同。
    那如果我们&来比较str3和str4呢？两个变量是两块空间，所以是no。

    1. #define _CRT_SECURE_NO_WARNINGS 1
    2. #include
    3. int main()
    4. {
    5. 	char str1[] = "hello bit.";
    6. 	char str2[] = "hello bit.";
    7. 	const char* str3 = "hello bit.";
    8. 	const char* str4 = "hello bit.";
    9. 	if (str1 == str2)
    10. 		printf("str1 and str2 are same\n");
    11. 	else
    12. 		printf("str1 and str2 are not same\n");
    13. 	if (str3 == str4)
    14. 		printf("str3 and str4 are same\n");
    15. 	else
    16. 		printf("str3 and str4 are not same\n");
    17. 	if (&str3 == str4)
    18. 	{
    19. 		printf("yes\n");
    20. 	}
    21. 	else
    22. 	{
    23. 		printf("no\n");
    24. 	}
    25. 	return 0;
    26. }

     2.指针数组

    在《指针》章节我们也学了指针数组，指针数组是一个存放指针的数组。
    下面指针数组是什么意思？

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

    那么指针数组是怎么用的呢，指针数组可以用来模拟一个二维数组，下面有三个一维数组，我们将三个数组的数组名放进一个指针数组中，也就是首元素的地址，，每个数组名都指向它们的首元素，我们可以通过下标0访问arr1，下标1访问爱人人，下标3访问arr2，再用j访问每个它们的每个元素，

    1. #define _CRT_SECURE_NO_WARNINGS 1
    2. #include
    3. int main()
    4. {
    5. 	int arr1[] = { 1,2,3,4,5 };
    6. 	int arr2[] = { 2,3,4,5,6 };
    7. 	int arr3[] = { 3,4,5,6,7 };
    8. 	        //int*  int*  int*
    9. 	//指针数组
    10. 	int* arr[] = { arr1, arr2, arr3 };
    11. 	int i = 0;
    12. 	for (i = 0; i < 3; i++)
    13. 	{
    14. 		int j = 0;
    15. 		for (j = 0; j < 5; j++)
    16. 		{
    17. 			printf("%d ", arr[i][j]);
    18. 		}
    19. 		printf("\n");
    20. 	}
    21.  
    22. 	return 0;
    23. }

     指针数组还可以这样用：

    每个常量字符串都有首字符的地址，所以有五个首字符的地址，首字符的地址就是char*。然后我们就可以进行打印了。

    1. #define _CRT_SECURE_NO_WARNINGS 1
    2. #include
    3. int main()
    4. {
    5. 	//指针数组
    6. 	char* arr[5] = {"abcd", "hehe", "insjcd", "java", "C++"};
    7.  
    8. 	int i = 0;
    9. 	for (i = 0; i < 5; i++)
    10. 	{
    11. 		printf("%s\n", arr[i]);
    12. 	}
    13.  
    14. 	return 0;
    15. }

    3.数组指针

    3.1 数组指针的定义

    数组指针是指针？还是数组？
    答案是：指针。
    我们已经熟悉：
    整形指针： int * pint; 能够指向整形数据的指针。
    浮点型指针： float * pf; 能够指向浮点型数据的指针。
    那数组指针应该是：能够指向数组的指针。
    下面代码哪个是数组指针？

    第一个是指针数组，里面存放的是10个元素，每个元素的类型是int*。

    第二个是数组指针，p2指向的是数组，里面存放的是10个元素，每个元素的类型是int。

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

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

    3.2 &数组名VS数组名

     下面我们来理解一下数组名：

    1. #define _CRT_SECURE_NO_WARNINGS 1
    2. #include
    3. //数组名的理解
    4. //数组名是数组首元素的地址
    5. //但是存在2个例外：
    6. //1. sizeof(数组名)，这里的数组名表示整个数组，sizeof(数组名)计算的是整个数组的大小，单位是字节
    7. //2. &数组名，这里的数组名表示整个数组，取出的是数组的地址
    8. int main()
    9. {
    10. 	int arr[10];
    11. 	printf("%p\n", arr);//int*
    12. 	printf("%p\n", arr+1);
    13.  
    14. 	printf("%p\n", &arr[0]);//int*
    15. 	printf("%p\n", &arr[0] + 1);
    16.  
    17. 	printf("%p\n", &arr);//
    18. 	printf("%p\n", &arr+1);
    19.  
    20. 	//指针类型决定了指针+1，到底+几个字节
    21.  
    22. 	return 0;
    23. }

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

    3.3 数组指针的使用

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

    1. #define _CRT_SECURE_NO_WARNINGS 1
    2. #include
    3. int main()
    4. {
    5. 	int arr[10] = { 1,2,3,4,5,6,7,8,9,0 };
    6. 	int(*p)[10] = &arr;//把数组arr的地址赋值给数组指针变量p
    7. 	//但是我们一般很少这样写代码
    8. 	return 0;
    9. }

    一个数组指针的使用：

    函数print_arr1和函数printarr2其实是一样的效果，差别就是print_arr1的形参是指针，print_arr2的形参是二维数组的形式。

    1. #define _CRT_SECURE_NO_WARNINGS 1
    2. #include
    3. void print_arr1(int arr[3][5], int row, int col)
    4. {
    5. 	int i = 0;
    6.     int j = 0;
    7. 	for (i = 0; i < row; i++)
    8. 	{
    9. 		for (j = 0; j < col; j++)
    10. 		{
    11. 			printf("%d ", arr[i][j]);
    12. 		}
    13. 		printf("\n");
    14. 	}
    15. }
    16. void print_arr2(int(*arr)[5], int row, int col)
    17. {
    18. 	int i = 0;
    19.     int j = 0;
    20. 	for (i = 0; i < row; i++)
    21. 	{
    22. 		for (j = 0; j < col; j++)
    23. 		{
    24. 			printf("%d ", arr[i][j]);
    25. 		}
    26. 		printf("\n");
    27. 	}
    28. }
    29. int main()
    30. {
    31. 	int arr[3][5] = { 1,2,3,4,5,6,7,8,9,10 };
    32. 	print_arr1(arr, 3, 5);
    33. 	//数组名arr，表示首元素的地址
    34. 	//但是二维数组的首元素是二维数组的第一行
    35. 	//所以这里传递的arr，其实相当于第一行的地址，是一维数组的地址
    36. 	//可以数组指针来接收
    37. 	print_arr2(arr, 3, 5);
    38. 	return 0;
    39. }

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

    arr是一个数组，里面有5个元素，每个元素的类型是int。

    parr1是一个数组，里面有10个元素，每个元素的类型是int*。

    parr2是一个指针，指向的是数组，指向的数组有10个元素，每个元素的类型是int。

    parr3是一个数组，是存放数组指针的数组，数组有10个元素，存放的数组指针指向的数组有5个元素，每个元素的类型是int。

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

    4. 数组参数、指针参数

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

    4.1 一维数组传参

    第一种是ok的，因为数组传参本质上是传首元素的地址过去，所以大小可以省略。

    第二种相较于第一种就是把数组的大小也指定了，可以不写，也可以写错，反正也不用。

    第三种也是没有毛病的，数组传参写成指针的形式，类型是int*。

    第四种arr2是指针数组，里面有20个元素，每个元素的类型是int*。形参也是用指针数组来接收，是一模一样的。

    第五种也是可以的，因为arr2的每个元素的类型都是int*，所以第一个元素就是int*类型的，数组名表示首元素的地址，一个指针变量类型的地址放到二级指针里面去，所以是没有问题的。

    1. #define _CRT_SECURE_NO_WARNINGS 1
    2. #include
    3. void test(int arr[])//ok?
    4. {}
    5. void test(int arr[10])//ok?
    6. {}
    7. void test(int* arr)//ok?
    8. {}
    9. void test2(int* arr[20])//ok?
    10. {}
    11. void test2(int** arr)//ok?
    12. {}
    13. int main()
    14. {
    15. 	int arr[10] = { 0 };
    16. 	int* arr2[20] = { 0 };
    17. 	test(arr);
    18. 	test2(arr2);
    19. }

    4.2 二维数组传参

    第一种是没有任何问题的，是标准的二维数组传参方式。

    第二种是不行的，因为行可以省略，列不可以省略。

    第三种省略行是可以的。

    第四种是不行的，因为数组名表示首元素的地址，是二维数组第一行的地址，而int*arr是整形指针，用来接收整型变量的地址。

    第五种肯定是错误的，用指针数组来作为形参是不行的，里面存放的是5个元素，每个元素的类型是int*。

    第六种是可以的，使用数组指针来作为形参，这个指针指向的数组是5个元素，每个元素的类型是int，所以这个数组指针有能力指向这个数组的每一行。

    第七种是不行的，因为二级指针是用来存放一级指针的地址的，所以传过去一个一级指针才能用二级指针来接收。

    1. void test(int arr[3][5])//ok？
    2. {}
    3. void test(int arr[][])//ok？
    4. {}
    5. void test(int arr[][5])//ok？
    6. {}
    7. void test(int *arr)//ok？
    8. {}
    9. void test(int* arr[5])//ok？
    10. {}
    11. void test(int (*arr)[5])//ok？
    12. {}
    13. void test(int **arr)//ok？
    14. {}
    15. int main()
    16. {
    17.      int arr[3][5] = {0};
    18.      test(arr);
    19. }

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

    4.3 一级指针传参

    其实指针传参也挺简单的，比数组更简单，因为更纯粹，就是指针。

    这里把arr这个数组名也就是首元素地址赋给p，p就是一个一级指针，所以直接用一个一级指针接收就行，使用*（p+i）来访问每一个元素。

    1. #define _CRT_SECURE_NO_WARNINGS 1
    2. #include
    3. void print(int* p, int sz)
    4. {
    5. 	int i = 0;
    6. 	for (i = 0; i < sz; i++)
    7. 	{
    8. 		printf("%d\n", *(p + i));
    9. 	}
    10. }
    11. int main()
    12. {
    13. 	int arr[10] = { 1,2,3,4,5,6,7,8,9 };
    14. 	int* p = arr;
    15. 	int sz = sizeof(arr) / sizeof(arr[0]);
    16. 	//一级指针p，传给函数
    17. 	print(p, sz);
    18. 	return 0;
    19. }

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

    比如：

    1. void test1(int *p)
    2. {}
    3. //test1函数能接收什么参数？
    4. void test2(char* p)
    5. {}
    6. //test2函数能接收什么参数？

    test1的参数是一个一级指针，类型是int，所以可以用来存放整型变量。

    如果我们先把a的地址放到一个一级指针里面去，再传一级指针也没问题。

    我们还可以将整型数组的数组名传给test,也就是数组首元素的地址，只要类型是int就行。

    1. int a=10;
    2. test(&a);
    3.  
    4. int *ptr=&a;
    5. test(ptr);
    6.  
    7. int arr[5];
    8. test(arr);

    4.4 二级指针传参

    这里我们将整型n的地址赋给一级指针p，再将p赋给二级指针pp，将pp传参，所以test用二级指针接收。

    1. #define _CRT_SECURE_NO_WARNINGS 1
    2. #include
    3. void test(int** ptr)
    4. {
    5. 	printf("num = %d\n", **ptr);
    6. }
    7. int main()
    8. {
    9. 	int n = 10;
    10. 	int* p = &n;
    11. 	int** pp = &p;
    12. 	test(pp);
    13. 	test(&p);
    14. 	return 0;
    15. }

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

    1. int n = 10;
    2. int* p = &n;
    3. test(&p);
    4.  
    5. int** pp = &p;
    6. test(pp);

     数组名是首元素地址，就是一个int*的地址，是没问题的。

    1. int *arr[6];
    2. test(arr);

    5. 函数指针

    函数指针就是指向函数的指针，存放的是函数的地址。

    首先看一段代码：

    我们&函数名就能拿到函数的地址，直接用函数名也能实现一样的效果。

    1. #define _CRT_SECURE_NO_WARNINGS 1
    2. #include
    3. void test()
    4. {
    5. 	printf("hehe\n");
    6. }
    7. int main()
    8. {
    9. 	printf("%p\n", test);
    10. 	printf("%p\n", &test);
    11. 	return 0;
    12. }

     如果我们想把Add的地址存起来，就要用函数指针来接收，后面（）里面存放的是参数的类型。

    1. int Add(int x, int y)
    2. {
    3. 	return x + y;
    4. }
    int (*pf1)(int，int) = Add；

    如果我们要调用pf1的话，代码如下：

    *可以不写。

    今天的分享到这里就结束啦！谢谢老铁们的阅读，让我们下期再见。

  • 相关阅读:
    mybatis-plus集成pagehelper进行分页排序和返回查询总数
    BUUCTF NewStarCTF 公开赛赛道Week4 Writeup
    【目标检测】理论篇（3）YOLOv5实现
    你不一定知道的四种遍历进程的方法(c语言)
    1048 Find Coins
    【Unity实战100例】Unity内部软键盘输入制作
    以梦为马，不负韶华｜电巢科技&延安大学飞鹰计划实习班精彩回顾
    紫光同创PG2L100H关键特性评估板，盘古100K开发板，可实现复杂项目的开发
    【C++数据结构】线性表的本质和概念
    react useState基本使用
  • 原文地址：https://blog.csdn.net/2301_79035870/article/details/132790886