【C进阶】指针

最新推荐文章于 2024-08-08 19:15:10 发布

Zzt.opkk

最新推荐文章于 2024-08-08 19:15:10 发布

阅读量98

点赞数

分类专栏： C进阶文章标签： c语言开发语言后端

本文链接：https://blog.csdn.net/weixin_61543874/article/details/122275780

版权

C进阶专栏收录该内容

9 篇文章 0 订阅

订阅专栏

指针

楔子
字符指针
指针数组
数组指针
数组参数，指针参数
回调函数

楔子

在文章开始前，我们先复习一下什么是指针：

指针实际上是一个变量，是用来存储地址的。
指针的大小为4/8字节(32位/64位)。
指针也是有类型的，它决定了在加减操作中所移动的步长。

字符指针

字符指针，顾名思义是一个指向字符的指针，我们可以通过*p间接修改ch中的内容。

int main()
{
	char ch = 'W';
	char* p = &ch;//p中存放的是ch的地址
	*p = 'T';
	char *p1 = "abcdef"//p1存放的是“abcdef”字符串的首元素地址
	return 0;
}

那如果是一个字符串呢？C语言是没有字符串类型的，但我们可以通过字符数组来存放它，例如：

int main ()
{
	char *str = "abcdef";//该字符串是存放在字符常量区，str是一个字符指针变量，里面存放的是字符串的首元素地址
	*str = "qwe";//对指针解引用就找到了其地址所指向的内容(即“abcdef”)，又因为常量不可以被赋值，所以这个赋值是错误的。
}

那么我们再来看看用这种方式存储的和以数组方式存储的区别

