C语言进阶篇第二讲【指针详解】

Kukeoo

已于 2022-01-19 10:17:35 修改

阅读量1.7k

点赞数 2

分类专栏： C语言文章标签： c语言 c++ 开发语言

于 2021-01-30 22:23:15 首次发布

By Kukeoo

本文链接：https://blog.csdn.net/Kukeoo/article/details/113186542

版权

C语言专栏收录该内容

71 篇文章 12 订阅

订阅专栏

一、本章重点

1. 字符指针

2. 数组指针

3. 指针数组

4. 数组传参和指针传参

5. 函数指针

6. 函数指针数组

7. 指向函数指针数组的指针

8. 回调函数

9. 指针和数组面试题的解析

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

1. 指针就是个变量，用来存放地址，地址唯一标识一块内存空间。

2. 指针的大小是固定的4/8个字节（32位平台/64位平台）。

在不存在交叉编译（在A平台编译B平台的代码）的情况下，可以用sizeof(void*) = 4 or = 8来判断平台是32位还是64位。

3. 指针是有类型，指针的类型决定了指针的+-整数的步长，指针解引用操作的时候的权限。

4. 指针的运算。

二、字符指针

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

一般使用:

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

还有一种使用方式如下：

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

代码 char* pstr = "hello bit."; 特别容易让同学以为是把字符串 hello bit 放到字符指针 pstr 里了，

但是/本质是把字符串 hello bit. 首字符的地址放到了pstr中。

上面代码的意思是把一个常量字符串的首字符 h 的地址存放到指针变量 pstr 中。

也就是说，

printf("%c\n",*pstr);//这段代码会打印出h。

printf("%s\n", pstr);//这段代码会打印出hello bit.

注意，C++中则不同。C++中应该加const修饰。

那就有可这样的面试题：

#include <stdio.h>
int main()
{
    char str1[] = "hello bit.";
    char str2[] = "hello bit.";
    char *str3 = "hello bit.";
    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;
}

这里最终输出的是：

这里str3和str4指向的是一个同一个常量字符串。

常量字符串既然一样，又不会被修改，那就没有必要存两份。

C/C++会把常量字符串存储到单独的一个内存区域，当几个指针。

指向同一个字符串的时候，他们实际会指向同一块内存。

但是用相同的常量字符串去初始化不同的数组的时候就会开辟出不同的内存块。

所以str1和str2不同，str3和str4不同。

三、数组指针

数组指针的定义

数组指针是指针？还是数组？

答案是：指针。

我们已经熟悉：

整形指针： int * pint; 能够指向整形数据的指针。

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

那数组指针应该是：能够指向数组的指针。

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

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

解释：

int (*p)[10];

//解释：p先和*结合，说明p是一个指针变量，然后指着指向的是一个大小为10个整型的数组。所以p是一个指针，指向一个数组，叫数组指针。

//这里要注意：[]的优先级要高于*号的，所以必须加上（）来保证p先和*结合

&数组名VS数组名

对于下面的数组：

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

运行结果如下：

可见数组名和&数组名打印的地址是一样的。

难道两个是一样的吗？

我们再看一段代码：

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

根据上面的代码我们发现，其实&arr和arr，虽然值是一样的，但是意义应该不一样的。

实际上： &arr 表示的是数组的地址，而不是数组首元素的地址。（细细体会一下）

数组的地址+1，跳过整个数组的大小，所以 &arr+1 相对于 &arr 的差值是40.

数组指针的使用

那数组指针是怎么使用的呢？

既然数组指针指向的是数组，那数组指针中存放的应该是数组的地址。

char* arr[5];
char* (*pa)[5] = &arr;

看代码：

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

//数组名arr，表示首元素的地址
//但是二维数组的首元素是二维数组的第一行
//所以这里传递的arr，其实相当于第一行的地址，是一维数组的地址

printf("%d ", *( *(arr+i) + j ) );

首先，数组指针存放的是一个数组的地址。

这个数组存放的元素是int型的，并且有5个；

+1，表示跨度，而跨度是一个数组。

一个数组有5个int类型的元素，所以跨度是20个字节；

arr+i，

指的是第一行还是第二行还是第三行的数组地址；

*（arr+i），

对其进行解引用，使其变成数组名，也就是第一行数组的首元素地址；

*（arr+i）+j，

第一行数组的首元素地址+0，+1...+4表示这是第一行第几个元素的地址；

*( *(arr+i) + j )，

再对具体到某个元素的地址进行解引用，得到元素的值。

也可以(*(p+i))[j];

//加一跳过一个数组
//可以数组指针来接收

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

int arr[5];
int *parr1[10];
int (*parr2)[10];
int (*parr3[10])[5];

1、arr是一个5个元素的整型数组

2、parr1是一个数组，数组有10个元素，每个元素的类型是int*，所以parr1是指针数组

3、parr2是一个数组指针，指向一个int型数组，里面存放了10个元素，每个元素类型是int

4、parr3是一个数组，因为[]比*优先级更高。

parr3[10] ------ parr3是数组名，10是十个元素

那么剩下的是他的类型 ------int(* )[5];

这是一个指向数组的指针。

所以：

parr3是一个数组，该数组有10个元素，每个元素是一个数组指针；

该数组指针指向的数组有5个元素，每个元素类型是int.

四、指针数组

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

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

指针数组的用法：

int arr1[] = {1,2,3,4,5};

int arr2[] = {2,3,4,5,6};

int arr3[] = {3,4,5,6,7};

int* parr[] = {arr1,arr2,arr3};

这样就建立起了如下关系：

int i = 0;

for(i = 0;i<3;i++)

{

int j = 0;

for(j = 0;j<5;j++)

{

printf("%d ",*(parr[i] + j));

}
printf("\n");
}

