当前位置：首页 > news >正文

指针（一）【C语言进阶版】

news 文章来源：https://blog.csdn.net/qq_73017178/article/details/132181132 2025/4/5 2:25:32

大家好，我是深鱼~

【前言】：

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

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

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

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

4.指针的运算

一、字符指针

一般使用：

#include<stdio.h>
int main()
{char ch = 'w';char* pc = &ch;*pc = 'w';return 0;
}

还有一种使用方式如下：

#include<stdio.h>
int 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 <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 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 *）指针数组，并打印数组内的元素

#include<stdio.h>
int 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代表数组元素类型

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

代码运行结果:

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

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

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

#include<stdio.h>
void 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],就可以得到每行的数组元素

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

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

<2>parr1是一个数组，数组10个元素，，每个元素的类型都是int *

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

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

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

四、数组参数，指针参数

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

4.1一维数组传参

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

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

#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，数组的形式传参，可以省略数组的元素个数
{}
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);
}

二维数组传参：

<1>数组形式传参：只能省略行，不可省略列

<2>指针形式传参：参数形式应该是数组指针int （*arr）【列】，而不能是指针数组

4.3一级指针传参

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

一级指针传参形式参数写成一级指针就可以

【思考】：

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

（1）传一维数组的数组名

（2）传变量的地址

（3）传指针

4.4二级指针传参

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

二级指针传参形式参数写成二级指针或者一级指针的地址都可以

【思考】：

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

(1)一级指针的地址

(2)二级指针

(3)传指针数组（首元素的地址）

五、函数指针

类比：

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

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

#include<stdio.h>
int 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加和：

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