深⼊理解指针（5）

最新推荐文章于 2024-05-28 09:30:58 发布
最新推荐文章于 2024-05-28 09:30:58 发布
阅读量1.2k 收藏 30
点赞数 61
分类专栏： C指针详解 文章标签： c#
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_70238476/article/details/138721302
版权

目录

1. 回调函数是什么？

回调函数就是⼀个通过函数指针调⽤的函数。
如果你把函数的指针（地址）作为参数传递给另⼀个函数，当这个指针被⽤来调⽤其所指向的函数时，被调⽤的函数就是回调函数。回调函数不是由该函数的实现方直接调用，⽽是在特定的事件或条件发生时由另外的⼀⽅调用的，用于对该事件或条件进行响应。
深入理解指针（4）中我们写的计算器的⼀般实现代码中是重复出现的，其中虽然执⾏计算的逻辑是区别的，但是输⼊输出操作是冗余的，有没有办法，简化⼀些呢？
只有调⽤函数的逻辑是有差异的，我们可以把调⽤的函数的地址以参数的形式传递过去，使⽤函数指针接收，函数指针指向什么函数就调⽤什么函数，这⾥其实使⽤的就是回调函数的功能。

#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 eum()
{
	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;
	do
	{
		eum();
		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("请输入两个操作数:>\n");
			scanf("%d %d", &x, &y);
			ret = Sub(x, y);
			printf("%d\n", ret);
			break;
		case 3:
			printf("请输入两个操作数:>\n");
			scanf("%d %d", &x, &y);
			ret = Mul(x, y);
			printf("%d\n", ret);
			break;
		case 4:
			printf("请输入两个操作数:>\n");
			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;
}

1.1 使用回调函数修改

//使用回调函数改造后
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 eum()
{
	printf("*******************************\n");
	printf("***1. add   2. sub   **********\n");
	printf("***3. mul   4. div   **********\n");
	printf("***     0. exit     **********\n");
	printf("*******************************\n");
}

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

int main()
{
	int input = 0;
	int x = 0;
	int y = 0;
	int ret = 0;
	do
	{
		eum();
		printf("请选择:>");
		scanf("%d", &input);
		switch (input)
		{
		case 1:
			Clcs(Add);
			break;
		case 2:
			Clcs(Sub);
			break;
		case 3:
			Clcs(Mul);
			break;
		case 4:
			Clcs(Div);
			break;
		case 0:
			printf("退出程序\n");
			break;
		default:
			printf("输入错误请重新输入\n");
			break;
		}
	} while (input);
	return 0;
}

2. qsort使⽤举例

C/C++函数介绍: https://legacy.cplusplus.com/
使用说明
在这里插入图片描述
这里的头文件是#include <stdlib.h>

2.1 使⽤qsort函数排序整型数

#define _CRT_SECURE_NO_WARNINGS 1
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
int cmp_int(const void* p1, const void* p2)
{
	return (*(int*)p1) - (*(int*)p2);
}

void print1(int* p, int sz)
{
	for (int i = 0; i < sz; i++)
	{
		printf("%d ", *(p + i));
	}
}

//测试qsort排序整型结构体
void test1()
{
	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);
	print1(arr, sz);
}

int main()
{
	test1();//打印整型数组
	return 0;
}

运行结果：
在这里插入图片描述

2.2 使⽤qsort排序结构数据按年龄排序

#define _CRT_SECURE_NO_WARNINGS 1
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
struct Stu
{
	char name[20];
	int age;
};

int cmp_int(const void* p1, const void* p2)
{
	return (*(int*)p1) - (*(int*)p2);
}

cmp_stu_by_age(const void* p1, const void* p2)
{
	return ((struct Stu*)p1)->age - ((struct Stu*)p2)->age;
}

test2()
{
	struct Stu arr[] = { {"zhangsan",20},{"lisi",50},{"wangwu",18} };
	int sz = sizeof(arr) / sizeof(arr[0]);
	qsort(arr, sz, sizeof(arr[0]), cmp_stu_by_age);
	print2(arr, sz);
}

//打印结构体age
print2(struct Stu* p, int sz)
{
	for (int i = 0; i < sz; i++)
	{
		printf("%d ", (p + i)->age);
	}
}

int main()
{
	test2();//打印结构体age
	return 0;
}

运行结果：
在这里插入图片描述

2.3 使⽤qsort排序结构数据按名字排序

#define _CRT_SECURE_NO_WARNINGS 1
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
struct Stu
{
	char name[20];
	int age;
};

