大家好,我是深鱼~

【前言】:

指针的主题,在初阶指针章节已经接触过了,我们知道了指针的概念:

1.指针就是个变量,用来存放地址,地址的唯一标识一块内存空间(指针变量),内存单元是由编号的,编号==地址==指针

2.指针/地址/指针变量的大小是固定的4/8个字节(32位平台/64位平台)

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

4.指针的运算


【目录】

一、字符指针

二、指针数组

三、数组指针

3.1数组指针的定义

3.2&数组名vs数组名

3.3数组指针的使用

四、数组参数,指针参数

4.1一维数组传参

4.2二维数组传参

4.3一级指针传参

4.4二级指针传参

五、函数指针


一、字符指针

一般使用:

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

还有一种使用方式如下:

#includeint main(){char ch = 'w';char* p = "abcdef"; //[abcdef\0]//char arr[]="abcdef"printf("%s\n,p);//打印的是整个字符串printf("%c\n,*p);//打印的是aprintf("%c\n", "abcdef"[3]);//打印的是dreturn 0;}

这里的字符串”abcdef“类似于数组,把这个字符串赋给p指针,也就是字符串的首地址赋给p指针

(假设是 32位平台,指针的大小也就是4个字节,但是这个字符串却有7个字节(算上\0),这样看是放不下的)

但是这个代码存在问题,p变量赋给了常量字符串,如果改变p变量,常量字符串是不会更改的

eg:这样代码很容易出错误,所以一般会在char *p之前写上const

char* p = “abcdef”;
*p = ‘e’;

更加安全的写法:

const char* p = “abcdef”;

下面再来看一道【经典面试题】

这道题的输出结果是啥?

#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");elseprintf("str1 and str2 are not same\n");if(str3 ==str4)printf("str3 and str4 are same\n");elseprintf("str3 and str4 are not same\n");return 0;}

【答案】:

str1 and str2 are not same
str3 and str4 are same

【解释】:

(1)首先创建两个数组,分别放入hello bit,因为是两个不同的数组,那么字符串就存在不同的位置,当判断str1和str2,也就是两个数组的首地址的时候,这两个h地址肯定不相同

(2)str3和str4指针都指向常量字符串,因为常量字符串不可修改,那么其实也没有必要再创建一个空间来存两个相同的常量字符串,如果两个指针同时指向这个常量字符串的时候,其实指向的也就是同一个地址,那么str3和str4也就相同


【拓展】:再加一个

if(&str3==&str4)

printf(“YES\n”);

else

printf(“NO\n”);

【答案】:NO

【图解】:指针变量不同,地址不同

p(指针变量):表示指针变量指向的内存地址

&p:取指针p的地址,表示编译器为变量p分配的内存地址(不同变量分配的地址不同),而不是这个指针p指向的地址


二、指针数组

指针数组是数组

字符数组-存放字符的数组

整形数组-存放整形的数组

指针数组-存放指针的数组,存放在数组的元素都是指针类型的

eg: int *arr[5]; //存放整形指针的数组

char * ch[6]; //存放字符指针的数组

【那指针数组一般怎么用呢?】

一般不会像这样使用:int *arr[3]={&a,&b,&c}

而是这样使用:可以用指针数组模拟一个二维数组

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 };for (int i = 0; i < 3; i++){for (int j = 0; j < 5; j++){printf("%d ", arr[i][j]);}printf("\n");}return 0;}

【图解】:指针数组放入三个数组,这三个数组的类型是int *指针类型,通过指针数组的打印可以模拟二维数组

【程序结果】:


再举个栗子:建立一个字符类型(int *)指针数组,并打印数组内的元素

#includeint main(){char* arr[5] = { "hello bit","hehe","penggeC","bitejiuyeke","C++" };for (int i = 0; i < 5; i++){printf("%s\n", arr[i]);}return 0;}

【图解】:分别把字符串的首元素地址传给了指针,然后把这些指针放在数组中

【程序结果】:


三、数组指针

3.1数组指针的定义

数组指针是指针,类型于字符指针(指向字符的指针),整形指针(指向整形的指针),浮点型指针(指向浮点型的指针),那么数组指针就是指向数组的指针

int a=10; int *p=&a;(整形指针)

char ch=’a’; char *pc=&ch;(字符指针)

int arr[10]; int (*p)[10]=&arr;(数组指针)

下面我们来理解一下int(*p)[10]:

int (*p) [10]中的*表示p是一个指针,*p指向[10]表示指向数组的指针,int代表数组元素类型

【注意】:

不能直接定义一个指针p,然后把&arr赋给p,&arr是整个数组的地址,&arr的类型是int (*)【10】,而指针p的类型是int *,不对等,所以&arr应该放在数组指针中

3.2&数组名vs数组名

首先数组名的理解:

数组名是首元素的地址但是存在两个例外:

1.sizeof(数组名),这里的数组名表示整个数组,计算的是整个数组的大小,单位是字节

2.&数组名,这里的数组名表示整个数组,取出来的是数组的地址

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);//int *[10]这就是数组指针的类型printf("%p\n", &arr+1);//指针类型决定了指针+1到底+几个字节return 0

【注意】:这里的10不可省略,数组指针要明确指针指向的数组是几个元素

【练习】:

char* arr2[5]的数组指针:char* (*p)[5](前面的char*是数组类型)

int arr3[]={1,2,3}的数组指针:int (*p)[3] (数组指针要明确指向数组的大小,这个3必须写)

3.3数组指针的使用

