十四、指针（三）

最新推荐文章于 2024-07-25 01:51:24 发布
最新推荐文章于 2024-07-25 01:51:24 发布
阅读量102 收藏 12
点赞数 15
分类专栏： C语言笔记 文章标签： c语言 笔记
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/hackerkevon/article/details/133278274
版权

9 字符指针变量

用法一：用来指向字符。

int main()
{
	char ch = 'w';
	char* pc = &ch;
    //pc 就是字符指针变量
	*pc = 'w';
	return 0;
}

用法二：用来指向字符串。

int main()
{
	const char* p = "abcdefg";
	printf("%s\n", p);
	return 0;
}

输出结果：

外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传

事实上，p 里面存的还是首字符 a 的地址，只是因为字符串是连续存放的，所以给人一种指向的是整个字符串的错觉。

例：

#include <stdio.h>
int main()
{
	const char* p = "abcdefg";
	//不是将"abcdefg"字符串存放到p中，而是将首字符a的地址存在p中
	printf("%c\n", *p);
	return 0;
}

输出结果：

外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传

笔试题：下面代码输出的结果是什么？

#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;
}

输出结果：

外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传

C/C++会把常量字符串存储到单独的一个内存区域，当几个指针指向同一个字符串的时候，它们实际会指向同一块内存，但是用相同的常量字符串去初始化不同的数组的时候就会开辟出不同的内存块，所以 str3 和str4 指向的是同一个常量字符串，而 str1 和 str2 不是。

10 二级指针

指针变量也是变量，是变量就有地址，二级指针就用来存放指针变量的地址。

int a = 10;
int* pa = &a;
int** ppa = &pa;

对于二级指针的运算有：

• *ppa 通过对 ppa 中的地址进行解引用，这样找到的是 pa ，*ppa 其实访问的就是 pa。

• **ppa 先通过 *pa 找到 pa，然后对 pa 进行解引用操作从而找到 a。

例：

#include <stdio.h>
int main()
{
	int a = 10;
	int* pa = &a;
	int** ppa = &pa;
	**ppa = 30;
	printf("%d", **ppa);
	return 0;
}

输出结果：

外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传

11 指针数组

指针数组就是用来存放指针的数组。

指针数组指向的元素是地址，这个地址又指向一个区域。

外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传

11.1 指针数组模拟二维数组

例：

#include <stdio.h>
int main()
{
	int arr1[] = { 1,2,3,4,5 };
	int arr2[] = { 2,3,4,5,6 };
	int arr3[] = { 3,4,5,6,7 };
	int arr4[] = { 4,5,6,7,8 };
	int arr5[] = { 5,6,7,8,9 };
	//数组名是数组⾸元素的地址，类型是int*的，就可以存放在parr数组中
	int* parr[5] = { arr1, arr2, arr3,arr4,arr5 };
	int i = 0;
	int j = 0;
	for (i = 0; i < 5; i++)
	{
		for (j = 0; j < 5; j++)
		{
			printf("%d ", parr[i][j]);
            //parr[i]    == *(parr+i)
			//parr[i][j] == *(*(parr+i)+j)
		}
		printf("\n");
	}
	return 0;
}

输出结果：

外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传

外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传

parr[i] 就是访问 parr 数组中的元素，parr[i] 指向的数组元素指向了整型一维数组， parr[i][j]就是整型一维数组中的元素。

上述代码只是模拟出二维数组的效果，实际上并非完全是二维数组，因为每一行不是连续的。

12 数组指针变量

刚才我们知道指针数组是一种数组，数组中存放的是地址（指针）。

//语法
int arr[6];
int (*p1)[6] = &arr;

类比：

• 整形指针变量：存放的是整型变量的地址，能够指向整型数据。

• 浮点型指针变量：存放浮点型变量的地址，能够指向浮点型数据。

所以数组指针变量存放的应该是数组的地址，能够指向数组。

//指针数组和数组指针的定义方式
int *p1[10];//指针数组
int (*p2)[10];//数组指针

p2 先和 * 结合，说明 p2 是一个指针变量，然后指向的是一个大小为10的整型数组，所以 p2 是一个数组指针，指向一个数组。

注意：由于 [ ] 的优先级要高于 * ，所以必须加上 ( ) 来保证 p2 先和 * 结合。

数组指针类型解析：

int (*p) [10] = &arr;
 |    |    |
 |    |    |
 |    |    p指向数组的元素个数
 |    p是数组指针变量名
 p指向的数组的元素类型

例：