int cmp_stu_by_name(const void* p1, const void* p2)
{
	return ((struct Stu*)p1)->name - ((struct Stu*)p2)->name;
}

void print3(int* p, int sz)
{
	for (int i = 0; i < sz; i++)
	{
		printf("%s ", ((struct Stu*)p + i)->name);
	}
}

test3()
{
	struct Stu arr[3] = { {"zhangsan",18},{"wangwu",30},{"lisi",20} };
	int sz = sizeof(arr) / sizeof(arr[0]);
	qsort(arr, 3, sizeof(arr[0]), cmp_stu_by_name);
	print3(arr, sz);
}

//qsort使用
int main()
{	
	test3();//打印结构体name
	return 0;
}

运行结果：
在这里插入图片描述

2.4整体代码

#define _CRT_SECURE_NO_WARNINGS 1
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
int cmp_int(const void* a, const void* b)
{
	return *((int*)a) - *((int*)b);
}

void print1(int arr[], int sz)
{
	for (int i = 0; i < sz; i++)
	{
		printf("%d ", arr[i]);
	}
}

test1()
{
	int arr[] = { 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);
	print1(arr, sz);
}

struct Stu
{
	char name[20];
	int age;
};

int cmp_stu_by_age(const void* p1, const void* p2)
{
	return ((struct Stu*)p1)->age - ((struct Stu*)p2)->age;
}

void print2(int* p, int sz)
{
	for (int i = 0; i < sz; i++)
	{
		printf("%d ", ((struct Stu*)p + i)->age);
	}
}

test2()
{
	struct Stu arr[3] = {{"zhangsan",18},{"wangwu",30},{"lisi",20}};
	int sz = sizeof(arr) / sizeof(arr[0]);
	qsort(arr, 3, sizeof(arr[0]), cmp_stu_by_age);
	print2(arr, sz);
}

int cmp_stu_by_name(const void* p1, const void* p2)
{
	return ((struct Stu*)p1)->name - ((struct Stu*)p2)->name;
}

void print3(int* p, int sz)
{
	for (int i = 0; i < sz; i++)
	{
		printf("%s ", ((struct Stu*)p + i)->name);
	}
}

test3()
{
	struct Stu arr[3] = { {"zhangsan",18},{"wangwu",30},{"lisi",20} };
	int sz = sizeof(arr) / sizeof(arr[0]);
	qsort(arr, 3, sizeof(arr[0]), cmp_stu_by_name);
	print3(arr, sz);
}

//qsort使用
int main()
{	
	test1();//打印整型数组
	//test2();//打印结构体age
	//test3();//打印结构体name
	return 0;
}

3. qsort函数的模拟实现

使⽤回调函数，模拟实现qsort（采⽤冒泡的⽅式）。
注意：这⾥使⽤的是 void ∗ \ast ∗ 的指针

3.1 整型数组的实现

#define _CRT_SECURE_NO_WARNINGS 1
#include <stdio.h>
int int_cmp(const void* p1, const void* p2)
{
	return (*(int*)p1 - *(int*)p2);
}

void Swap(char* buf1, char* buf2, int size)
{
	for (int i = 0; i < size; i++)
	{
		char tmp = *buf1;
		*buf1 = *buf2;
		*buf2 = tmp;
		buf1++;
		buf2++;
	}
}
void bubble_sort(void* base, int num, int size, int(*cmp)(const void*, const void*))
{
	//趟数
	for (int i = 0; i < num - 1; i++)
	{
		//一趟内部比较的对数
		for (int j = 0; j < num - 1 - i; j++)
		{
			//假设需要升序cmp返回>0，交换
			if (cmp((char*)base + j * size, (char*)base + (j + 1) * size) > 0)//两个元素比较
			{
				//交换
				Swap((char*)base + j * size, (char*)base + (j + 1) * size, size);
			}
		}
	}
}

void print1(int* arr, int sz)
{
	for (int i = 0; i < sz; i++)
	{
		printf("%d ", *(arr + i));
	}
}

void test1()
{
	int arr[] = { 1, 3, 5, 7, 9, 2, 4, 6, 8, 0 };
	int sz = sizeof(arr) / sizeof(arr[0]);
	bubble_sort(arr, sz, sizeof(int), int_cmp);
	print1(arr, sz);
}

int main()
{
	test1();
	return 0;
}

运行结果：
在这里插入图片描述

3.2 结构体按名字排序实现

#define _CRT_SECURE_NO_WARNINGS 1
#include <stdio.h>
void Swap(char* buf1, char* buf2, int size)
{
	for (int i = 0; i < size; i++)
	{
		char tmp = *buf1;
		*buf1 = *buf2;
		*buf2 = tmp;
		buf1++;
		buf2++;
	}
}

