C语言深度剖析指针

我会带着你远行 2023-09-26 17:40 230阅读 0赞

> **文章目录**
> 
> 一、指针简单介绍
> 
> 二、进阶指针的详解
> 
> 2、1 字符指针
> 
> 2、2 指针数组
> 
> 2、3 数组指针
> 
> 2、3、1 数组指针的定义以用法
> 
> 2、3、2 数组名和&数组名的区别
> 
> 2、3、3 数组指针的用法
> 
> 2、4 函数指针
> 
> 2、4、1 函数指针的解释
> 
> 2、4、2 函数指针的举例分析
> 
> 2、5 函数指针数组
> 
> 2、5、1 函数指针的解释
> 
> 2、5、2 函数指针的引用举例
> 
> 2、6 指向函数指针数组的指针
> 
> 三、总结
> 
> --------------------
> 
> ## **标题：C语言深度剖析指针** ##
> 
> ## **作者：@Ggggggtm** ##
> 
> ## **寄语：与其忙着诉苦，不如低头赶路，奋路前行，终将遇到一番好风景** ##
> 
> ![83c99de362ce47eabb12f1f44251089b.png][]

## 一、指针简单介绍 ##

> 首先我们先复习一下**指针的概念**：
> 
>  *  指针就是个变量，用来存放地址，地址唯一标识一块内存空间。
>  *  指针的大小是固定的4/8个字节（32位平台/64位平台）。
>  *  指针是有类型，指针的类型决定了指针的+-整数的步长，指针解引用操作的时候的权限。
>  *  指针的运算（指针减指针为两个指针之间的元素个数）。
> 
> 我们本篇文章会重点讲解一下**字符指针、数组指针、指针数组、数组传参和指针传参、函数指针、函数指针数组、指向函数指针数组的指针、回调函数、指针和数组面试题的解析。**

## 二、进阶指针的详解 ##

### 2、1 字符指针 ###

> 字符指针在指针类型中是比较常见的，也是相对来说较为简单的。其代码表示为**char\* 。**
> 
> 字符指针一般的用法如下：

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

> 上述代码就是将一个字符变量的地址存放到字符指针当中 ，通过解引用操作可对字符变量的值进行修改。
> 
> 还有如下用法：

int main()
    {
        const char* pstr = "hello bit.";//这里是把一个字符串放到pstr指针变量里了吗？
        printf("%s\n", pstr);
        return 0;
    }

> 上述的代码是把**字符串的首元素地址存放到了字符指针当中**，并不是把一个字符串放到pstr指针变量里。
> 
> 我们再来看一道例题理解一下，代码如下：

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数组分别在栈区开辟了不同的空间，并且都存储了相同的内容”hello bit.“，但是用相同的常量字符串去初始化不同的数组的时候就会开辟出不同的内存块。**”hello bit.“为常量字符串，在内存中存储到位置为代码段区（常量区）**，str3与str4字符指针都是指向了代码段区（常量区）的字符串”hello bit.“的首元素地址。同时要注意的是，**str1 ==str2与str3 ==str4两两比较是比较的地址，而不是两者的内容**。所以答案就是str1 ！=s tr2 、str3 == str4。

### 2、2 指针数组 ###

> 首先我们要考虑的是**指针数组是指针呢？还是数组呢？**我们不妨想想之前学过的整型数组、浮点型数组、字符数组等等可知，**指针数组是一个数组，该数组存放的数据类型为指针。**
> 
>  指针数组常见的用法如下：

int  main()
    {
    	int a = 0, b = 1, c = 2;
    	int* arr1[10] = { &a,&b,&c }; //整形指针的数组
    
    
    	char* arr2[4] = { "abcde","ghijk","rmn","opqrst" }; //一级字符指针的数组
    
    	char A = 'c';
    	char* p = &A;
    	char** arr3[5] = { &p };//二级字符指针的数组
    	return 0;
    }

### 2、3 数组指针 ###

#### 2、3、1 数组指针的定义以用法 ####

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

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

> 通过上面对指针数组的学习，我们知道int \*p1\[10\]是指针数组。那么int (\*p2)\[10\]为数组指针。指向的类型为数组，该数组的元素个数为十个，数据类型为int。
> 
> int (\*p)\[10\]是数组指针的解释：p先和\*结合，说明p是一个指针变量，然后指着指向的是一个大小为10个整型的数组。所以p是一个指针，指向一个数组，叫数组指针。  
> **这里要注意：\[\]的优先级要高于\*号的，所以必须加上（）来保证p先和\*结合。**
> 
> 数组指针常见的用法如下：

int main()
    {
    	int arr[10];
    	int(*p)[10] = &arr; //&arr为整个数组的地址
    	return 0;
    }