int main()
{
	char str1[] = "hello";
	char str2[] = "hello";
	const char* str3 = "hello";
	const char* str4 = "hello";
	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中内容是相同的，但是在压栈时顺序不同，导致其存放的地址不同，而数组名是首元素地址所以不同，而“hello”是在字符常量区，str3和str4都是指向其首元素地址所以相同

指针数组

存放指针的数组，其基类型为指针

int *arr[3]定义了一个指针数组，里面元素类型为int *[]，一共有3个。
使用方法：

int main()
{
	int arr1[3] = { 1,2,3 };
	int arr2[3] = { 4,5,6 };
	int arr3[3] = { 7,8,9 };
	int* arr[3] = { arr1,arr2,arr3 };
	printf("%d\n", *(*(arr + 0) + 2));//输出3
	printf("%d\n", *(*(arr + 1) + 2));//输出6
	printf("%d\n", *(*(arr + 2) + 2));//输出9
	return 0;
}

char*arr[4]定义一个指针数组，里面元素类型为char *[]，一共有3个.
使用方法

int main()
{
	char* arr[4] = { "zheng","xin","shong","jiu" };
	printf("%c\n", arr[0][1]);//我们可以通过访问数组下标的方式来访问
	printf("%c\n", arr[1][1]);
	printf("%c\n", arr[2][1]);
	return 0;
}

数组指针

数组指针本质是指针，我们知道int *pint为整形指针，char *pchar为字符指针，那么int (*p)[3]为数组指针。

我们先通过一段代码来认识：

int main ()
{
	int arr[5] = {0};
	printf("%p\n",arr);
	printf("%p\n",&arr);
	printf("%p\n",&arr[0]);//三者的结果完全相同，但是它们真的相同吗？我们在看一段代码
	return 0;
}

int main()
{
	int arr[10] = { 0 };

	printf("arr = %p\n", arr);
	printf("arr+1 = %p\n", arr + 1);//arr是首元素地址，类型为int*，加1实际上是加上前类型的大小，所以指向下一个元素的地址。

	printf("&arr= %p\n", &arr);
	printf("&arr+1= %p\n", &arr + 1);//&arr是整个数组的地址，类型为int*[]，同上，指向下一个数组首元素。
	return 0;
}

如何使用数组指针？

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

这个是一维数组，如果是二维数组呢？

void print(int(*p)[4], int row, int col)
{
	for (int i = 0;i < row; i++)
	{
		for (int j = 0;j < col;j++)
		{
			printf("%d ", *((*p + i) + j));
			//首先(*p + i)我们拿到的是二维数组的第i行，实际上就是第i行的地址
			//然后加j就是访问第i行数组中的第j个元素
	}
}
int main()
{
	int arr[3][4] = { {1,2,3,4},{2,3,4,5},{4,5,6,7} };
	print(arr, 3, 4);
	return 0;
}

int arr[5];
arr是一个整型数组，有5个元素，每个元素是int类型的
int * parr1[10];
parr是一个数组，数组有10个元素，每个元素的类型是int *，所以parr1是指针数组。
int ( * parr2)[10];
parr2和 * 结合，说明parr2是一个指针，该指针指向一个数组，数组是10个元素，每个元素是int类型的。所以它是数组指针.
int ( * parr3[10])[5];
parr3和[]结合，说明parr3是一个数组，数组是10个元素
数组的每个元素是什么类型呢?是一种数组指针，类型是int(*)[5]该类型的指针指向的数组有5个int类型的元素。

数组参数，指针参数

一维数组传参

void test(int arr[])//以数组形式传参，数组形式接受参数是🆗
{}
void test(int arr[10])//[]里面的数字不会影响，同上
{}
void test(int* arr)//数组名基类型是int* ，二者类型相同可以接受
{}
void test2(int* arr[20])//以指针数组形式传参，接受方式相同是🆗
{}
void test2(int** arr)//指针数组里面的元素为指针(即int*)，所以以数组名传参其基类型为int**，所以🆗
{}
int main()
{
	int arr[10] = { 0 };
	int* arr2[20] = { 0 };
	test(arr);
	test2(arr2);
}

总结： 传参看前后要确保其基类型是否相同

二维数组传参

	void test(int arr[3][5])
	{}
	void test(int arr[][])
	{}
	void test(int arr[][5])
	{}
	//总结：二维数组传参，函数形参的设计只能省略第一个[]的数字。
	//因为对一个二维数组，可以不知道有多少行，但是必须知道一行多少元素。
	void test(int* arr)
	{}
	void test(int* arr[5])
	{}
	void test(int(*arr)[5])
	{}
	void test(int** arr)
	{}
	//总结 arr的基类型为int(*)[],第一，第二为int*，第四为int**，只有第三其基类型相同；
	int main()
	{
		int arr[3][5] = { 0 };
		test(arr);
	}

一级指针传参

void test(int* p)
{}
int main()
{
	int a = 10;
	int* ptr = &a;
	int arr[10] = {0};
	test(&a);
	test(ptr);
	test(arr);
	return 0;
}

注：arr[i] == *(arr+i) == p[i] == *(p+i);访问方式相同

总结： 保证形参与实参类型相同

二级指针传参

void test(char** p)
{}
int main()
{
	char ch = 'w';
	char* p = &ch;
	char** pp = &p;
	char* arr[5];

	test(&p);
	test(pp);
	test(arr);

	return 0;
}

函数指针

在数组中数组名为首元素地址，那么函数名是不是也是其地址呢？

int Add(int x, int y)
{
	return x + y;
}
int main()
{
	printf("%p\n", Add);
	printf("%p\n", &Add);
	return 0;
}

输出的地址是相同的，那么我们就可以把函数地址存放在指针中，比如上面的Add函数的声明为int (*pAdd)(int,int)= &Add*先与pAdd结合表明是一个指针，返回类型为int，函数参数类型为两个int类型参数。

那么我们怎么使用它呢？例如：int sum = (*pAdd)(2，3)

注：这里我们省略某些部分，比如
int (* pf)(int, int) = &Add <==> int (* pf)(int, int) = Add,
int sum = (*pf)(2,3) <==> int sum = pf(2, 3)
这里的& 和* 可以省略，不影响使用。

在《C陷阱和缺陷》有两段关于函数指针的代码：

( *( void (*)() )0 )()
我们一层一层的分析，首先把0强制类型转换为void (*)()类型的函数指针，再去调用0地址处这个参数为无参，返回类型是void的函数。
void ( *signal( int, void(*)(int) ) )(int)
首先void( * )(int) 该函数指针和int作为参数，传给signal函数，剩余的部分为void ( * )(int)，表明它是一个返回类型为函数指针的函数。
我们可以用typedef来重定义

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

函数指针数组

函数指针数组-存放函数指针的数组，每个元素都是函数指针类型
比如我们写一个简单的计算器：

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. add     2. sub     *****\n");
	printf("*****  3. mul     4. div     *****\n");
	printf("*****  0. exit               *****\n");
	printf("**********************************\n");
}

int main()
{
	int input = 0;
	int x = 0;
	int y = 0;
	int ret = 0;

	int (*pfArr[5])(int, int) = { 0, Add, Sub, Mul, Div };//pfArr是一个函数指针的数组，也叫转移表

	do
	{
		menu();
		printf("请选择:>");
		scanf("%d", &input);
		if (input == 0)
		{
			printf("退出计算器\n");
			break;
		}
		else if (input >= 1 && input <= 4)
		{
			printf("输入2个操作数:>");
			scanf("%d %d", &x, &y);
			ret = pfArr[input](x, y);
			printf("ret = %d\n", ret);
		}
		else
		{
			printf("选择错误\n");
		}
	} while (input);

	return 0;
}

回调函数

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

qsort函数中的cmp函数即为回调函数，这里我们用冒泡排序的思想来实现

#include<stdlib.h>
#include<string.h>
struct Stu
{
	char name[20];
	float score;
	int age;
};
void print(struct Stu arr[], int len)
{
	for (int i = 0; i < len; i++)
	{
		printf("%-5s %.3f %d\n", arr[i].name, arr[i].score, arr[i].age);
	}
}
int cmp_name(const void* e1, const void* e2)
{
	return strcmp(((struct Stu*)e1)->name, ((struct Stu*)e2)->name);
}
int cmp_age(const void* e1, const void* e2)
{
	return ((struct Stu*)e1)->age - ((struct Stu*)e2)->age;
}
int cmp_score(const void* e1, const void* e2)
{
	if (((struct Stu*)e1)->score > ((struct Stu*)e2)->score)
		return 1;
	else if (((struct Stu*)e1)->score < ((struct Stu*)e2)->score)
		return -1;
	else
		return 0;
}
void Swap(char* buf1, char* buf2, int width)
{
	for (int i = 0;i < width;i++)
	{
		char tmp = *buf1;
		*buf1 = *buf2;
		*buf2 = tmp;
		buf1++;
		buf2++;
	}
}
void My_qsort(void* base, int sz, int width, int(*cmp)(const void* e1, const void* e2))
{
	for (int i = 0;i < sz - 1;i++)
	{
		for (int j = 0;j < sz - i - 1;j++)
		{
			if (cmp((char*)base + j * width, (char*)base + (j + 1) * width) > 0)
			{
				Swap((char*)base + j * width, (char*)base + (j + 1) * width, width);
			}
		}
	}
}
int main()
{
	struct Stu arr[] = { {"zhang",81.2f,20},{"ning",90.2f,32},{"shang",76.2f,45} };
	int len = sizeof(arr) / sizeof(arr[0]);
	My_qsort(arr, len, sizeof(struct Stu), cmp_name);
	//My_qsort(arr, len, sizeof(struct Stu), cmp_score);
	//My_qsort(arr, len, sizeof(struct Stu), cmp_age);
	print(arr, len);
	return 0;
}