char* ch[8];//指针数组
char* (*p2)[8] = &ch;//*p2 是一个数组指针，指向一个大小为8，类型为 char* 的数组。

注意：在定义上面的数组指针时，容易把 char 后面的 * 忽略掉，如果忽略掉之后，指向的就是大小为8，类型为 char 的数组。

一个比较简单的判断指针类型的方法是，把指针名去掉，比如 char* (*p2)[8] ，去掉指针名 p2 后就是 char* (*)[8]，就是它的类型。

12.1 数组指针的初始化

用 &数组名 可以获得数组的地址，如果要存放这个数组的地址，就需要存放在数组指针变量中，如：

#include <stdio.h>
int main()
{
	int arr[10] = { 0 };
	int(*p)[10] = &arr;
	return 0;
}

调试：

外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传

从调试中也可以看到，&arr 和 p 的类型完全一致。

例：

#include <stdio.h>
void print1()
{
	int arr[10] = { 1,2,3,4,5,6,7,8,9,10 };
	int* p = arr;
	int i = 0;
	printf("用整型指针打印数组每一个元素：");
	for (i = 0; i < 10; i++)
	{
		printf("%d ", p[i]);
	}
	printf("\n");
}
void print2()
{
	int arr[10] = { 1,2,3,4,5,6,7,8,9,10 };
	int (*p)[10] = &arr;
	int i = 0;
	printf("用数组指针打印数组每一个元素：");
	for (i = 0; i < 10; i++)
	{
		printf("%d ", (*p)[i]);
	}
	printf("\n");
}
int main()
{
	print1();
	print2();
	return 0;
}

输出结果：

外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传

虽然数组指针也可以打印数组的元素，但在使用的时候不建议，容易出错。

12.2 二维数组传参的本质

要理解二维数组传参的本质，首先我们再来理解一下二维数组。二维数组本质上可以看作是每个元素是一维数组的数组，也就是说二维数组的每个元素是一个一维数组。那么二维数组的首元素就是第一行，是一个一维数组。

所以，根据数组名是数组首元素的地址这个规则，二维数组的数组名表示的就是第一行的地址，是一维数组的地址。根据图中的例子，第一行一维数组的类型就是 int [5]，所以第一行的地址类型就是数组指针类型 int (*)[5]。这就意味着二维数组传参本质上也是传递了地址，传递的是第一行一维数组的地址。

以往一个二维数组需要传参给一个函数时，我们是这样写的：