#### 2、3、2 数组名和&数组名的区别 ####

> 我们看如下数组：
> 
>     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;
    }

> 上述代码的运行结果是什么呢？我们看下图：
> 
> ![a55b79f02ddb415fb9aac81fc11c9ed2.png][]
> 
> 从这里我们好像看不出来有什么区别。那我们再看一下下面的代码：

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

> 上面代码的运行结果呢？如果我们不了解两者的区别的话，就很容易出错。我们看下图运行结果：![c8ff888576c4425ca84220c6fda5bd70.png][]
> 
> 根据上面的代码我们发现，其实&arr和arr，虽然值是一样的，但是**意义应该不一样的。**实际上： **&arr 表示的是数组的地址，而不是数组首元素的地址。**（细细体会一下）本例中 &arr 的类型是：int(\*)\[10\] ，是一种数组指针类型数组的地址+1，跳过整个数组的大小，所以 &arr+1 相对于 &arr 的差值是40。

#### 2、3、3 数组指针的用法 ####

> 我们直接看一段数组指针的代码：

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

> 我们再来看一下自己的掌握程度。看看是否能够解释一下如下代码的意思。

int arr[5];  //数组
    
    
    int *parr1[10];  //指针数组——parr1是一个数组，该数组有十个元素，每个元素的类型为int*
    
    
    int (*parr2)[10];  //数组指针——parr2是一个指针，该指针是指向的一个数组，       
                       //指向的数组的元素个数为10个，数组元素的类型为int
    
    
    int (*parr3[10])[5];  //parr3是一个数组，该数组有10个元素，每个元素的类型为数组指针，
                          //也就是每个元素为指针，指针指向的是一个数组。

### 2、4 函数指针 ###

#### 2、4、1 函数指针的解释 ####

> 我们先来看一段代码：

#include <stdio.h>
    void test()
    {
        printf("hehe\n");
    }
    int main()
    {
        printf("%p\n", test);
        printf("%p\n", &test);
        return 0;
    }

> 看到这段代码的首先反应是：函数有地址吗？答案是有的。我们先看一下运行的结果，如下图：![e552e4220ff24906aeb632a58131afb4.png][]
> 
> 通过上述例子，我们更加确定了函数确实是有地址的。并且**函数名和&函数名都是函数的地址，两者是相同的**。那我们怎么保存函数的地址呢？肯定是需要指针来保存的。根据我们上面的学习，这里就可以推断出**保存函数的地址是需要一个函数指针。**
> 
> 我们通过上面的例子来说明函数指针的使用，如下:

#include <stdio.h>
    void test()
    {
        printf("hehe\n");
    }
    int main()
    {
        void (*p)()=test;  //指针p即为函数指针，存储的是test函数的地址。
        printf("%p\n", p);
        printf("%p\n", test);
        return 0;
    }

#### 2、4、2 函数指针的举例分析 ####

> 通过对上面的函数指针的了解后，我们分析一下下面的两段代码的意思：

//代码1
    (*(void (*)())0)();
    //代码2
    void (*signal(int , void(*)(int)))(int);

> **代码1**：我们可以从最里面的括号进行分析。**void（\*）（）**是一个函数指针类型，**(void ( \* )( ))0**的意思是**将0强制类型转换为一个函数指针类型****地址**。最后再对**以0为地址进行解引用操作**，相当于**调用了以0为地址的函数**。
> 
> **代码2**：我们可以从变量名称signal入手。我们可以分析出**signal(int , void(\*)(int))**是一次函数的调用，剩下的**void (\*)(int)**即为signal函数调用的**返回值的类型**，该类型是一个指针，该指针的类型是一个函数指针。

### 2、5 函数指针数组 ###

#### 2、5、1 函数指针的解释 ####

> 学完函数指针后，我们学函数指针数组也就容易了。**函数指针数组是一个数组，该数组存放的数据类型为函数指针。**
> 
> 把函数的地址存到一个数组中，那这个数组就叫函数指针数组，那函数指针的数组如何定义呢？我们看如下代码：

int (*parr1[10])();

> 上述的代码就是一个函数指针数组。我们来分析一下。上述的**parr1与\[10\]结合，表明parr1是一个数组**，该数组的元素类型为**int（\*）（）**，很明显了元素的类型为**函数指针**。

#### 2、5、2 函数指针的引用举例 ####

> 当我们有多个函数，且函数的参数和返回值类型相同的时候，我们就可以将多个函数的地址放到一个函数指针数组中。
> 
> 我们要写出一段代码，要求该代码能够实现加、减、乘、除算法。我们先看如下代码。

