C语言：指针详解【进阶】前篇

前言：

我在``指针详解【初阶】的文章中，讲解了指针的基本概念：

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

今天就让我们进一步的了解指针更深层次的使用形式和用法。

---

字符指针

指针的类型有很多，比如整型指针、字符指针、浮点数指针等。
我们一般说，什么类型的指针变量就存放着该类型变量的地址。
对于字符指针来说，一般的使用场景是这样的：

int main()
{
	char ch = 'w';
	char* pc = &ch;
	*pc = 'w';
	return 0;
}

定义一个字符变量ch并进行初始化，接着再定义一个字符指针pc，里面存放着ch的地址，然后对pc指针解引用就可以访问到ch变量并对其进行相关操作了。

假如这里有一个这样的字符指针：

int main()
{ 
	const char* ps = "hello bit.";
	printf("%s\n", ps);
	return 0;
}

注：

const修饰变量，使变量具有常属性，变量不可再被修改。

const的详细讲解在：C语言：实用调试技巧（VS2019）

对于这里的指针ps的使用怎么理解？
对于代码 const char* ps = "hello bit.";
这里特别容易让初学者以为是把字符串 hello bit .放到字符指针 ps 里了，但指针的大小只有4/8个字节，是存放不下这些字符的，所以这里本质是把字符串 hello bit. 首字符的地址放到了ps中。

根据上述的知识，这里有个练习题：

#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[]是分别在内存中的不同地址处分别申请了两块空间并进行初始化，所以str1[]和str2[]的地址是不同的。str3和str4指针是指向了内存中的一个常量字符串的首字符的地址，两个指针指向的内容是一样的，所以str3和str4的地址是相同的。

---

指针数组

在指针详解【初阶】我们也基本认识了指针数组。

指针数组是一个存放指针的数组。

这里我们再复习一下，下面指针数组是什么意思？

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

数组指针

数组指针的定义

数组指针是指针？还是数组？
答案是：指针。
我们已经熟悉：

整形指针： int * pint; 能够指向整形数据的指针。
浮点型指针： float * pf; 能够指向浮点型数据的指针。

那数组指针应该是：能够指向数组的指针。
下面代码哪个是数组指针？

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

注：

[ ]的优先级要高于 * 号的，所以必须加上 () 来保证 先和 * 结合。

---

数组名 和 &数组名

对于下面的数组：

int arr[10];

arr 和 &arr 分别是啥？
我们知道arr是数组名，数组名表示数组首元素的地址。
那&arr数组名到底是啥？
我们来看看两者的地址：

#include <stdio.h>
int main()
{
    int arr[10] = {0};
    printf("%p\n", arr);
    printf("%p\n", &arr);
    return 0;
}

结果数组名和&数组名打印的地址一样。
难道arr和&arr都指得是数组arr的首元素的地址吗？
这里再看一组代码：

#include <stdio.h>
int main()
{
    int arr[10] = { 0 };
    printf("%p\n", arr);
    printf("%p\n", arr + 1);
    printf("%p\n", &arr);
    printf("%p\n", &arr + 1);
    return 0;
}

当我们对arr和&arr进行加一操作时，他们跳过的字节数也不相同。

arr + 1 跳过了4个字节
&arr + 1 跳过了40个字节

我们可以知道arr每个元素的类型为整型，每个整型正好占了4个字节，所以当arr + 1时就指向了数组第二个元素的地址了。
但&arr + 1却跳过了40个字节，这是怎么回事？
其实这里的&arr是取出了整个数组的地址，但打印时只打印数组第一个元素的地址，所以&arr和arr的地址是相同的。
所以当&arr进行+1操作时跳过了整个数组，数组一共有10个整型元素，所占字节总数为40个字节，所以&arr + 1跳过了40个字节。

本例中 &arr 的类型是： int(*)[10] ，是一种数组指针类型
数组的地址+1，跳过整个数组的大小，所以 &arr+1 相对于 &arr 的差值是40.

---

数组指针的使用

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

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

一个数组指针的使用：

#include <stdio.h>
void print_arr1(int arr[3][5], int row, int col)
{
    int i = 0;
    for(i=0; i<row; i++)
   {
        for(j=0; j<col; j++)
       {
            printf("%d ", arr[i][j]);
       }
               printf("\n");
   }
}
	 //这里用数组指针来接收二维数组的首元素地址
void print_arr2(int (*arr)[5], int row, int col)
{
    int i = 0;
    for(i=0; i<row; i++)
   {
        for(j=0; j<col; j++)
       {
            printf("%d ", arr[i][j]);
       }
        printf("\n");
   }
}
int main()
{
    int arr[3][5] = {1,2,3,4,5,6,7,8,9,10};
   print_arr1(arr, 3, 5);
    //数组名arr，表示首元素的地址
    //但是二维数组的首元素是二维数组的第一行
    print_arr2(arr, 3, 5);
    //所以这里传递的arr，其实相当于第一行的地址，是一维数组的地址
    //可以数组指针来接收
    return 0;
}

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

int arr[5];//一维数组
int *parr1[10];//指针数组
int (*parr2)[10];//数组指针

int (*parr3[10])[5];//这个是什么？

数组传参和指针传参

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

一维数组传参

思考下面这些数组传参是否可取

1. 普通数组传参：

#include <stdio.h>
void test1(int arr[])
{
	printf("test1 ok\n");
}
void test2(int arr[10])
{
	printf("test2 ok\n");
}
void test3(int* arr)
{
	printf("test3 ok\n");
}
int main()
{
	int arr[10] = { 0 };
	test1(arr);
	test2(arr);
	test3(arr);
	return 0;
}

2. 指针数组传参：

#include <stdio.h>
void test4(int* arr[])
{
	printf("test4 ok\n");
}
void test5(int* arr[10])
{
	printf("test5 ok\n");
}
void test6(int** arr)
{
	printf("test6 ok\n");
}
int main()
{
	int* arr2[10] = { 0 };
	test4(arr2);
	test5(arr2);
	test6(arr2);
	return 0;
}

---

二维数组传参

#include <stdio.h>
void test1(int arr[3][5])
{}
void test2(int arr[][5])
{}
void test3(int arr[][])
{}
void test4(int* arr)
{}
void test5(int* arr[5])
{}
void test6(int(*arr)[5])
{}
void test7(int** arr)
{}
int main()
{
	int arr[3][5] = { 0 };
	test1(arr);
	test2(arr);
	test3(arr);
	test4(arr);
	test5(arr);
	test6(arr);
	test7(arr);
	return 0;
}

一级指针传参

#include <stdio.h>
void print(int* parr, int sz)
{
	int i = 0;
	for (i = 0; i < sz; i++)
	{
		printf("%d\n", *(parr + 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]);
	print(p, sz);
	return 0;
}

思考：

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

可以接收：

• 一级指针
• 非指针变量的地址
• 数组
• 数组的首元素地址

二级指针传参

#include <stdio.h>
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;
}

思考：

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

可以接收：

• 二级指针
• 一级指针的地址
• 指针数组的首元素地址

---

讲到这里指针详解【进阶】前篇的知识讲解就结束了，由于指针方面知识较多，这里我分为了前篇和后篇两次文章讲解，后篇将会讲到函数指针、函数指针数组、指向函数指针数组的指针和回调函数。

---

感兴趣的的小伙伴点点赞，点点关注，谢谢大家的阅读哦！！！
点点关注，后期不错过哦。😘
你们的鼓励就是我的动力，欢迎下次继续阅读！！！😘😘😘