#include <stdio.h>
void test(int a[3][5], int r, int c)
{
	int i = 0;
	int j = 0;
	for (i = 0; i < r; i++)
	{
		for (j = 0; j < c; j++)
		{
			printf("%d ", a[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} };
	test(arr, 3, 5);
	return 0;
}

知道了二维数组传参的本质后，就可以这样写了：

#include <stdio.h>
void test(int(*p)[5], int r, int c)
{
	int i = 0;
	int j = 0;
	for (i = 0; i < r; i++)
	{
		for (j = 0; j < c; j++)
		{
			printf("%d ", *(*(p + i) + j));
            //      甚至写成(*(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} };
	test(arr, 3, 5);
	return 0;
}

输出结果：

外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传

结论：二维数组传参，形参的部分可以写成数组的形式，也可以写成指针形式。

13 函数指针变量

13.1 函数指针变量的创建

函数其实也有地址，有了地址，就可以创建指针来存储这个地址。

例：

//打印函数的地址
#include <stdio.h>
void test()
{
	printf("hehe\n");
}
int main()
{
	printf("test:  %p\n", test);
	printf("&test: %p\n", &test);
	return 0;
}

输出结果：

外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传

从输出结果可以看到，函数确实有地址，而函数名就是函数的地址，当然也可以通过 &函数名 的方式来获得函数的地址。这和数组有所区别，数组名是数组首元素的地址，而 &数组名 才是数组的地址。

如果要将函数的地址存放起来，就需要创建函数指针变量，创建函数指针后，后续就可以通过地址来调用函数。

例1：

void test()
{
 	printf("hehe\n");
}
void (*pf1)() = &test;
void (*pf2)() = test;

例2：

int Add(int x, int y)
{
 	return x+y;
}
int(*pf3)(int, int) = Add;
int(*pf3)(int x, int y) = &Add;//x和y写上或者省略都可以

函数指针类型解析：

int (*pf3) (int x, int y)
 |    |     ------------ 
 |    |           |
 |    |           pf3指向函数的参数类型和个数的交代
 |    函数指针变量名
 pf3指向函数的返回类型
 
int (*) (int x, int y) //pf3函数指针变量的类型

13.2 函数指针变量的使用

通过函数指针调用指针指向的函数：

#include <stdio.h>
int Add(int x, int y)
{
	return x + y;
}
int main()
{
	int(*pf3)(int, int) = Add;

	printf("%d\n", (*pf3)(2, 3));//事实上，不用解引用也可以
	printf("%d\n", pf3(2, 3));
	return 0;
}

输出结果：

外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传

特例1：下面这段代码是什么意思？

(*(void (*)())0)();

上述代码中，0是一个数字，类型为 int，而它前面的 void (*)() 是一个函数指针类型，而把一个类型放在一对括号里又是强制类型转换，所以 (void (*)())0 的意思就是把0强制转换为 void (*)() 类型，也就是把0当成 void (*)() 类型的地址。(*(void (*)())0)() 就是在调用0地址处的函数，这个函数没有参数，返回类型是 void。

特例2：下面这段代码是什么意思？

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

上述代码中，其实是一次函数声明，声明的 signal 函数有2个参数，第一个参数是 int 类型，第二个参数是函数指针类型，该函数指针指向的函数参数是 int 类型，返回类型是 void，signal 的返回类型也是一个函数指针，该函数指针指向的函数参数是 int，返回类型是void。

13.3 typedef关键字

typedef 用来给类型重命名，可以将复杂的类型简单化。

例：

typedef unsigned int uint;
//将 unsigned int 类型重命名为 uint
typedef int* ptr_t;
//将 int* 类型重命名为 ptr_t

给数组指针和函数指针重命名时，语法稍微有些区别。

例：

typedef int(*parr_t)[5]; 
//将数组指针类型 int(*)[5] 重命名为 parr_t
typedef void(*pfun_t)(int);
//将 void(*)(int) 类型重命名为 pf_t

如果要对刚才的特例2进行简化，那就可以这样写：

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

14 函数指针数组

把函数的地址存到一个数组中，这个数组就叫函数指针数组。

//函数指针数组的定义语法。
int (*parr1[3])();
//parr1 先和 [] 结合，说明 parr1 是数组，数组的内容是 int (*)() 类型的函数指针。
int *parr2[3]();
int (*)() parr3[3];

14.1 转移表

转移表就是一个函数指针数组。

要理解转移表的用途，我们最好用个例子来解释。

例：写一个程序，用于实现计算器的功能。

//一般实现
#include <stdio.h>
int add(int a, int b)
{
	return a + b;
}
int sub(int a, int b)
{
	return a - b;
}
int mul(int a, int b)
{
	return a * b;
}
int div(int a, int b)
{
	return a / b;
}
int main()
{
	int x, y;
	int input = 1;
	int ret = 0;
	do
	{
		printf("*************************\n");
		printf(" 1:add 2:sub \n");
		printf(" 3:mul 4:div \n");
		printf(" 0:exit \n");
		printf("*************************\n");
		printf("请选择：");
		scanf("%d", &input);
		switch (input)
		{
		case 1:
			printf("输入操作数：");
			scanf("%d %d", &x, &y);
			ret = add(x, y);
			printf("ret = %d\n", ret);
			break;
		case 2:
			printf("输入操作数：");
			scanf("%d %d", &x, &y);
			ret = sub(x, y);
			printf("ret = %d\n", ret);
			break;
		case 3:
			printf("输入操作数：");
			scanf("%d %d", &x, &y);
			ret = mul(x, y);
			printf("ret = %d\n", ret);
			break;
		case 4:
			printf("输入操作数：");
			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 语句尚可应付得过来，可如果是一个具有上百个操作符的计算器，那么这条 switch 语句将会非常长。而我们还发现，为了使用 switch 语句，表示操作符的代码必须是整数并且是连续的，这个时候就可以用转移表来实现相同的任务。

//用转移表实现
#include <stdio.h>
int add(int a, int b)
{
	return a + b;
}
int sub(int a, int b)
{
	return a - b;
}
int mul(int a, int b)
{
	return a * b;
}
int div(int a, int b)
{
	return a / b;
}
int main()
{
	int x, y;
	int input = 1;
	int ret = 0;
	int (*p[5])(int x, int y) = { 0,add,sub,mul,div };//转移表
	do
	{
		printf("*************************\n");
		printf(" 1:add 2:sub \n");
		printf(" 3:mul 4:div \n");
		printf(" 0:exit \n");
		printf("*************************\n");
		printf("请选择：");
		scanf("%d", &input);
		if (input >= 1 && input <= 4)
		{
			printf("请输入两个操作数：");
			scanf("%d %d", &x, &y);
			ret = (*p[input])(x, y);
			printf("ret = %d\n", ret);
		}
		else if (input == 0)
		{
			printf("退出计算器\n");
		}
		else
		{
			printf("选择错误，重新选择\n");
		}
	} while (input);
	return 0;
}

上面的代码中，函数指针数组就像是一个跳板，用表示操作符的代码作为下标去函数指针数组里面找一个地址，然后通过这个地址去调用这个函数，所以函数指针数组又叫做转移表。

不过转移表也有自己的局限性，由于转移表的实现依赖于函数指针数组，而放在这个数组的元素的类型必须是相同的，也就是说放在函数指针数组中的函数的参数和返回类型必须是一样的。比如在上面的代码中，我们就只能用整型数来进行计算。

15 回调函数

如果把函数的指针（地址）作为参数传递给另一个函数，当这个指针被用来调用其所指向的函数时，被调用的函数就是回调函数。

例：写一个程序，用于实现计算器的功能。

//一般实现
#include <stdio.h>
int add(int a, int b)
{
	return a + b;
}
int sub(int a, int b)
{
	return a - b;
}
int mul(int a, int b)
{
	return a * b;
}
int div(int a, int b)
{
	return a / b;
}
int main()
{
	int x, y;
	int input = 1;
	int ret = 0;
	do
	{
		printf("*************************\n");
		printf(" 1:add 2:sub \n");
		printf(" 3:mul 4:div \n");
		printf(" 0:exit \n");
		printf("*************************\n");
		printf("请选择：");
		scanf("%d", &input);
		switch (input)
		{
		case 1:
			printf("输入操作数：");
			scanf("%d %d", &x, &y);
			ret = add(x, y);
			printf("ret = %d\n", ret);
			break;
		case 2:
			printf("输入操作数：");
			scanf("%d %d", &x, &y);
			ret = sub(x, y);
			printf("ret = %d\n", ret);
			break;
		case 3:
			printf("输入操作数：");
			scanf("%d %d", &x, &y);
			ret = mul(x, y);
			printf("ret = %d\n", ret);
			break;
		case 4:
			printf("输入操作数：");
			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;
}

外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传

可以看到，上面的代码是重复出现的，虽然其中执行计算的逻辑有区别，但是输入输出操作是冗余的，如果想要简化一些，就需要使用回调函数。

//用回调函数实现
#include <stdio.h>
int add(int a, int b)
{
	return a + b;
}
int sub(int a, int b)
{
	return a - b;
}
int mul(int a, int b)
{
	return a * b;
}
int div(int a, int b)
{
	return a / b;
}

void cal(int(*pf)(int, int))
{
	int x, y;
	int ret = 0;
	printf("输入操作数：");
	scanf("%d %d", &x, &y);
	ret = pf(x, y);
	printf("ret = %d\n", ret);
}

int main()
{
	
	int input = 1;
	
	do
	{
		printf("*************************\n");
		printf(" 1:add 2:sub \n");
		printf(" 3:mul 4:div \n");
		printf(" 0:exit \n");
		printf("*************************\n");
		printf("请选择：");
		scanf("%d", &input);
		switch (input)
		{
		case 1:
			cal(add);
			break;
		case 2:
			cal(sub);
			break;
		case 3:
			cal(mul);
			break;
		case 4:
			cal(div);
			break;
		case 0:
			printf("退出程序\n");
			break;
		default:
			printf("选择错误\n");
			break;
		}
	} while (input);
	return 0;
}

15.1 回调函数举例：qsort

qsort 函数是一个包含在头文件 <stdlib.h> 中的库函数，它可以对任意类型的数组进行排序，内部使用的是快速排序的方法。

//qsort函数的声明
void qsort(void* base, size_t nitems, size_t size, int (*compar)(const void* a, const void* b));

qsort 函数的声明中：

  1. 参数 base 指向数组的起始地址，即数组名。
  2. 参数 nitems 表示该数组的元素个数。
  3. 参数 size 表示该数组中每个元素的大小（单位：字节）。
  4. 参数 int (*compar)(const void*, const void*)) 为指向比较函数的函数指针，决定了排序的顺序。

其中 void* 是一种指针类型，也被称为通用指针类型，它可以接收任意数据类型的地址，但要注意的是，这种类型只能用于存放地址，不能参与运算也不能解引用。

由于 qsort 函数是一个库函数，而实现 qsort 函数的设计者事先并不知道这个函数将被用来给什么样类型的数据进行排序，所以设计者把参数中的 base 和 *compar 中的参数定义为 void* 类型。此时，由于 void* 类型可以接收任意数据类型的地址，而不同类型的数据所占字节的大小又各不相同，所以需要把表示每个元素大小的参数也输入给函数，这就是参数 size 的用途。

另外，compar 参数是 qsort 函数排序的核心内容，它指向一个比较两个元素的函数，这个函数需要使用 qsort 函数的人自己去实现，因为只有使用者才知道待排序的数据是什么类型。注意两个形参必须是 const void* 类型，同时在调用 compar 函数（compar 实质为函数指针，这里称它所指向的函数也为 compar）时，传入的实参也必须转换成 const void* 类型。在 compar 函数内部才会将 const void* 类型转换成实际类型。

int compar(const void* a, const void* b);

compar 函数虽然可以自己实现，但也需要满足一些规则。一个通用的 compar 函数应该满足：

• 如果 compar 返回值小于0，那么 a 所指向元素会被排在 b 所指向元素的前面。

• 如果 compar 返回值等于0，那么 a 所指向元素与 b 所指向元素的顺序不确定。

• 如果 compar 返回值大于0，那么 a 所指向元素会被排在 b 所指向元素的后面。

因此，如果想让 qsort 函数进行从小到大（升序）排序，那么 compar 参数可以这样写：

 //方法一
int compare (const void* a, const void* b)
 {
   if ( *(MyType*)a <  *(MyType*)b ) return -1;
   if ( *(MyType*)a == *(MyType*)b ) return 0;
   if ( *(MyType*)a >  *(MyType*)b ) return 1;
 }
//方法二
int compare(const void* a, const void* b)
{
	return (*(MyType*)a - *(MyType*)b);
}

注意：实际使用时，需要将 MyType 转换成实际数组元素的类型。

例：使用 qsort 函数对 int 数组进行升序排序。

#include <stdio.h>
#include <stdlib.h>
int IntCmp(const void* a, const void* b)
{
	return (*(int*)a - *(int*)b);
}
int main()
{
	int arr[] = { 9,1,2,8,6,4,3,5,7,0 };
	int i = 0;
	int num = sizeof(arr) / sizeof(arr[0]);
	qsort(arr,num,sizeof(arr[0]),IntCmp);
	for (i = 0; i < 10; i++)
		printf("%d ", arr[i]);
	return 0;
}

输出结果：

外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传

15.2 qsort函数模拟实现

知道了 qsort 函数的原理，下面我们用冒泡排序来模拟实现 qsort 函数。

//冒泡排序核心代码
void bubble_sort(int arr[], int sz)
{
	int i = 0;
	for (i = 0; i < sz - 1; i++)//确定趟数
	{
		int j = 0;
		for (j = 0; j < sz - i - 1; j++)//一趟冒泡排序的过程
		{
			if (arr[j] > arr[j + 1])//比较
			{
                //交换
				int tmp = arr[j];
				arr[j] = arr[j + 1];
				arr[j + 1] = tmp;
			}
		}
	}
}

由于 qsort 函数可以对任意类型的数组进行排序，而上面的代码显然只能对整型数组进行排序，要利用冒泡排序的思想对任意类型的数组进行排序，我们就需要对上面的代码进行改造。

首先，我们要对函数接收的参数进行改造，让这个函数能够接收任意类型的数组。其次，由于不同类型的数据的比较方法存在差异（比如整型数据和结构体数据的比较方法并不相同），所以我们需要对比较的方法进行改造，让函数在排序时能够比较不同类型的数据。同理，交换的代码也需要修改。

函数参数的改造：

//由于我们是在模拟实现qsort函数，因此函数的参数部分直接仿写即可。
//改造前
void bubble_sort(int arr[], int sz);
//改造后
void Bubble_sort(void* base, size_t nitems, size_t size, int(*compar)(const void* a, const void* b));

比较方法的改造：

由于我们不知道要比较的两个数据有多大，这就造成我们不能像用整型指针那样直接对指针进行加法运算就能得到后边元素的地址。而我们发现 char 类型的数据只占1个字节，恰好参数 size 又表示的是待排序数组中每个元素所占字节的大小，我们通过把 base 强制转换为 char* 类型后，这样一来如果我们想通过 base 得到下一个元素的地址，只需要在 base 的基础上加上 size 个字节即可。

外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传

外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传

上图分别以短整型和整型数组为例展示了将 base 强制转换为 char* 类型后 base 访问后续元素的方法。

//改造前
if (arr[j] > arr[j + 1])
//改造后
int Int_cmp(const void* a, const void* b)
{
	return (*(int*)a - *(int*)b);
}

if (Int_cmp(((char*)base + j * size), ((char*)base + (j + 1) * size)) > 0)

交换方法的改造：

和前面遇到的情况一样，由于我们不知道要交换的两个数据有多大，所以在 Swap 函数中我们需要输入一个参数 size 用来表示元素的大小。

由于我们想要实现一个不管是什么类型的数据都能通过这个函数进行交换的功能，所以我们不能像以往交换整型数据那样直接把它的四个字节都同时交换掉，我们需要把不同类型的数据统一强制转化为只有1个字节的 char 类型后，再通过逐个字节进行交换的办法，实现整体交换。

外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传

上图以两个整型数据3和9为例展示了 Swap 函数的交换过程。

//改造前
int tmp = arr[j];
arr[j] = arr[j + 1];
arr[j + 1] = tmp;
//改造后
void Swap(char* a, char* b,int size)
{
	int i = 0;
	for (i = 0; i < size; i++)
	{
		char tmp = *a;
		*a = *b;
		*b = tmp;
		a++;
		b++;
	}
}

Swap(((char*)base + j * size), ((char*)base + (j + 1) * size),size);

完整代码及测试内容：

#include <stdio.h>
#include <string.h>

void Swap(char* a, char* b, int size)
{
	int i = 0;
	for (i = 0; i < size; i++)
	{
		char tmp = *a;
		*a = *b;
		*b = tmp;
		a++;
		b++;
	}
}

void Bubble_sort(void* base, size_t nitems, size_t size, int(*compar)(const void* a, const void* b))
{
	int i = 0;
	int j = 0;
	for (i = 0; i < nitems - 1; i++)
	{
		for (j = 0; j < nitems - 1 - i; j++)
		{
			if (compar(((char*)base + j * size), ((char*)base + (j + 1) * size)) > 0)
			{
				Swap(((char*)base + j * size), ((char*)base + (j + 1) * size), size);
			}
		}
	}
}

//测试Bubble_sort函数排序整型数据
int Int_cmp(const void* a, const void* b)
{
	return (*(int*)a - *(int*)b);
}

void test1()
{
	int arr1[] = { 9,1,3,7,4,6,8,2,5,0 };
	int i = 0;
	size_t num = sizeof(arr1) / sizeof(arr1[0]);
	printf("测试Bubble_sort函数排序整型数据：\n");
	printf("排序前：");
	for (i = 0; i < num; i++)
	{
		printf("%d ", arr1[i]);
	}
	printf("\n");
	Bubble_sort(arr1, num, sizeof(arr1[0]), Int_cmp);
	printf("排序后：");
	for (i = 0; i < num; i++)
	{
		printf("%d ", arr1[i]);
	}
	printf("\n");
}

//测试Bubble_sort函数排序结构体数据
struct Stu
{
	char name[20];
	int age;
};
int Stu_cmp_by_name(const void* a, const void* b)
{
	return strcmp(((struct Stu*)a)->name, ((struct Stu*)b)->name);
}
int Stu_cmp_by_age(const void* a, const void* b)
{
	return (((struct Stu*)a)->age) - (((struct Stu*)b)->age);
}
void test2()
{
	struct Stu arr2[] = { {"zhangsan",15},{"lisi",12},{"wangwu",18} };
	struct Stu* p = arr2;
	int i = 0;
	size_t num = sizeof(arr2) / sizeof(arr2[0]);
	printf("测试Bubble_sort函数排序结构体数据：\n");
	printf("排序前：\n");
	for (p = arr2; p < &arr2[3]; p++)
	{
		printf("%s,%d\n", (*p).name, (*p).age);
	}
	printf("\n");
	Bubble_sort(arr2, num, sizeof(arr2[0]), Stu_cmp_by_age);
	printf("排序后(根据年龄排）：\n");
	for (p = arr2; p < &arr2[3]; p++)
	{
		printf("%s,%d\n", (*p).name, (*p).age);
	}
	printf("\n");
	Bubble_sort(arr2, num, sizeof(arr2[0]), Stu_cmp_by_name);
	printf("排序后(根据姓名排）：\n");
	for (p = arr2; p < &arr2[3]; p++)
	{
		printf("%s,%d\n", (*p).name, (*p).age);
	}
	printf("\n");
}
int main()
{
	test1();
	test2();
	return 0;
}

输出结果：

外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传

HackerKevn
关注
  • 15
    点赞
  • 踩
  • 12
    收藏
    觉得还不错? 一键收藏
  • 打赏
    打赏
  • 14
    评论
专栏目录
Qt基础之四十三：Qt智能指针(QPointer、QSharedPointer、QWeakPointer和QScopedPointer)
草上爬的博客
12-30 3629
Qt智能指针(QPointer、QSharedPointer、QWeakPointer和QScopedPointer)
简单易懂的指针教程
10-15
#### 四、指针与内存地址 - **取地址运算符 (&)：** 获取一个变量的内存地址。 ```cpp int b = 80; int *a = &b; // a现在存储的是b的地址 ``` - **间接引用运算符 (*)：** 访问指针所指向的变量的值。 ```...
C++ 智能指针 - 全部用法详解
cpp_learner的博客
08-02 6万+
血的教训？不学智能指针，本人丢了一份工作。
【C进阶】第十三篇——指针详解
m0_58367586的博客
01-10 8983
堆栈有栈顶指针，队列有头指针和尾指针，这些概念中的"指针"本质上是一个整数，是数组的索引，通过指针访问数组中的某个元素，经过学习我们在间接寻址那里看到了另一个指针的概念，这几个变量的内存布局如下图所示，在初学阶段经常要借助于这样的图来理解指针。这里的&是&i表示取变量i的地址，int *pi=&i;表示定义一个指向int型的指针变量pi,并用i的地址来初始化pi.我们讲过全局变量只能用常量表达式初始化，如果定义int p=i;
【C语言】让你不再害怕指针——C指针详解(经典,非常详细)
码农印象
03-23 13万+
因排版过于粗糙 学习详情转至 ： https://blog.csdn.net/qq_41035588/article/details/97010039 前言:复杂类型说明 要了解指针,多多少少会出现一些比较复杂的类型,所以我先介绍一下如何完全理解一个复杂类型,要理解复杂类型其实很简单,一个类型里会出现很多运算符,他们也像普通的表达式一样,有优先级,其优先级和运算优先级一样,所以我总...
C++指针（三）
PingdiGuo_guo的博客
03-03 1287
字符指针，数组参数、指针参数，一级指针与二级指针的知识点，图配文字喔~关注主播不迷路喔~~7000字详解！
C语言指针操作（三）通过指针引用数组
技术改变命运
03-04 4809
通过指针引用数组的几种方法的原理和差异；以及利用指针引用数组元素的技巧。一个数组包含若干元素，每个数组元素都占用存储单元，所以他们都有相应的地址，所谓数组元素的指针就是数组元素的地址。
C语言指针详解(经典,非常详细)
热门推荐
liu100m的专栏
06-01 28万+
前言:复杂类型说明 要了解指针,多多少少会出现一些比较复杂的类型,所以我先介绍一下如何完全理解一个复杂类型,要理解复杂类型其实很简单,一个类型里会出现很多运算符,他们也像普通的表达式一样,有优先级,其优先级和运算优先级一样,所以我总结了一下其原则:从变量名处起,根据运算符优先级结合,一步一步分析.下面让我们先从简单的类型开始慢慢分析吧: int p; //这是一个普通的整型变量 i...
Tsukinai的第四十三个程序（指针实现两数组元素互换）
Tsukinai的博客
12-09 1964
在主函数中输入数组元素的个数n，然后分别调用函数ReadData()输入数组a和数组b的元素值，在循环语句中调用函数Swap()交换数组a和数组b的对应元素的值，最后在主函数中分别调用函数PrintData()输出数组a和数组b的元素值。
C语言指针——指针与数组
qq_51182221的博客
03-21 2256
种一棵树最好的时间是十年前，其次是现在。 指针与数组 一、指针的运算 指针可以进行三种运算： 1.指针加上整数： 如果指针p指向数组a[i]，那么指针p + j 指向a[i + j]（前提是a[i + j]存在！) 2.指针减去整数: 如果指针p指向数组a[i],那么指针p - j 指向a[i - j](前提 a[i - j] 存在！) 3.两个指针相加减（两指针必须指向同一变量！！！否则运算没有意义的！） 当两个指针相减时，结果是指针在内存上的距离，可以用数组元素的个数来度量，所以如果指
c语言指针是什么
顺其自然~专栏
10-21 4273
计算机中所有的数据都必须放在内存中，不同类型的数据占用的字节数不一样，例如 int 占用 4 个字节，char 占用 1 个字节。为了正确地访问这些数据，必须为每个字节都编上号码，就像门牌号、身份证号一样，每个字节的编号是唯一的，根据编号可以准确地找到某个字节。 下图是 4G 内存中每个字节的编号（以十六进制表示）： 我们将内存中字节的编号称为地址（Address）或指针（Pointer）。地址从 0 开始依次增加，对于 32 位环境，程序能够使用的内存为 4GB，最小的地址为 0，最大的地址为 0XFFF
指针的应用程序设计十四.doc
06-20
实验名称：指针应用程序设计(十四) 实验目的： 1. 了解和掌握指针的基本概念，包括如何定义和使用指针变量。 2. 学习如何使用指针处理数组，包括数组的指针和指向数组的指针变量。 3. 学习如何操作字符串的指针和...
C指针练习.docx
04-26
十四、思考题 14. 以下程序段中，不能正确赋字符串（编译时报错）は： 答案：C. Char s[10]; s = “abcdefg”; 解释：在C语言中，字符数组的赋值操作需要使用strcpy函数或格式化字符串，否则将引发编译错误。 十...
C语言指针进阶第1课.pdf
06-16
三、指针的定义和声明 在C语言中，指针可以用星号（\*）来声明，例如`int *p;`，其中`p`是指针变量，用于存储整型变量的地址。 四、数组和指针的关系 在C语言中，数组和指针有紧密的关系。数组名可以看作是一个...
鼠标指针炫酷皮肤及使用方法
06-03
除了通过系统设置更换鼠标指针，市面上还有很多第三方软件，如CursorFX，它们提供了更为丰富的定制功能，包括自定义动画效果、声音反馈等。用户可以根据个人喜好选择合适的方式来个性化自己的鼠标指针。 总结来说，...
C/C++进阶 （8）哈希表（STL）
敲代码嘞~的博客
07-24 848
个人主页：专题分栏：本文着重于模拟实现哈希表，并非是哈希表的使用。实现的哈希表的底层用的是线性探测法，并非是哈希桶。
嵌入式初学-C语言-前言
MaBaB的博客
07-24 1046
原码就是符号位加上真值的绝对值，即用第一位表示符号，其余位表示值。比如：如果是8位二进制：[+1]原= 0000 0001[-1]原= 1000 0001第一位是符号位，因为第一位是符号位，所以8位二进制数的取值范围就是：（即第一位不表示值，只表示正负。[1111 1111 , 0111 1111] 即 [-127 , 127]原码是人脑最容易理解和计算的表示方式。
deepseek-vl 论文阅读笔记
samoyan的博客,记录技术成长~
07-22 1183
我们的语言模型基于DeepSeek LLM（DeepSeek-AI，2024），其微设计大体遵循LLaMA（Touvron等，2023a,b）的设计，采用带有RMSNorm（Zhang和Sennrich，2019）函数的Pre-Norm结构，并使用SwiGLU（Shazeer，2020）作为前馈网络（FFN）的激活函数，中间层维度为8/3模型维度。此外，我们引入了一种新的“模态预热”策略。为了促进创新并支持广泛的应用需求，我们公开了两个版本的模型，分别为1.3B和7B，以满足不同计算能力的需求。
Typora笔记上传到CSDN
最新发布
m0_48362854的博客
07-25 472
我花了一个小时弄这个 找了很多csdn的笔记 都弄完感觉最方便的还是直接在csdn上写（因为有的之前不是用的阿里云oss 而是gitee 免费仓库 但是好像后来不能使用了 就会导致你上传的笔记图片不显示 很麻烦 使用阿里云或者腾讯云的话 需要花钱 虽然两块钱用一年 但是感觉也是很麻烦 不如直接在网页上写写算了 当然如果笔记图片很多的 还是建议配置一下 ）参考这个配置完阿里云oss 没什么问题 但是PicGo也是参考他的 因为版本是旧的 可以点击我下边的官方链接下载。图片的链接是本地的 当然没法显示。
C语言指针练习与解答
3. 第三题考察指针的使用和输入输出。正确答案是D）p=&n; *p=n; *p=m; 这段代码首先为p赋值为变量n的地址，然后将m的值赋给n所指向的位置，最后将m的值赋给n。 4. 第四题是一个函数调用，其中函数`print_value`接受...
评论 14
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包

打赏作者

HackerKevn

你的鼓励将是我创作的最大动力

¥1 ¥2 ¥4 ¥6 ¥10 ¥20
扫码支付：¥1
获取中
扫码支付

您的余额不足，请更换扫码支付或充值

打赏作者

实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值