#include <stdio.h>
    int add(int a, int b)
    {
        return a + b;
    }
    int sub(int a, int b)
    {
        return a - b;
    }
    int mul(int a, int b)
    {
        return a*b;
    }
    int div(int a, int b)
    {
        return a / b;
    }
    int main()
    {
        int x, y;
        int input = 1;
        int ret = 0;
        do
        {
            printf( "*************************\n" );
            printf( " 1:add 2:sub \n" );
            printf( " 3:mul 4:div \n" );
            printf( "*************************\n" );
            printf( "请选择：" );
            scanf( "%d", &input);
            switch (input)
            {
            case 1:
                printf( "输入操作数：" );
                scanf( "%d %d", &x, &y);
                ret = add(x, y);
                printf( "ret = %d\n", ret);
                break;
            case 2:
                printf( "输入操作数：" );
                scanf( "%d %d", &x, &y);
                ret = sub(x, y);
                printf( "ret = %d\n", ret);
                break;
            case 3:
                printf( "输入操作数：" );
                scanf( "%d %d", &x, &y);
                ret = mul(x, y);
                printf( "ret = %d\n", ret);
                break;
            case 4:
                printf( "输入操作数：" );
                scanf( "%d %d", &x, &y);
                ret = div(x, y);
                printf( "ret = %d\n", ret);
                break;
            case 0:
                printf("退出程序\n");
                breark;
            default:
                printf( "选择错误\n" );
                break;
            }
        } while (input);
        return 0;
    }

> 我们发现，上面的代码switch语句中，代码有大量的重复和冗余。这时我们可以用函数指针数组来代替switch语句。我们直接结合代码理解一下。代码如下：

#include <stdio.h>
    int add(int a, int b)
    {
        return a + b;
    }
    int sub(int a, int b)
    {
        return a - b;
    }
    int mul(int a, int b)
    {
        return a*b;
    }
    int div(int a, int b)
    {
        return a / b;
    }
    int main()
    {
        int x, y;
        int input = 1;
        int ret = 0;
        int(*p[5])(int x, int y) = { 0, add, sub, mul, div }; //转移表
        while (input)
        {
            printf( "*************************\n" );
            printf( " 1:add 2:sub \n" );
            printf( " 3:mul 4:div \n" );
            printf( "*************************\n" );
            printf( "请选择：" );
            scanf( "%d", &input);
            if ((input <= 4 && input >= 1))
            {
                printf( "输入操作数：" );
                scanf( "%d %d", &x, &y);
                ret = (*p[input])(x, y);
            }
            else
                printf( "输入有误\n" );
            printf( "ret = %d\n", ret);
        }
    return 0

> 这是我们发现，代码的简洁性提高了很多。

### 2、6 指向函数指针数组的指针 ###

> 指向函数指针数组的指针是什么呢？一看到这个名字就头昏脑胀，感觉很难理解。我们不妨一步一步分析一下。首先我们可以很容易看出**指向函数指针数组的指针是一个指针**。**指针指向的类型是什么呢？**指针指向的是**一个数组，该数组存放的数据类型是函数指针**。
> 
> 如何定义呢？我们看如下代码：

void test(const char* str)
    {
        printf("%s\n", str);
    }
    int main()
    {
        //函数指针pfun
        void (*pfun)(const char*) = test;
        //函数指针的数组pfunArr
        void (*pfunArr[5])(const char* str);
        pfunArr[0] = test;
        //指向函数指针数组pfunArr的指针ppfunArr
        void (*(*ppfunArr)[5])(const char*) = &pfunArr;
        return 0;
    }

## 三、总结 ##

> 通过对本篇文章的学习，可能会感觉到很晕，分析时不知道该如何下手。分析时我们应该**先判断该代码是一个数组，还是一个指针**。**根源无非就指针和函数两种**，其他的任何形式都是在这两个的基础上一点一点拓展的。我们应该多练习，反复阅读理解。到后面会发现自己或有不断的新理解，从而能够熟练掌握并运用。

> 本篇文章对指针的讲述就到这里，希望以上内容对你可以有一个很好的理解帮助。
> 
> 感谢阅读ovo~

[83c99de362ce47eabb12f1f44251089b.png]: https://img-blog.csdnimg.cn/83c99de362ce47eabb12f1f44251089b.png
[a55b79f02ddb415fb9aac81fc11c9ed2.png]: https://img-blog.csdnimg.cn/a55b79f02ddb415fb9aac81fc11c9ed2.png
[c8ff888576c4425ca84220c6fda5bd70.png]: https://img-blog.csdnimg.cn/c8ff888576c4425ca84220c6fda5bd70.png
[e552e4220ff24906aeb632a58131afb4.png]: https://img-blog.csdnimg.cn/e552e4220ff24906aeb632a58131afb4.png