void bubble_sort(void* base, int num, int size, int(*cmp)(const void*, const void*))
{
	//趟数
	for (int i = 0; i < num - 1; i++)
	{
		//一趟内部比较的对数
		for (int j = 0; j < num - 1 - i; j++)
		{
			//假设需要升序cmp返回>0，交换
			if (cmp((char*)base + j * size, (char*)base + (j + 1) * size) > 0)//两个元素比较
			{
				//交换
				Swap((char*)base + j * size, (char*)base + (j + 1) * size, size);
			}
		}
	}
}

struct Stu
{
	int age;
	char name[10];
};

void com_name(const void* p1, const void* p2)
{
	return ((struct Stu*)p1)->name - ((struct Stu*)p2)->name;
}

void print2(struct Stu* p1, int sz)
{
	for (int i = 0; i < sz; i++)
	{
		printf("%s ", (p1 + i)->name);
	}
}

void test2()
{
	struct Stu arr[] = { {18,"zhangsan"},{30,"lisi"},{20,"wangwu"}};
	int sz = sizeof(arr) / sizeof(arr[0]);
	bubble_sort(arr, sz, sizeof(arr[0]), com_name);
	print2(arr, sz);
}

//qsort实现
int main()
{
	test2();//结构体打印
	return 0;
}

运行结果：
在这里插入图片描述

3.3 结构体按年龄排序实现

#define _CRT_SECURE_NO_WARNINGS 1
#include <stdio.h>
void Swap(char* buf1, char* buf2, int size)
{
	for (int i = 0; i < size; i++)
	{
		char tmp = *buf1;
		*buf1 = *buf2;
		*buf2 = tmp;
		buf1++;
		buf2++;
	}
}

void bubble_sort(void* base, int num, int size, int(*cmp)(const void*, const void*))
{
	//趟数
	for (int i = 0; i < num - 1; i++)
	{
		//一趟内部比较的对数
		for (int j = 0; j < num - 1 - i; j++)
		{
			//假设需要升序cmp返回>0，交换
			if (cmp((char*)base + j * size, (char*)base + (j + 1) * size) > 0)//两个元素比较
			{
				//交换
				Swap((char*)base + j * size, (char*)base + (j + 1) * size, size);
			}
		}
	}
}

struct Stu
{
	int age;
	char name[10];
};
//按年龄排序
void com_age(const void* p1, const void* p2)
{
	return ((struct Stu*)p1)->age - ((struct Stu*)p2)->age;
}
//按年龄打印
void print3(struct Stu* p1, int sz)
{
	for (int i = 0; i < sz; i++)
	{
		printf("%d ", (p1 + i)->age);
	}
}

void test3()
{
	struct Stu arr[] = { {18,"zhangsan"},{30,"lisi"},{20,"wangwu"} };
	int sz = sizeof(arr) / sizeof(arr[0]);
	bubble_sort(arr, sz, sizeof(arr[0]), com_age);
	print3(arr, sz);
}

//qsort实现
int main()
{
	test3();//结构体打印age
	return 0;
}

运行结果：
在这里插入图片描述

3.4 整体代码

#define _CRT_SECURE_NO_WARNINGS 1
#include <stdio.h>
int int_cmp(const void* p1, const void* p2)
{
	return *((int*)p1) - *((int*)p2);
}

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

void bubble_sort(void* base, int num, int size, int(*cmp)(const void*, const void*))
{
	//趟数
	for (int i = 0; i < num - 1; i++)
	{
		//一趟内部比较的对数
		for (int j = 0; j < num - 1 - i; j++)
		{
			//假设需要升序cmp返回>0，交换
			if (cmp((char*)base + j * size, (char*)base + (j + 1) * size) > 0)//两个元素比较
			{
				//交换
				Swap((char*)base + j * size, (char*)base + (j + 1) * size, size);
			}
		}
	}
}

void print1(int* arr, int sz)
{
	for (int i = 0; i < sz; i++)
	{
		printf("%d ", *(arr + i));
	}
}

void test1()
{
	int arr[] = { 7,9,3,5,4,6,2,1,0,8 };
	int sz = sizeof(arr) / sizeof(arr[0]);
	bubble_sort(arr, sz, sizeof(arr[0]), int_cmp);
	print1(arr, sz);
}

struct Stu  //学生
{
	int age;//年龄
	char name[10];//名字
};
//假设按照名字来⽐较
void com_name(const void* p1, const void* p2)
{
	return ((struct Stu*)p1)->name - ((struct Stu*)p2)->name;
}

