部分指针操作及详解

最新推荐文章于 2024-11-03 21:27:26 发布

wantEnndme

最新推荐文章于 2024-11-03 21:27:26 发布

阅读量817

点赞数 21

文章标签：算法

本文链接：https://blog.csdn.net/wantEnndme/article/details/136769271

版权

今天来介绍一下部分指针：

首先是字符指针，其实字符指针很简单，也很容易理解，参考下列代码：

int main()
{
	//字符指针
	char a = 's';
	char* ps = &a;
	*ps = 'w';
	//或者
	const char* ptr = "hello bit.";
	printf("%s\n", ptr);
	return 0;
}

这里我个人感觉没啥介绍和解释的，基本上一看代码就基本上可以理解了，整形指针、浮点型指针……等等都基本上很好理解的，只要去实践一下就基本上没问题了。

我们来看一段代码：

int main()
{
	char str1[] = "hello bit.";
	char str2[] = "hello bit.";
	char* str3 = "hello bit.";
	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，str3==str4 首先我们应该了解
对于str1和str2来说，它俩代表的就是首元素的地址，但是两个数组是在栈区上开辟的相当于各给一块空间来存放hello bit.空间的起始地址肯定不相同，所以str1！=str2。接着str3和str4两个指针都是开辟出来的，所以系统自动的给常量字符串分配了一块空间，常量字符串hello bit.其实就只有一份，因为来找到常量字符串hello bit.的时候它又不会发生改变，一份已经足够了，而既然都是一份，str3和str4代表的都是首元素h的地址，自然相等。

Ok接下来继续看例子：

int main()
{
	//数组指针：顾名思义是指针
	//整形指针：指向整形数据的指针
	//字符指针：指向字符数据的指针
	//那我们来判别一下下面的代码，那个是数组指针
	int* p[10];//指针数组
	int(*ps)[10];//数组指针

	return 0;
}

这里我给大家介绍了指针数组和数组指针的定义，大家记清楚了，如果遇到相关的题目快要会做哦！

继续看：

int main()
{
	int arr[10] = { 1,2,3,4,5,6,7,8,9,10 };
	int* p1 = arr;
	int* p2 = &arr;
	printf("%p\n", p1);
	printf("%p\n", p2);
	//p1=p2的，如此我们知道arr和&arr是相同的
	return 0;
}

这里你们可以自己去试一试，数组名绝大部分情况下是代表数组首元素的地址，但是有两个特别重要的点可要记清楚了，sizeof(arr)还有&arr这俩都是代表整个数组哦！如果不相信的话我们来看下面的代码：

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

我们来看输出结果：

我们看虽然arr和&arr打印出来的地址都是一样的但是，它们俩的不同代表了arr+1和&arr+1时跳过的字节，arr+1跳过四个字节，但是&arr+1可是跳过了28H=40个字节啊。所以千万记住它俩的区别。

Ok我们继续：

void print_s1(int arr[3][5], int row, int col)
{
	int i = 0;
	int j = 0;
	for (i = 0; i < row; i++)
	{
		for (j = 0; j < col; j++)
		{
			printf("%d ", arr[i][j]);
		}
	}
	printf("\n");
}

void print_s2(int (*p)[5], int row, int col)
{
	{
		int i = 0;
		int j = 0;
		for (i = 0; i < row; i++)
		{
			for (j = 0; j < col; j++)
			{
				printf("%d ", p[i][j]);
			}
		}
		printf("\n");
	}

}
int main()
{
	int arr[3][5] = { 1,2,3,4,5,6,7,8,9,10 };
	print_s1(arr, 3, 5);
	print_s2(arr, 3, 5);
	return 0;
}

我们学了数组指针之后，其实二位数组的传参可以利用数组指针解决，就像这里的代码一样，使用起来没有任何的问题。

那我们继续，接下来给大家介绍一个新的概念：函数指针，我们可以通过类比的方法可以推出函数指针就是指向函数的指针，我们学了之后怎么使用呢？我们还要继续类比，arr和&arr地址值是一样的，那我们就可以知道函数名和&函数名是一样的，例子：

void test1()
{
	printf("hehe\n");
}
int main()
{
	printf("%p\n", test1);
	printf("%p\n", &test1);
	return 0;
}

这俩打印结果完全一样，关于这个我们了解一下就基本上可以了，接下来我们继续来学习一个新的概念：

函数指针数组：顾名思义，首先是数组，存放函数地址的数组就是函数指针数组，废话少说，直接例子：

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");

}
int main()
{

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

	return 0;
}

这里我们可以看到，我简单实现了一个四则运算，但是我们观察一下，其实好像这个代码有好多重复的地方，也就是”代码冗余“，那我们能否简化一下呢？必然是可以的：

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");

}
int main()
{

	int x = 0;
	int y = 0;
	int input = 0;
	int ret = 0;
	int (*ps[5])(int, int) = { NULL,Add,Sub,Mul,Div };
	do
	{
		menu();
		printf("请选择：");
		scanf("%d", &input);
		if (0 == input)
		{
			printf("退出计算器\n");
			break;
		}
		else if (input >= 1 && input <= 4)
		{
			printf("请输入操作数：");
			scanf("%d %d", &x, &y);
			ret = (*ps[input])(x, y);
		}
		else
		{
			printf("输入错误，请重新输入：");
		}
		printf("%d\n", ret);
		
	} while (input);

	return 0;
}

对比效果出现，利用函数指针数组可以简化代码，这样子一看代码是不是少了很多，而且一样的可以实现四则运算：