先来看看用数组指针打印数组元素:这其实是多此一举的,本来可以直接arr打印数组元素,但是还要定义一个数组指针,再用数组指针来打印数组元素

int main(){int arr[10] = { 1,2,3,4,5,6,7,8,9 };int(*p)[10] = &arr;for (int i = 0; i < 10; i++){printf("%d ", (*p)[i]);}return 0;}

【那如果把打印的内容换成p[i],结果又如何呢?】

p[i]等价于*(p+i),而指针+1,直接就跳过一个数组地址,根本不可能打印出数组的元素

直接把数组名传给p指针,这样才能访问数组的元素:int *p=arr

代码运行结果:


那么数组指针到底有什么用呢?】

数组指针用都是用在二维数组上,我们来看一个例子:打印一个二维数组


正常的方法:形参使用二维数组的形式

#includevoid print(int arr[3][5], int row, int col){for (int i = 0; i < 3;i++){for (int 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)形参int (*p)[5]代表:这个数组指针指向的是数组第一行5个元素的地址

(3)p[i][j]代表:p[i]就相当于*(p+i),每行的地址,解引用后就是每行的数组名,每行的数组名[j],就可以得到每行的数组元素

#includevoid print(int (*p)[5], int row, int col){for (int i = 0; i < 3;i++){for (int j = 0; j < 5; 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;}

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

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

arr是一个能够存放5个整形数据的数组

parr1是一个数组,数组10个元素,,每个元素的类型都是int *

parr2是一个指针,该指针是指向数组的,指向的数组有10个元素,每个元素的类型都是int

parr3是一个数组,是存放数组指针的数组(这个parr3【10】数组10个元素),存放数组指针(int (*) [5],指向的数组有5个元素,每个元素是int类型(这个比较难,不理解也没事)

对于4画图理解:parr3是10个元素的数组,每个元素中都是地址(数组指针),每个元素的类型都是int(* )[5],而对应数组中存放的数组指针,这个指针指向5个元素的数组


四、数组参数,指针参数

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

4.1一维数组传参

数组传参,形参是可以写成数组的形式的,也可以是指针,传参的本质是传递了数组首元素的地址

以下6种方式传参都是可以的

#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,数组的形式传参,可以省略数组的元素个数{}void test2(int** arr)//ok,指针的形式传参{}int main(){int arr[10] = { 0 };int* arr2[20] = { 0 };//指针数组test(arr);test2(arr2);}

对于最后一种的理解:arr2每个元素的类型都是int *,arr2也就是取int *元素的首地址,一个指针的地址,那么就放到二级指针里面去


4.2二维数组传参

void test(int arr[3][5])//ok{}void test(int arr[][])//no,二维数组只能省略行,不可省略列{}void test(int arr[][5])//ok{}void test(int* arr)//no,二维数组首元素地址是第一行的地址,所以指针传参不能省略列{}void test(int* arr[5])//no,这是一个指针数组,而不是本来的二维数组{}void test(int(*arr)[5])//ok,数组指针,指针指向数组,数组中有5个元素{}void test(int** arr)//no,二级指针是用来接收一级指针的地址,而我们只需要第一行数组的地址,一级指针即可{}int main(){int arr[3][5] = { 0 };test(arr);}

二维数组传参:

数组形式传参:只能省略行,不可省略列

指针形式传参:参数形式应该是数组指针int (*arr)【列】,而不能是指针数组

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.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)传指针数组(首元素的地址)

五、函数指针

类比:

数组指针-指向数组的指针-存放的是数组的地址-&数组名就是数组的地址

函数指针-指向函数的指针-存放的是函数的地址-那么怎么得到函数的地址呢

#includeint Add(int x, int y){return x + y;}int main(){//&函数名就是函数的地址//函数名也是函数的地址printf("%p\n", &Add);printf("%p\n", Add);int (*pf1)(int, int) = Add;//pf1就是函数指针变量int (*pf2)(int, int) = &Add;return 0;}

&函数名就是函数的地址,函数名也是函数的地址

int (*pf1)(int, int) = Add这里的括号不可省略,不然前面的部分就跟函数声明一样

利用函数指针进行Add加和:

#includeint Add(int x, int y){return x + y;}int main(){int (*pf2)(int, int) = &Add;//int (*pf2)(int, int) = Add;这样写也可以int ret = (*pf2)(2, 3);//int ret = pf2(2, 3);不用*也可以,但是用了*一定得加括号//int ret = *pf2(2, 3);这个就相当于*5printf("%d\n", ret);return 0;}

阅读两段有趣的代码:

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

(1)void(*)()是函数指针类型

(2)(类型)常量-强制类型转换-eg:int a=(int )3.14

(3)有颜色的就是将0强制类型转换为函数指针类型,这个0就变成了地址(地址),然后调用0地址处的函数,这个函数没有参数,返回值是void


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

这个代码是函数声明,声明的是signal函数,signal函数的参数有2个

一个是int 类型

一个是函数指针类型,该类型是void(*)(int)

该函数指针指向的函数,参数是int,返回类型是void

signal函数的返回类型也是函数指针类型,该类型是void(*)(int)

该函数指针指向的函数,参数是int,返回类型是void

【将这个代码简化】

typedef void(*pfun_t)( int );//也就是将void(*)(int)改给名字叫pfun_t

pfun_t signal(int ,pfun_t);


本次内容就到此啦,欢迎评论区或者私信交流,觉得笔者写的还可以,或者自己有些许收获的,麻烦铁汁们动动小手,给俺来个一键三连,万分感谢 !