【C进阶】指针（一）

曾经终败给现在 2023-10-14 16:26 14阅读 0赞

> **大家好，我是深鱼~**

**【前言】：**

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

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

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

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

4.指针的运算

--------------------

**【目录】**

一、字符指针

二、指针数组

三、数组指针

3.1数组指针的定义

3.2&数组名vs数组名

3.3数组指针的使用

四、数组参数，指针参数

4.1一维数组传参

4.2二维数组传参

4.3一级指针传参

4.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);//打印的是a
    	printf("%c\n", "abcdef"[3]);//打印的是d
    	return 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指向的地址**

![0c992d07d3974e759a449d373fb68a9d.jpeg][]

--------------------

### 二、指针数组 ###

> 指针数组是数组
> 
> 字符数组-存放字符的数组
> 
> 整形数组-存放整形的数组
> 
> 指针数组-存放指针的数组，存放在数组的元素都是指针类型的

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 \*指针类型，通过指针数组的打印可以模拟二维数组**

![70eacc63cf314a3c86b5a7ebc9e170b6.png][]

**【程序结果】：**

![e8e3f0601b354a82af1cc0c56b2e927c.png][]

--------------------

再举个栗子：建立一个字符类型（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;
    }

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

![68aa26b56e7046e18fd23fb1175b9a47.png][]

【程序结果】：

![350eba767c5540338fd29a8b7528106a.png][]

--------------------

###  **三、数组指针** ###

#### **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

代码运行结果:

![019653c1f312480581b14e01c788169b.png][]

--------------------

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

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

--------------------

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

#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个元素的数组

![85ef06c176e8484b8cad0424a61bc9c2.png][]

--------------------

### 四、数组参数，指针参数 ###

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

#### 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);这个就相当于*5
    	printf("%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**);

--------------------

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

![85950c950e614cd5a60c5a2a4096e1bd.jpeg][]

[0c992d07d3974e759a449d373fb68a9d.jpeg]: https://img-blog.csdnimg.cn/0c992d07d3974e759a449d373fb68a9d.jpeg
[70eacc63cf314a3c86b5a7ebc9e170b6.png]: https://img-blog.csdnimg.cn/70eacc63cf314a3c86b5a7ebc9e170b6.png
[e8e3f0601b354a82af1cc0c56b2e927c.png]: https://img-blog.csdnimg.cn/e8e3f0601b354a82af1cc0c56b2e927c.png
[68aa26b56e7046e18fd23fb1175b9a47.png]: https://img-blog.csdnimg.cn/68aa26b56e7046e18fd23fb1175b9a47.png
[350eba767c5540338fd29a8b7528106a.png]: https://img-blog.csdnimg.cn/350eba767c5540338fd29a8b7528106a.png
[019653c1f312480581b14e01c788169b.png]: https://img-blog.csdnimg.cn/019653c1f312480581b14e01c788169b.png
[85ef06c176e8484b8cad0424a61bc9c2.png]: https://img-blog.csdnimg.cn/85ef06c176e8484b8cad0424a61bc9c2.png
[85950c950e614cd5a60c5a2a4096e1bd.jpeg]: https://img-blog.csdnimg.cn/85950c950e614cd5a60c5a2a4096e1bd.jpeg