指针进阶（1）

waves浪游2023-10-28 11:09

文章目录

  • 目录
    • [1. 字符指针](#1. 字符指针)
    • [2. 指针数组](#2. 指针数组)
    • [3. 数组指针](#3. 数组指针)
      • [3.1 数组指针的定义](#3.1 数组指针的定义)
      • [3.2 &数组名VS数组名](#3.2 &数组名VS数组名)
      • [3.3 数组指针的使用](#3.3 数组指针的使用)
    • [4. 数组参数、指针参数](#4. 数组参数、指针参数)
      • [4.1 一维数组传参](#4.1 一维数组传参)
      • [4.2 二维数组传参](#4.2 二维数组传参)
      • [4.3 一级指针传参](#4.3 一级指针传参)
      • [4.4 二级指针传参](#4.4 二级指针传参)
    • [5. 函数指针](#5. 函数指针)

目录

  • 字符指针
  • 数组指针
  • 指针数组
  • 数组传参和指针传参
  • 函数指针
  • 函数指针数组
  • 指向函数指针数组的指针
  • 回调函数
  • 指针和数组面试题的解析

1. 字符指针

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

一般是这样使用:

c 复制代码 
int main()
{
	char ch = 'w';
	//ch = 'a';

	char* pc = &ch;//pc就是字符指针
	*pc = 'a';

	return 0;
}

还有一种使用方式如下：

c 复制代码 
#include <stdio.h>

int main()
{
	char arr[] = "abcdef";
	//[a b c d e f \0]

	const char* p = "abcdef";//常量字符串
	printf("%s\n", p);//abcdef
	printf("%c\n", *p);//a
	
	return 0;
}

代码 const char* p = "abcdef"; 并不是把字符串 abcdef 放到字符指针 p 里去，而是把字符串 abcdef 首字符的地址 放到 p 中去；同时，因为 abcdef 是一个常量字符串 ，所以要用 const 进行修饰，以保证 p 中的内容不会被修改。

注：

不能被改变的常量的数据是放在代码区的，比如代码、常量字符串等等。

有这样一道面试题：

c 复制代码 
#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 和 str2 是两个不同的数组，所以 str1 和 str2 不相等；而常量字符串是不允许修改的 ，所以在内存中只需要存一份就可以了，又因为 str3 和 str4 中存的是字符串首字符的地址，所以 str3 和 str4 相等。

2. 指针数组

c 复制代码 
//指针数组
//整型数组 - 存放整型的数组
//字符数组 - 存放字符的数组
//指针数组 - 存放指针的数组

int main()
{
	int* arr[10];//存放整型指针的数组

	return 0;
}

使用指针数组模拟实现二维数组：

c 复制代码 
#include <stdio.h>

int main()
{
	int arr1[] = { 1, 2, 3, 4, 5 };//arr1 - int*
	int arr2[] = { 2, 3, 4, 5, 6 };
	int arr3[] = { 3, 4, 5, 6, 7 };

	//指针数组
	int* arr[3] = { arr1, arr2, arr3 };

	int i = 0;

	for (i = 0; i < 3; i++)
	{
		int j = 0;

		for (j = 0; j < 5; j++)
		{
			printf("%d ", arr[i][j]);
		}

		printf("\n");
	}

	return 0;
}

3. 数组指针

3.1 数组指针的定义

通过类比：

整型指针：能够指向整型数据的指针

浮点型指针：能够指向浮点型数据的指针

我们可以得知：

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

3.2 &数组名VS数组名

c 复制代码 
//数组名的理解
//数组名是数组首元素的地址
//有2个例外：
//1. sizeof(数组名)，这里的数组名不是数组首元素的地址，数组名表示整个数组，sizeof(数组名)计算的是整个数组的大小，单位是字节
//2. &数组名，这里的数组名表示整个数组，&数组名取出的是整个数组的地址
//除此之外，所有的地方的数组名都是数组首元素的地址

#include <stdio.h>

int main()
{
	int arr[10] = { 0 };
	printf("%p\n", arr);
	printf("%p\n", &arr[0]);

	return 0;
}
c 复制代码 
#include <stdio.h>

int main()
{
	int arr[10] = { 0 };
	printf("%p\n", arr);
	printf("%d\n", sizeof(arr));

	return 0;
}
c 复制代码 
#include <stdio.h>

int main()
{
	int arr[10] = { 0 };
	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);

	return 0;
}
c 复制代码 
//对于数组名来说
//&数组名得到的是数组的地址

int main()
{
	int arr[10] = { 1, 2, 3, 4, 5, 6, 7, 8, 9, 10 };
	int (*p)[10] = &arr;//数组的地址，存储到数组指针变量
	//解释：p先和*结合，说明p是一个指针变量，然后指针指向的是一个大小为10个整型的数组，所以p是一个指针，指向一个数组，叫数组指针。
	//这里要注意：[]的优先级要高于*号的，所以必须加上（）来保证p先和*结合。
	
	return 0;
}

3.3 数组指针的使用

打印数组中的每个元素：

c 复制代码 
#include <stdio.h>

int main()
{
	int arr[10] = { 1, 2, 3, 4, 5, 6, 7, 8, 9, 10 };
	int* p = arr;
	int i = 0;

	for (i = 0; i < 10; i++)
	{
		printf("%d ", *(p + i));
	}

	return 0;
}

也可以通过数组指针来实现：

c 复制代码 
#include <stdio.h>

int main()
{
	int arr[10] = { 1, 2, 3, 4, 5, 6, 7, 8, 9, 10 };
	int (*p)[10] = &arr;//*&arr --> arr
	int i = 0;

	for (i = 0; i < 10; i++)
	{
		//printf("%d ", *((*p) + i));
		printf("%d ", (*p)[i]);
	}

	return 0;
}

但是在这种情况下使用数组指针并不方便，那么数组指针怎么使用呢？

一般在二维数组上才方便

c 复制代码 
//1 2 3 4 5
//2 3 4 5 6
//3 4 5 6 7

//二维数组传参，形参是二维数组的形式

#include <stdio.h>

void Print(int arr[3][5], int r, int c)
{
	int i = 0;

	for (i = 0; i < r; i++)
	{
		int j = 0;

		for (j = 0; j < c; 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;
}
c 复制代码 
//二维数组传参，形参是指针的形式

#include <stdio.h>

void Print(int (*p)[5], int r, int c)
{
	int i = 0;

	for (i = 0; i < r; i++)
	{
		int j = 0;

		for (j = 0; j < c; 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);//arr是数组名，数组名表示数组首元素的地址；二维数组其实是一维数组的数组，所以数组名是第一个一维数组的地址

	return 0;
}

学了指针数组和数组指针，我们来看看下面这行代码的意思：

c 复制代码 
int (*parr3[10])[5];

首先， parr3 和 [ ] 结合，说明 parr3 是一个数组，而数组中的每个元素是数组指针类型，每个元素指向一个有五个元素的整型数组；也就是说 parr3 这个数组里可以存10个 int (*)[5] 类型的数组指针。

4. 数组参数、指针参数

4.1 一维数组传参

c 复制代码 
#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);

	return 0;
}

4.2 二维数组传参

c 复制代码 
void test(int arr[3][5])//ok
{
}

void test(int arr[][])//err 形参部分，行可以省略，但是列不能省略。
{
}

void test(int arr[][5])//ok
{
}
//总结：二维数组传参，函数形参的设计只能省略第一个[]的数字。
//因为对一个二维数组，可以不知道有多少行，但是必须知道一行多少元素。
//这样才方便运算。

void test(int* arr)//err
{
}

void test(int* arr[5])//err 这里的形参是指针数组
{
}

void test(int (*arr)[5])//ok
{
}

void test(int** arr)//err
{
}

int main()
{
	int arr[3][5] = {0};
	test(arr);
	
	return 0;
}

总结：

c 复制代码 
//一维数组传参，形参的部分可以是数组，也可以是指针

void test1(int arr[5], int sz)
{

}

void test2(int* p, int sz)
{

}

int main()
{
	int arr[5] = { 0 };
	test1(arr, 5);
	test2(arr, 5);
	
	return 0;
}
c 复制代码 
//二维数组传参，形参的部分可以是数组，也可以是指针

void test3(char arr[3][5], int r, int c)
{

}

void test4(char(*p)[5], int r, int c)
{

}

int main()
{
	char arr[3][5] = { 0 };
	test3(arr, 3, 5);
	test4(arr, 3, 5);
	
	return 0;
}

4.3 一级指针传参

c 复制代码 
#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]);
	print(p, sz);
	
	return 0;
}

思考：

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

c 复制代码 
void test(char* p)
{
}

int main()
{
	char ch = '2';
	char* ptr = &ch;
	char arr[] = "abcdef";
	
	test(&ch);
	test(ptr);
	test(arr);
	
	return 0;
}

4.4 二级指针传参

c 复制代码 
#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;
}

思考：

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

c 复制代码 
void test(char** p)
{
}

int main()
{
	char n = 'a';
	char* p = &n;
	char** pp = &p;
	char* arr[5];
	
	test(&p);
	test(pp);
	test(arr);
	
	return 0;
}

5. 函数指针

c 复制代码 
//函数指针 - 指向函数的指针
//数组指针 - 指向数组的指针

#include <stdio.h>

int Add(int x, int y)
{
	return x + y;
}

int main()
{
	//int arr[10] = { 0 };
	//int (*pa)[10] = &arr;
	printf("%p\n", &Add);
	printf("%p\n", Add);
	//函数名是函数的地址
	//&函数名也是函数的地址

	int (*pf)(int, int) = &Add;//pf是函数指针变量
	//int (*)(int, int) 是函数指针类型

	return 0;
}

再举一个例子：

c 复制代码 
void test(char* pc, int arr[10])
{

}

int main()
{
	void (*pf)(char*, int[10]) = &test;
	void (*pf)(char*, int[10]) = test;
	void (*pf)(char*, int[]) = &test;
	void (*pf)(char*, int*) = &test;

	return 0;
}

那么，函数指针如何使用呢？

c 复制代码 
#include <stdio.h>

int Add(int x, int y)
{
	return x + y;
}

int main()
{
	//int (*pf)(int, int) = &Add;
	int (*pf)(int, int) = Add;
	
	int r = Add(3, 5);
	printf("%d\n", r);
	
	//int m = (*pf)(4, 5);
	int m = pf(4, 5);
	printf("%d\n", m);

	return 0;
}

以下是两段有趣的代码：

c 复制代码 
//0 - int
//0 - int*
//0x0012ff40 - int
//0x0012ff40 - int*

//void (*p)() - p是函数指针
//void (*)()是函数指针类型

int main()
{
	//调用0地址处的函数
	//1. 将0强制类型转换为void (*)() 类型的函数指针
	//2. 调用0地址处的这个函数
	(*(void (*)())0)();

	return 0;
}
c 复制代码 
int main()
{
	//signal 是一个函数声明
	//signal 函数有2个参数，第一个参数的类型是int，第二个参数的类型是 void(*)(int) 函数指针类型
	//该函数指针指向的函数有一个int类型的参数，返回类型是void
	//signal 函数的返回类型也是void(*)(int) 函数指针类型，该函数指针指向的函数有一个int类型的参数，返回类型是void
	void (*signal(int, void(*)(int)))(int);

	return 0;
}

第二段代码看上去非常复杂，应该如何简化呢？

我们先来看一下typedef的用法：

c 复制代码 
typedef unsigned int uint;
typedef int* ptr_t;

typedef int (*parr_t)[10];
typedef int (*pf_t)(int, int);

int main()
{
	uint u1;
	ptr_t p1;
	int* p2;
	
	return 0;
}

因此，我们可以这样进行简化：

c 复制代码 
int main()
{
	typedef void (*pf_t)(int);

	pf_t signal(int, pf_t);

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

	return 0;
}
相关推荐
逊嘘14 分钟前
【Java语言】抽象类与接口
java·开发语言·jvm
xinghuitunan15 分钟前
蓝桥杯顺子日期（填空题）
c语言·蓝桥杯
van叶～17 分钟前
算法妙妙屋-------1.递归的深邃回响：二叉树的奇妙剪枝
c++·算法
Half-up17 分钟前
C语言心型代码解析
c语言·开发语言
简简单单做算法18 分钟前
基于Retinex算法的图像去雾matlab仿真
算法·matlab·图像去雾·retinex
云卓SKYDROID32 分钟前
除草机器人算法以及技术详解！
算法·机器人·科普·高科技·云卓科技·算法技术
Source.Liu39 分钟前
【用Rust写CAD】第二章 第四节 函数
开发语言·rust
monkey_meng39 分钟前
【Rust中的迭代器】
开发语言·后端·rust
余衫马42 分钟前
Rust-Trait 特征编程
开发语言·后端·rust
monkey_meng1 小时前
【Rust中多线程同步机制】
开发语言·redis·后端·rust
热门推荐
01【HarmonyOS】HUAWEI DevEco Studio 下载地址汇总02(欧拉)openEuler系统添加网卡文件配置流程、(欧拉)openEuler系统手动配置ipv6地址流程、(欧拉)openEuler系统网络管理说明03组基轨迹建模 GBTM的介绍与实现（Stata 或 R）04【AIGC】重塑未来的科技巨轮05全面解析：构建基于深度学习的安全帽检测系统（UI界面+YOLO代码+数据集）06【经验分享】Ubuntu22.04安装微信(linux官方版)07基于YOLOv10深度学习的CT扫描图像肾结石智能检测系统【python源码+Pyqt5界面+数据集+训练代码】深度学习实战、目标检测08Ubuntu 20.04使用Livox mid 360 测试 FAST_LIO09RAG 实践- Ollama+RagFlow 部署本地知识库10红米手机使用google play