这样就能一次性打印三个数组。

五、数组传参和指针传参

数组参数、指针参数

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

一维数组传参

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

arr是一个整型数组，

arr2是一个整型指针数组

先看第一个：

可以的。

第二个也可以，都是用一个数组形参来接收数据。

第三个写的是指针的形式，

因为我们传过去的是数组首元素地址，也就是一个指针；

综上，对于整型数组，可以有以下三种传参写法：

void test(int arr[])
{}
void test(int arr[10])
{}
void test(int *arr)
{}

 test(arr);

那么对于指针数组呢？

第四个也是可以的。也可以省略数组大小20.

第五个也可以，

参数部分如果是一个二级指针，指向指针数组的地址即可

综上，对于指针数组，可以有以下两种传参写法：

void test2(int *arr[20])
{}
void test2(int **arr)
{}
 test2(arr2);

二维数组传参

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!因为这里的数组是二维数组，二维数组的数组名如果表示首元素地址，那么是第一行的地址，也就是一个一维数组的地址。一个数组的地址显然是不能放进整型指针里的。
{}
void test(int* arr[5])//ok？NO！这里表示的是一个指针数组。
{}
void test(int (*arr)[5])//ok？OK!传过去的其实是第一行的地址，所以应该使用一个数组指针，指向的数组一共有5个元素，每个元素都是int型的。
{}
void test(int **arr)//ok？NO!这样也有问题。二维数组名是首元素地址，是第一行的地址，是一个数组的地址；而数组地址显然不能放进一个二级指针里。
{}
int main()
{
 int arr[3][5] = {0};
 test(arr);
}

一级指针传参

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

思考：

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

比如：

void test1(int *p)
{}
//test1函数能接收什么参数？
void test2(char* p)
{}
//test2函数能接收什么参数？

test1可以传一个一级指针，或者一个变量的地址。

test2同理。

二级指针传参

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

思考：

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

void test(char **p)
{

}
int main()
{
 char c = 'b';
 char*pc = &c;
 char**ppc = &pc;
 char* arr[10];
 test(&pc);
 test(ppc);
 test(arr);//Ok?
 return 0;
}

这里，如果数组是一个指针数组，

那么数组名就是首元素地址，

而首元素是一个一级指针，

所以数组名此时就是一个二级指针。

所以test(arr)是可以的。

六、函数指针

指向函数的指针。

首先看一段代码：

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

输出的结果：

输出的是两个地址，这两个地址是 test 函数的地址。

函数里，&函数名和函数名是一样的，都是函数的地址。

那我们的函数的地址要想保存起来，怎么保存？

int (*pa)(int,int) = Add;

*pa指的是pa是一个指针；

(int,int) 指的是pa是一个函数指针；

int指的是指向的函数返回类型是int。

那么可以用函数指针来调用函数：

*pa(2,3);

此时的*pa相当于函数Add。

再举一个例子：

void print(char* str)
{
	printf("%s\n", str);
}
int main()
{
	char str[] = "123456";
	char* p = str;
	void (*pprint)(char*) = print;
	(*pprint)(p);
	return 0;
}

下面我们看代码：

void test()
{
 printf("hehe\n");
}
//下面pfun1和pfun2哪个有能力存放test函数的地址？
void (*pfun1)();
void *pfun2();

首先，能给存储地址，就要求pfun1或者pfun2是指针，那哪个是指针？答案是：

pfun1可以存放。pfun1先和*结合，说明pfun1是指针，指针指向的是一个函数，指向的函数无参数，返回值类型为void。

阅读两段有趣的代码：

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

代码1：

(*(void (*)())0)();

( void (* ) ( ) ):这是一个函数指针，返回类型为空

(void (*)())0：把0强制类型转换成：void(*)()这种函数指针的类型

这时候，0变成函数的地址了。

(*(void (*)())0)（）：对这个函数解引用，调用0地址处的这个函数

代码2：

函数名：signal

参数：int和一个函数指针void(*)(int)

返回类型：剩下的，

也就是void(* )(int);

返回类型也是一个函数指针。

代码2太复杂，如何简化：

typedef void(*pfun_t)(int);
pfun_t signal(int, pfun_t);

拓展：以下四种写法均可调用函数

如果pa是一个函数指针，它可以解引用，也可以不引用。

七、函数指针数组

数组是一个存放相同类型数据的存储空间，那我们已经学习了指针数组，比如：

int *arr[10];
//数组的每个元素是int*

那要把函数的地址存到一个数组中，那这个数组就叫函数指针数组，那函数指针的数组如何定义呢？

int (*parr1[10]])();
int *parr2[10]();
int (*)() parr3[10];

答案是：

parr1

parr1 先和 [] 结合，说明parr1是数组，数组的内容是什么呢？是 int (*)() 类型的函数指针。

两个练习：

函数指针数组的用途：转移表

例子：计算器

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

使用函数指针数组的实现：

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

注：这里的 ret = (*p[input])(x, y);

可以写成：ret = (p[input])(x, y);

对第一种方法继续改进：

采用封装的方法。

封装一个这样的函数：

他的参数是一个函数指针。

总的代码：

把函数地址传给某个新的函数，而被调用的那个旧的函数被称为回调函数。【见九】

解决了冗余的问题。

八、指向函数指针数组的指针

指向函数指针数组的指针

是一个指针，

指针指向一个数组，

数组的元素都是 函数指针 ;

如何定义？

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)[10])(const char*) = &pfunArr;
 return 0;
}

void (*(*ppfunArr)[10])(const char*) = &pfunArr;

(*ppfunArr)[10]：ppfunArr是一个数组指针

把它去掉，看剩下的：

void (* )(const char*)

剩下的是这个数组指针里存放的元素类型，

是函数指针。

所以这是一个指向函数指针数组的指针。