void print2(struct Stu* p1, int sz)
{
	for (int i = 0; i < sz; i++)
	{
		printf("%s ", (p1 + i)->name);
	}
}
//按照名字来排序
void test2()
{
	struct Stu arr[] = { {18,"zhangsan"},{30,"lisi"},{20,"wangwu"}};
	int sz = sizeof(arr) / sizeof(arr[0]);
	bubble_sort(arr, sz, sizeof(arr[0]), com_name);
	print2(arr, sz);
}

void com_age(const void* p1, const void* p2)
{
	return ((struct Stu*)p1)->age - ((struct Stu*)p2)->age;
}

void print3(struct Stu* p1, int sz)
{
	for (int i = 0; i < sz; i++)
	{
		printf("%d ", (p1 + i)->age);
	}
}

void test3()
{
	struct Stu arr[] = { {18,"zhangsan"},{30,"lisi"},{20,"wangwu"} };
	int sz = sizeof(arr) / sizeof(arr[0]);
	bubble_sort(arr, sz, sizeof(arr[0]), com_age);
	print3(arr, sz);
}

//qsort实现
int main()
{
	//test1();//整型打印
	//test2();//结构体打印
	test3();
	return 0;
}
蹋雾
关注
  • 61
    点赞
  • 踩
  • 30
    收藏
    觉得还不错? 一键收藏
  • 打赏
    打赏
  • 19
    评论