接下来我继续介绍一个很重要的概念，

回调函数：

回调函数就是一个通过函数指针调用的函数。如果你把函数的指针（地址）作为参数传递给另一个

函数，当这个指针被用来调用其所指向的函数时，我们就说这是回调函数。回调函数不是由该函数

的实现方直接调用，而是在特定的事件或条件发生时由另外的一方调用的，用于对该事件或条件进

行响应。

废话少说，例子：

//回调函数的实例：A函数C=B(&A)

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 Calc(int (*ps)(int, int))
{
	int x, y;
	printf("请输入操作数：");
	scanf("%d %d", &x, &y);
	int ret = ps(x, y);
	printf("ret=%d\n", ret);
	
}
int main()
{
	int input = 0;
	do
	{
		menu();
		printf("请选择：");
		scanf("%d", &input);
		switch (input)
		{
		case 1:
			Calc(Add);
			break;
		case 2:
			Calc(Sub);
			break;
		case 3:
			Calc(Mul);
			break;
		case 4:
			Calc(Div);
			break;
		case 0:
			printf("退出计算器\n");
			break;
		default:
			printf("选择错误请重新选择\n");
			break;
		}
	} while (input);
	return 0;
}

这里就可以看出来回调函数的使用：函数A 函数C=B(&A)

最后我来介绍一下一个库函数的使用：qsort函数

void qsort(void* base,
size_t num, size_t size,
int (*compar)(const void*, const void*));

base 指明数组类型，因为不知道你会使用那种数组所以返回类型是void*
num 数组的大小
size 每个元素的大小是几个字节
(* compar)具体用法麻烦去cplusplus网站查询，我这里就不过多介绍了

不过在介绍qsort函数的使用之前，我们再来回顾一下冒泡排序：

void Bubble_sort(int arr[], int sz)
{
	int i = 0;
	int j = 0;
	for (i = 0; i < sz - 1; i++)
	{
		for (j = 0; j < sz - 1 - i; j++)
		{
			if (arr[j] > arr[j + 1])
			{
				int temp = arr[j];
				arr[j] = arr[j + 1];
				arr[j + 1] = temp;
			}
		}
	}
}
void print_arr(int arr[],int sz)
{
	int i = 0;
	for (i = 0; i < sz; i++)
	{
		printf("%d ", arr[i]);
	}
	printf("\n");
}
int main()
{
	int arr[10] = { 9,8,7,6,5,4,3,2,1,0 };
	int sz = sizeof(arr) / sizeof(arr[0]);
	print_arr(arr, sz);
	Bubble_sort(arr, sz);
	print_arr(arr,sz);
	return 0;
}

结果：

我们分析一下冒泡排序的缺点：

只能进行整形数据的比较，遇到其他类型根本不能用，所以开始介绍基本上算全能的qsort函数：

//直接上实例
//整形比较
int Cmp_int(const void* s1, const void* s2)
{
	return (*(int*)s1 - *(int*)s2);
}
void print_arr(int arr[],int sz)
{
	int i = 0;
	for (i = 0; i < sz; i++)
	{
		printf("%d ", arr[i]);
	}
	printf("\n");
}

int main()
{
	int arr[10] = { 9, 8, 7, 6, 5, 4, 3, 2, 1, 0 };
	int sz = sizeof(arr) / sizeof(arr[0]);
	qsort(arr, sz, sizeof(arr[0]), Cmp_int);
	print_arr(arr, sz);
	return 0;
}

结果：

接下来我们进行复杂类型的比较：

//复杂的类型比较
typedef struct Stu
{
	char arr[20];
	int age;
}Stu;

//可以按照年龄比，也可以按照字符串比
//按照年龄比较

int Cmp_Stu_int(const void* s1,const void* s2)
{
	return ((Stu*)s1)->age - ((Stu*)s2)->age;
}
int main()
{
	Stu s1[] = { {"zhangsan",30},{"lisi",15},{"wangwu",20} };
	int len = sizeof(s1) / sizeof(s1[0]);
	qsort(s1, len, sizeof(s1[0]), Cmp_Stu_int);
	return 0;
}

结果：

看到了吧，按照年龄顺序排列了。

继续：

typedef struct Stu
{
	char arr[20];
	int age;
}Stu;

int Cmp_Stu_char(const void* s1, const void* s2)
{
	return strcmp(((Stu*)s1)->arr, ((Stu*)s2)->arr);
}
int main()
{
	Stu s1[] = { {"zhangsan",30},{"lisi",15},{"wangwu",20} };
	int len = sizeof(s1) / sizeof(s1[0]);
	qsort(s1, len, sizeof(s1[0]), Cmp_Stu_char);

	return 0;
}

看结果：

这里就完成了名字的排序。

最后给大家介绍一下刚刚出现的void*s1

void* 类型的指针——不能进行解引用操作，也不能进行+-整数的操作

void* 类型的指针是用来存放任意类型数据的地址。

void* 无具体类型的指针

例子：

int main()
{
	char c = 'w';
	char* p = &c;
	int a = 100;
	int* ps = &a;
	void* s1 = ps;//或者
	void* sp;
	return 0;
	
}

这里不会报错，但是如果你不用void* 指针来进行操作的话，就比如你硬要把char*类型赋给的int*类型，编译器一定会出警告。

今天就写到这里……

wantEnndme

关注

21
点赞
踩
21

收藏

觉得还不错? 一键收藏
1
评论
复制链接

分享到 QQ

分享到新浪微博

扫一扫