深入了解指针

晚风相伴

已于 2023-11-05 11:10:29 修改

阅读量660

点赞数 5

分类专栏：笔记文章标签： c语言

于 2022-03-23 23:20:29 首次发布

本文链接：https://blog.csdn.net/m0_62537611/article/details/123461110

版权

笔记专栏收录该内容

12 篇文章 0 订阅

订阅专栏

文章目录

1、字符指针

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

一般使用：

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

还有一种使用方式如下：

#include <stdio.h>
int main()
{
const char* pstr="hello bit";//这里是把字符串 hello bit. 首字符的地址放到了pstr中。
                             //并不是把这个字符串放到pstr变量中。
printf("%s\n",pstr);
return 0;
}

上面代码的意思是把一个常量字符串的首字符 h 的地址存放到指针变量 pstr 中。
知道了这个下面就让我们分析一个题目：

#include <stdio.h>
int main()
{
char str1[] = "hello world.";
char str2[] = "hello world.";
const char *str3 = "hello world.";
const char *str4 = "hello world.";
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不同。

2、数组指针

2.1数组指针的定义

数组指针其实还是指针，并且是指向数组的指针。

那数组指针如何写呢？

int* p1[10]

int(*p2)[10]

//哪种写法是对的呢？

解释：

一定要擦亮眼睛看清楚，不要写错数组指针了呦。

2.2&数组名和数组名

对于下面的数组

int arr[10];

arr和&arr有什么区别？

我们知道arr是数组名，数组名表示的是首元素的地址。

那么&arr到底是个啥？让我们先看一下下面这个代码

代码结果如下：

是不是感觉没啥区别，别急你在看看下面这个代码：

代码结果如下：

这是不是就有区别了，那么为什么是这个结果呢？

这里我们不难看出009EE6C4和009EE6EC相差40。

实际上：&arr是整个数组的地址，而不是数组首元素的地址，上面代码中的&arr的类型是

int（*）[10],是一种数组指针的类型，而数组+1跳过的是整个数组的大小，所以&arr+1 相对于 &arr 的差值是40。

数组名该怎么理解呢？

通常情况下我们说的数组名是首元素的地址，但是两个例外：

1、sizeof（数组名），这里的数组名表示整个数组，而sizeof计算的是整个数组的大小。

2、&数组名，这里的数组名表示的整个数组，&数组名，取出的整个数组的地址。

好了，这里是不是明白了。如果明白了就继续了。

2.3数组指针的使用

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

废话不多说，直接上代码。

写一个函数打印arr数组里的元素。

//形参写成指针的形式
#include <stdio.h>
void print(int* arr ,int sz)
{
	int i = 0;
	for (i = 0; i < sz; i++)
	{
		printf("%d ", *(arr + i));
	}
	printf("\n");
}
int main()
{
	int arr[10] = { 1,2,3,4,5,6,7,8,9,10 };
	int sz = sizeof(arr) / sizeof(arr[0]);
	print(arr, sz);
	return 0;
}

//形参写成数组指针的形式
#include <stdio.h>
void print(int(*p)[10], int sz)
{
	int i = 0;
	for (i = 0; i < sz; i++)
	{
		//*p相当于数组名，而数组名有是首元素的地址，因此*p就是arr[0].
		printf("%d ", *(*p + i));
	}
	printf("\n");
}
int main()
{
	int arr[10] = { 1,2,3,4,5,6,7,8,9,10 };
	int sz = sizeof(arr) / sizeof(arr[0]);
	print(&arr, sz);
	return 0;

这种写法不推荐写，因为感觉太别扭了，复杂化了，多此一举了。二维数组中我们才会真正用到数组指针。

举例：

#include <stdio.h>
void print(int(*p)[4], int c, int r)
{
	int i = 0;
	for (i = 0; i < c; i++)
	{
		int j = 0;
		for (j = 0; j < r; j++)
		{
			//p+i是指向了第i行
			//*(p+i)相当于拿到了第i行，也相当于第i行的数组名
			//数组名是首元素的地址，*(p+i)就是第i行第一个元素的地址
			printf("%d ", *(*(p + i) + j));
		}
		printf("\n");
	}
}
int main()
{
	int arr[3][4] = { {1,2,3,4},{2,3,4,5},{3,4,5,6} };
	print(arr, 3, 4);
	return 0;
}

这里讲完了，那么一下这些代码的意思你都知道了吗

int arr[5]

arr是一个整形数组，每个元素是int类型，有五个元素

int *(parr)[10]

parr是一个数组，数组10个元素，每个元素的类型是int*

int (*parr2)[10]

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

int (*parr3[10])[5];
parr3是一个数组，数组有10个元素，每个元素的类型是int(*)[5]

parr3是存放数组指针的数组

3、数组参数、指针参数

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

3.1一维数组传参

#include <stdio.h>
//形参写成数组的形式
void test(int arr[])
{}
void test(int arr[10])//当然[]里面的数字填或者不填都没有什么影响
{}
void test(int arr[100])//当然这里把[]的数字填错虽然没错，但是不建议这样写
//形参写成指针的形式
void test(int* arr)
{}


void test2(int* arr[20])
{}
void test2(int* arr[])
{}
//写成二级指针的形式
void test2(int** arr)
{}
int main()
{
	int arr[10] = { 0 };
	int* arr2[20] = { 0 };
	test(arr);
	test2(arr2);
	return 0;
}

以上写法都行。

3.2二维数组传参

#include <stdio.h>
//形参写成数组的形式
void test(int arr[3][5])
{}
void test(int arr[][5])
{}
void test(int arr[][])//这种写法就是错误的
{}
//总结：二维数组传参，函数形参的设计只能省略第一个[]的数字。
//因为对一个二维数组，可以不知道有多少行，但是必须知道一行多少元素。
//这样才方便运算

//形参写成指针的形式
void test(int (*arr)[5])
{}
void test(int** arr)//这种写法是错误的，二级指针是用来存放一级指针的地址的
{}
void test(int* arr[5])//这种写法也是错误的，这里写成了指针数组的形式
{}
int main()
{
	int arr[3][5] = { 0 };
	test(arr);
	return 0;
}

3.3一级指针传参

#include <stdio.h>
void print(int* ptr, int sz)
{
	int i = 0;
	for (i = 0; i < sz; i++)
	{
		printf("%d ", *ptr);
		ptr++;
	}
}
int main()
{
	int arr[] = { 1,2,3,4,5,6,7,8,9,10};
	int* p = arr;
	int sz = sizeof(arr) / sizeof(arr[0]);
	print(p, sz);//一级指针传参
	return 0;
}

知道了这些，那么思考一下：

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

例如：一个一维数组或者一个变量的地址等。

3.4二级指针传参

#include <stdio.h>
void test(int** ppa)
{

}
int main()
{
	int n = 10;
	int* p = &n;
	int** pp = &p;//用二级指针来存放一级指针的地址
	test(pp);//这里传个二级指针当然是可以的啦
	test(&p);//传个一级指针的地址用二级指针来接收当然也是可以的啦
	return 0;

}

思考：

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

二维数组吗？ no no no!当然是不行的啦。(二维数组参数写成这样才行int (*p)[]）。
#include <stdio.h>
void test(char** ppc)
{ }
int main()
{
	char c = 'b';
	char* pc = &c;
	char** ppc = &pc;
	char* arr[10];
	test(&pc);
	test(ppc);
	test(arr);
	return 0;
}
以上这些才是可以的。

4、函数指针

函数指针即指向函数的指针

看下面的代码：

运行结果：

输出的是这两个地址，这两个地址其实就是test函数的地址，由此可以看出test和&test的意义是一样的。

那我们该如何将函数的地址保存起来呢？下面看代码

我们现在知道了函数指针，那么函数指针该如何使用呢？

这两种写法的结果都一样，其实pf前面那个*是没有意义的，你加不加都无所谓。类比一下数组指针，上面例子中函数指针的类型就应该是int(*)(int,int)。

这里看懂的话，就继续往下吧。

下面有两段有趣的代码，让我们分析分析。

代码2太复杂了，我们可以作如下的简化：

typedef void(*pf_t)(int);//给函数指针void(*)(int)类型重新起名为pf_t
pf_t signal(int, pf_t);//这样是不是就好看多了

5.函数指针数组

#include <stdio.h>
int Add(int x, int y)
{
	return x + y;
}
int Sub(int x, int y)
{
	return x - y;
}
int Mul(int x, int y)
{
	return x * y;
}
int Div(int x, int y)
{
	return x / y;
}
int main()
{
	int (*pf[4])(int, int) = { Add,Sub,Mul,Div };//函数指针数组
	int i = 0;
	for (i = 0; i < 4; i++)
	{
		int ret = pf[i](8, 4);
		printf("%d\n", ret);
	}
	return 0;
}

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

例：（计算器）

#include <stdio.h>
int Add(int x, int y)
{
	return x + y;
}
int Sub(int x, int y)
{
	return x - y;
}
int Mul(int x, int y)
{
	return x * y;
}
int Div(int x, int y)
{
	return x / y;
}
void menu()
{
	printf("***************************\n");
	printf("****  1.加法   2.减法  ****\n");
	printf("****  3.乘法   4除法   ****\n");
	printf("****  0.退出           ****\n");
	printf("***************************\n");
}
int main()
{
	int input = 0;
	int x = 0;
	int y = 0;
	int ret = 0;

	do
	{
		menu();
		printf("请选择:>");
		scanf("%d", &input);
		switch (input)
		{
		case 1:
			printf("请输入2个操作数:>");
			scanf("%d%d", &x, &y);
			ret = Add(x, y);
			printf("ret = %d\n", ret);
			break;
		case 2:
			printf("请输入2个操作数:>");
			scanf("%d %d", &x, &y);
			ret = Sub(x, y);
			printf("ret = %d\n", ret);
			break;
		case 3:
			printf("请输入2个操作数:>");
			scanf("%d %d", &x, &y);
			ret = Mul(x, y);
			printf("ret = %d\n", ret);
			break;
		case 4:
			printf("请输入2个操作数:>");
			scanf("%d %d", &x, &y);
			ret = Div(x, y);
			printf("ret = %d\n", ret);
			break;
		case 0:
			printf("退出计算器\n");
			break;
		default:
			printf("选择错误\n");
			break;
		}
	} while (input);

	return 0;
}

这里是用switch-case语句写的，但是还不够好，代码有些冗余。

#include <stdio.h>
int Add(int x, int y)
{
	return x + y;
}
int Sub(int x, int y)
{
	return x - y;
}
int Mul(int x, int y)
{
	return x * y;
}
int Div(int x, int y)
{
	return x / y;
}

void menu()
{
	printf("***************************\n");
	printf("****  1.加法   2.减法  ****\n");
	printf("****  3.乘法   4除法   ****\n");
	printf("****  0.退出           ****\n");
	printf("***************************\n");
}
int main()
{
	int input = 0;
	int x = 0;
	int y = 0;
	int ret = 0;
	int (*pf[5])(int, int) = { 0,Add,Sub,Mul,Div };
	do
			{
				menu();
				printf("请选择:>");
				scanf("%d", &input);
				if (input == 0)
				{
					printf("退出计算器\n");
				}
				else if(input >= 1 && input<=4)
				{
					printf("请输入2个操作数:>");
					scanf("%d %d", &x, &y);	
					ret = pf[input](x, y);
					printf("ret = %d\n", ret);
				}
				else
				{
					printf("选择错误\n");
				}
		
			} while (input);
	return 0;
}

这里写成函数指针数组的形式是不是好多了，减少了代码量。

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

指向函数指针数组的指针是一个指针，指针指向数组，数组的每个元素都是函数指针类型。

7、回调函数

回调函数就是一个通过函数指针调用的函数。如果你把函数的指针（地址）作为参数传递给另一个函数，当这个指针被用来调用其所指向的函数时，我们就说这是回调函数。回调函数不是由该函数的实现方直接调用，而是在特定的事件或条件发生时由另外的一方调用的，用于对该事件或条件进行响应

话不多说直接上代码

#include <stdio.h>
int Add(int x, int y)
{
	return x + y;
}
int Sub(int x, int y)
{
	return x - y;
}
int Mul(int x, int y)
{
	return x * y;
}
int Div(int x, int y)
{
	return x / y;
}
void menu()
{
	printf("***************************\n");
	printf("****  1.加法   2.减法  ****\n");
	printf("****  3.乘法   4除法   ****\n");
	printf("****  0.退出           ****\n");
	printf("***************************\n");
}
void print(int (*pf)(int, int))//接收函数地址
{
	int x = 0;
	int y = 0;
	int ret = 0;
	printf("请输入2个操作数:>");
	scanf("%d%d", &x, &y);
	ret = pf(x, y);//回调函数，用来调用加减乘除函数
	printf("ret=%d\n", ret);
}
int main()
{
	int input = 0;
	do
	{
		menu();
		printf("请选择:>");
		scanf("%d", &input);
		switch (input)
		{
		case 1:
			print(Add);//将函数地址传过去，再用一个函数指针来接收
			break;
		case 2:
			print(Sub);
			break;
		case 3:
			print(Mul);
			break;
		case 4:
			print(Div);
			break;
		case 0:
			printf("退出计算器\n");
			break;
		default:
			printf("选择错误\n");
			break;
		}
	} while (input);

	return 0;
}

这里将上面switch-case语句用回调函数改装了一下，变得不那么冗余了。

案例2：使用回调函数模拟实现qsort函数

qsort是一个库函数，是基于快速排序算法实现的一个排序函数。

void qsort(void*base,//待排序数据的起始位置
           size_t num //数组的元素个数
           size_t width  //一个元素的字节大小
       int(*cmp)(const void*e1,const void*e2));//函数指针，cmp是比较函数，e1和e2是带比较的个元素的地址

qsort函数的返回值是

对于qsort函数的使用者来说，要自定义一个比较函数。

看代码：

#include <stdio.h>
#include <string.h>
#include <stdlib.h>
struct stu
{
	char name[20];
	int age;
	int num;
};
int cmp_stu_by_name(const void* e1, const void* e2)
{
	return strcmp(((struct stu*)e1)->name,((struct stu*)e2)->name);
}
void test()
{
	struct stu arr[3] = {{"zhangsan",19,12},{"lisi",21,114},{"wangwu",22,16}};
	int sz = sizeof(arr) / sizeof(arr[0]);
	qsort(arr, sz, sizeof(arr[0]),cmp_stu_by_name);
	int i = 0;
	for (i = 0; i < 3; i++)
	{
		printf("%s ", arr[i].name);
	}
}
int main()
{
	test();
	return 0;
}

如果要模拟这个qsort函数的话可以看我之前写的《冒泡排序升级版》，里面将冒泡排序改良来一下模拟实现了qsort函数。

好了，本章完！

晚风相伴

关注

5
点赞
踩
3

收藏

觉得还不错? 一键收藏
1
评论
深入了解指针

文章目录1、字符指针2、数组指针3、指针数组4、数组传参和指针传参5、函数指针6、函数指针数组7、指向函数指针数组的指针8、回调函数1、字符指针在指针的类型中我们知道有一种指针类型为字符指针char*一般使用：#include <stdio.h>int main(){char ch='w';char* pc=&ch;*pc='w';return 0;}还有一种使用方式如下：#include <stdio
复制链接

扫一扫