专栏目录
深度帮助理解指针
11-15
有相应的例子，用图片说明，阐述了编程概念，简单易懂
深入理解C语言指针
02-24
而这个编号可以暂时理解为指针，就像酒店的门牌号一样。先写一段简单的代码：这段代码非常简单，就是两个变量的声明，分别赋值了10、20。我们把内存当做一个酒店，而每个房间就是一块内存。那么“intx=10;”和“inty...
深⼊理解指针5
jj666mhhh的博客
03-27 461
回调函数就是⼀个通过函数指针调⽤的函数。如果你把函数的指针（地址）作为参数传递给另⼀个函数，当这个指针被⽤来调⽤其所指向的函数 时，被调⽤的函数就是回调函数。回调函数不是由该函数的实现⽅直接调⽤，⽽是在特定的事件或条 件发⽣时由另外的⼀⽅调⽤的，⽤于对该事件或条件进⾏响应。我们可以把调⽤的函数的地址以参数的形式 传递过去，使⽤函数指针接收，函数指针指向什么函数就调⽤什么函数，这⾥其实使⽤的就是回调函 数的功能。
深⼊理解指针
2302_80007730的博客
01-27 1183
指针是C语言中最具特色的内容，也是C语言的重要概念和精华所在。提示：以下是本篇文章正文内容，下面案例可供参考指针与地址虽然有着密切的关系，但它们的概念上是有区别的，指针所标明的地址总是为保存特定的数据类型的数据而准备的，因此指针不但标明了数据的存储位置，而且标明了数据的类型，可以说指针是存储特定的数据类型的地址。指针是一种指向其他数据对象的数据类型。int a=10;int *p =&a;int *p = &a：把a的地址给指针变量p，int是指针变量p的数据类型，*（星号）是说明p是指针变量。
深⼊理解指针(2)
2301_78435333的博客
04-24 697
小伙伴们，小编又来咯！上一回咋们把什么叫指针以及内存，还有关于指针基础的知识点弄清楚了之后呢，这一回咋们来了解一下数组与指针之间的关系以及其中重要的知识点。小伙伴们上车坐好！准备发车啦！
深⼊理解指针-通过指针引用数组
AcsdnHZB的博客
05-23 1229
指针类型
深⼊理解指针(1)
xdx2578的博客
11-15 161
我们可以简单理解，32位机器有32根地址总线， 每根线只有两态，表⽰0,1【电脉冲有⽆】，那么 ⼀根线，就能表⽰2种含义，2根线就能表⽰4种含义，依次类推。我们知道计算上CPU（中央处理器）在处理数据的时候，需要的数据是在内存中读取的，处理后的数据也会放回内存中，那我们买电脑的时候，电脑上内存是8GB/16GB/32GB等，那这些内存空间如何⾼效的管理呢？每个内存单元也都有⼀个编号（这个编号就相当于宿舍房间的⻔牌号），有了这个内存单元的编号，CPU就可以快速找到⼀个内存空间。的每⼀个位置，这是为何？
第15讲：深⼊理解指针(5_1)
m0_46676283的博客
05-13 577
在学习操作符的时候，我们学习了 sizeof ， sizeof 计算变量所占内存空间的⼤⼩，单位是字节，如果操作数是类型的话，计算的是使⽤类型创建的变量所占内存空间的⼤⼩。sizeof 只关注占⽤内存空间的⼤⼩，不在乎内存中存放什么数据。
深⼊理解指针-字符，数组，函数-指针变量
AcsdnHZB的博客
05-25 1038
指针变量：指向内存中其他变量的变量，可以用来存放地址、函数指针、数组指针等。指针数组：存放指针变量的数组，可以用来存放不同类型的指针变量。函数指针数组：存放函数指针的数组，可以用来实现转移表。转移表：根据用户输入的选项，调用相应的函数。
第13讲：深⼊理解指针(3_1)
m0_46676283的博客
05-08 156
⽬录。
深⼊理解指针（1）
m0_70595067的博客
02-15 736
前⾯的内容我们了解到，32位机器假设有32根地址总线，每根地址线出来的电信号转换成数字信号后是1或者0，那我们把32根地址线产⽣的2进制序列当做⼀个地址，那么⼀个地址就是32个bit位，需要4个字节才能存储。上述代码中n是不能被修改的，其实n本质是变量，只不过被const修饰后，在语法上加了限制，只要我们在代码中对n就⾏修改，就不符合语法规则，就报错，致使没法直接修改n。同理64位机器，假设有64根地址线，⼀个地址就是64个⼆进制位组成的⼆进制序列，存储起来就需要8个字节的空间，指针变的⼤⼩就是8个字节。
deepin 深度主题鼠标指针
02-09
deepin 深度主题鼠标指针
深度理解c++中的this指针
09-02
主要介绍了C++编程指向成员的指针以及this指针的基本使用指南,与C语言一样,存储的数值被解释成为内存里的一个地址,需要的朋友可以参考下。
发票查验接口、发票识别接口-C#调用示例
weixin_49544544的博客
05-21 330
对于公司来说，发票是公司做账不可缺少的一部分，相信每位财务人员都会小心存放发票。如何实现发票的批量查验也成为了企业发展的一大困扰，今天翔云接口开放平台来为大家讲解一下发票查验接口。翔云平台提供发票识别与发票查验接口，可以事先识别发票上的信息，将信息保存下来，然后发票查验接口实时联网查验发票的真伪。接口，实时联网核验发票真伪,查验一致返回全票面信息，支持查验增值税发票管理系统开具的发票,支持批量核验发票，购发票查验送发票识别,助您摆脱手动输入繁琐,提升工作效率。
C#【进阶】迭代器
AMrss的博客
05-21 467
迭代器。
Unity3D 基于ILRuntime热更框架设计详解
最新发布
voidinit的专栏
05-28 545
ILRuntime是一个基于C#的热更框架，可以在运行时动态加载C#脚本，实现热更新功能。通过本文的介绍，希望读者能够了解ILRuntime框架的基本原理和使用方法，进而在自己的项目中应用ILRuntime框架，实现热更新功能。ILRuntime是一个基于C#的热更框架，可以在运行时动态加载C#脚本，实现热更新功能。ILRuntime框架使用了Mono的ILRuntime实现，可以在运行时动态生成和执行IL代码。ILRuntime是一个基于C#的热更框架，可以在运行时动态加载C#脚本，实现热更新功能。
C# 数据绑定 未完
3000bookworm
05-25 216
上述代码效果为点击ButtonLable的值++
C# 语法糖
3000bookworm
05-25 357
是一种不断进化的编程语言，随着时间的推移，微软为其添加了许多语法糖，以简化代码和提高开发效率。扩展方法允许你向现有类型“添加”方法，而无需修改其源代码或创建新的派生类型。异步编程允许你以同步代码的形式编写异步逻辑，简化了异步任务的编写和阅读。这允许编译器根据赋值推断变量的类型，减少了冗长的类型声明。（语言集成查询）提供了一种声明性的数据查询和操作方法。这允许你创建匿名类型的实例，而不需要定义具体的类型。版本的更新，未来可能会有更多的语法糖被引入。表达式提供了一种简洁的方式来编写匿名函数。
怎么理解指针和指针的指针
05-27
理解指针和指针的指针需要对内存和地址的概念有一定的了解。在C语言中，每个变量都有一个地址，指针就是存储这个地址的变量，而指针的指针则是存储指向指针变量的地址的变量。可以通过指针的解引用和指针的指针的解...

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论 19
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

打赏作者

蹋雾

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

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

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

打赏作者

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

抵扣说明：

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

余额充值