STL常用算法(上)

最新推荐文章于 2024-07-22 15:41:09 发布
最新推荐文章于 2024-07-22 15:41:09 发布
阅读量839 收藏 17
点赞数 18
分类专栏： 50 文章标签： c++ 开发语言 数据结构 算法
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_61847358/article/details/135919194
版权
本文介绍了C++STL中的几种常见算法，包括for_each用于遍历容器，transform用于搬运元素，find和find_if用于查找元素，以及count和count_if用于统计元素。同时涵盖了自定义数据类型和谓词的使用。
摘要由CSDN通过智能技术生成

触类旁通

常用遍历算法

for_each

功能描述：
实现遍历容器
函数原型：
for_each(iterator beg, iterator end, _func) ;
// 遍历算法 遍历容器元素
// beg 开始迭代器
// end 结束迭代器
// _func 函数或者函数对象 
#include <iostream>
#include<vector>
#include<algorithm>//算法 
using namespace std;
//常用遍历算法  for_each

//普通函数
void print01(int val){
	cout<<val<<" ";
} 

//仿函数
class print02{
	public:
		void operator()(int val){
			cout<<val<<" ";
		}
}; 
void test01(){
	vector<int>v;	
	for(int i=0;i<10;i++){
		v.push_back(i);
	}
	for_each(v.begin(),v.end(),print01);//始	末	函数名称 [这里传递的是函数指针(放函数名),不是仿函数,所以不加括号]
	//创建仿函数因为重载了(),所以要加()
	
	cout<<endl;
	
	for_each(v.begin(),v.end(),print02());//函数对象 
	cout<<endl; 
} 
int main()
{
	test01();
	
	system("pause");
}

这里分别用两种函数类型实现，一种叫普通函数，也叫函数名        第二种叫仿函数，也叫函数对象

for_each(v.begin(),v.end(),print01);//始    末    函数名称 [这里传递的是函数指针(放函数名),不是仿函数,所以不加括号]
    //创建仿函数因为重载了(),所以要加()

注意看括号添加有无

transform

功能描述：
搬运容器到另一个容器中
函数原型：
transform(iterator beg1, iterator end1, iterator beg2, _func) ;
//beg1 源容器开始迭代器
//end1 源容器结束迭代器
//beg2 目标容器开始迭代器
//_func 函数或者函数对象 
#include <iostream>
#include<vector>
#include<algorithm>//算法 

using namespace std;
class Transform//搬运作用 
{
	public:
		int operator()(int v){
			return v+100;//搬运过程可以修改 
		}
};

class MyPrint{
	public:
		void operator()(int val){
			cout<<val<<" ";
		}
};
void test01(){
	vector<int>v;
	
	for(int i=0;i<10;i++){
		v.push_back(i);
	}
	vector<int>vTarget;//目标容器
	vTarget.resize(v.size());//目标容器  需要提前的开辟空间
	//搬运的目标容器必须要提前开辟空间,否则无法正常搬运 
	
	 
	transform(v.begin(),v.end(),vTarget.begin(),Transform());//仿函数
	
	for_each(vTarget.begin(),vTarget.end(),MyPrint());
	cout<<endl; 
} 
int main()
{
	test01();
	system("pause");
}

 这个案例好,综合了foreach和transform算法     

与第一个for_each相同,既可以用仿函数又可以用普通函数

    vector<int>vTarget;//目标容器
    vTarget.resize(v.size());//目标容器  需要提前的开辟空间
    //搬运的目标容器必须要提前开辟空间,否则无法正常搬运  

这一块是核心，要有搬向空间和必须提前开辟空间

 常用查找算法

find

功能描述：
查找指定元素，找到返回指定元素的迭代器，找不到返回结束迭代器 end()
函数原型：
find(iterator beg, iterator end, value) ;
// 按值查找元素，找到返回指定位置迭代器，找不到返回结束迭代器位置
// beg 开始迭代器
// end 结束迭代器
// value 查找的元素 

#include <iostream>
#include<vector>
#include<algorithm>//算法 
#include<string>
using namespace std;
//查找  内置数据类型 
void test01(){
	vector<int> v;
	for(int i=0;i<10;i++){
		v.push_back(i);
	}
	
	//查找容器中是否有5这个元素
	vector<int>::iterator it=find(v.begin(),v.end(),5); 
	if(it==v.end()){
		cout<<"没有找到"<<endl;
	}else{
		cout<<"找到了"<<*it<<endl;
	}
	
} 
//查找自定义数据类型
class Person{
	public:
		Person(string name,int age)//构造函数赋初值 
		{
			this->m_Name=name;
			this->m_Age=age;
		}
		
	//自定义类型要重载 "=="   底层find知道如何对比person数据类型
	bool operator==(const Person&p)//明确该如何对待Person数据类型   如何相等 
	{
		if(this->m_Name==p.m_Name&&this->m_Age==p.m_Age){
			return true;
		}else{
			return false;
		}
	}
	 
		string m_Name;
		int m_Age;
};

void test02(){
	vector<Person>v;
	//创建数据
	Person p1("aaa",10);
	Person p2("bbb",20);
	Person p3("ccc",30);
	Person p4("ddd",40);
	
	//放入容器中
	v.push_back(p1);
	v.push_back(p2);
	v.push_back(p3);
	v.push_back(p4);
	
	Person pp("bbb",20);//找个容器中看是否有一样的人 
	
	vector<Person>::iterator it=find(v.begin(),v.end(),pp);//查找p2 

	if(it==v.end()) {
		cout<<"没找到"<<endl;
	}else{
		cout<<"找到了 姓名:"<<it->m_Name<<"年龄"<<it->m_Age<<endl; 
	}
} 
int main()
{
//	test01();
	test02();
	system("pause");
}

本代码数据类型用了一个内置数据类型,一个自定义

    自定义类型要重载 "=="   底层find知道如何对比person数据类型

因为自定义类型不同于内置类型,用本代码为例，数据类型为Person p1("aaa",10);

以下是明确类型    
    bool operator==(const Person&p)//明确该如何对待Person数据类型   如何相等 
    {
        if(this->m_Name==p.m_Name&&this->m_Age==p.m_Age){
            return true;
        }else{
            return false;
        }
    }

find_if

功能描述：
按条件查找元素
函数原型：
find_if(iterator beg, iterator end, _Pred) ;
// 按值查找元素，找到返回指定位置迭代器，找不到返回结束迭代器位置
// beg 开始迭代器
// end 结束迭代器
// _Pred 函数或者谓词（返回bool类型的仿函数）这个是主要的
代码和上一个类似                结果为这样
我想让这个输出可以得出所有比5大的数
我的想法是这样的
int p=it;//先把这个p记录下来,然后后面每次用这个p当首位置进行遍历到end;
发现for_each(p,it->end(),print01);//遍历输出
但发现报错,第一个不能是普通函数,要是迭代器.
然后尝试将p类型设置为vector<int>p;然后发现还是报错,思考后是不是想复杂了,
加上了
void print01(int val){
    cout<<val<<" ";
} 
和
for_each(v.begin()=it,v.end(),print01);

 程序正常输出成功。所以要多思考，暂停一下也行.

#include <iostream>
#include<vector>
#include<algorithm>//算法 

using namespace std;
void print01(int val){
	cout<<val<<" ";
} 
//1 查找内置数据类型 
class GreaterFive{
	public:
		bool operator()(int val){
			return val>5;
		}
};


void test01(){
	vector<int>v;
	for(int i=0;i<10;i++){
		v.push_back(i);
	}
	vector<int>::iterator it=find_if(v.begin(),v.end(),GreaterFive());
	
	
			if(it==v.end()){
		cout<<"没有找到"<<endl;
	}
	else{
		cout<<"找到了大于5的数字为"<<*it<<endl;
	}
	for_each(v.begin()=it,v.end(),print01);
	
} 

//2 查找自定义数据类型
void test02(){
	
} 
int main()
{
	test01();
	system("pause");
}

是我预期的效果 ok

然后将其修改为自定义数据类型

#include <iostream>
#include<vector>
#include<algorithm>//算法 
#include<string>
using namespace std;





//2 查找自定义数据类型
class Person{
	public:
		Person(string name,int age){
			this->m_Name=name;
			this->m_Age=age;	
		}
	string m_Name;
	int m_Age;
};

//谓词
class Greater20{
	public:
		bool operator()(Person &p){
			return p.m_Age>20;
		}
}; 
//void print02(Person val){
//	cout<<val.m_Age<<val.m_Name<<" "<<endl;
//	
//} 
void test02(){
	vector<Person>v;
	
	//创建数据
	Person p1("aaa",10);
	Person p2("bbb",20);
	Person p3("ccc",30);
	Person p4("ddd",40);
	//放入容器中
	v.push_back(p1);
	v.push_back(p2);
	v.push_back(p3);
	v.push_back(p4);
	
	//找年龄大于20的人
	vector<Person>::iterator it=find_if(v.begin(),v.end(),Greater20()) ;//谓词 
	
	 if(it==v.end()){
	 	cout<<"没找到"<<endl;
	 }
	 else{
	 	cout<<"找到姓名"<<it->m_Name<<"年龄"<<it->m_Age<<endl;
	 }
	 
//	 for_each(v.begin()=it,v.end(),print02);
} 
int main()
{
//	test01();
	test02();
	system("pause");
}

然后我想是不是也可以在这也加几行代码，实现效果和上一个相同,都可输出多个结果

经过了多次实验和思考，最后得出了代码

#include <iostream>
#include<vector>
#include<algorithm>//算法 
#include<string>
using namespace std;





//2 查找自定义数据类型
class Person{
	public:
		Person(string name,int age){
			this->m_Name=name;
			this->m_Age=age;	
		}
	string m_Name;
	int m_Age;
};

//谓词
class Greater20{
	public:
		bool operator()(Person &p){
			return p.m_Age>20;
		}
}; 
void print02(Person val){
	cout<<val.m_Age<<val.m_Name<<" "<<endl;
	
} 
void test02(){
	vector<Person>v;
	
	//创建数据
	Person p1("aaa",10);
	Person p2("bbb",20);
	Person p3("ccc",30);
	Person p4("ddd",40);
	//放入容器中
	v.push_back(p1);
	v.push_back(p2);
	v.push_back(p3);
	v.push_back(p4);
	
	//找年龄大于20的人
	vector<Person>::iterator it=find_if(v.begin(),v.end(),Greater20()) ;//谓词 
	
	 if(it==v.end()){
	 	cout<<"没找到"<<endl;
	 }
	 else{
	 	cout<<"找到姓名"<<it->m_Name<<"年龄"<<it->m_Age<<endl;
	 }
	 
	 for_each(v.begin()=it,v.end(),print02);
} 
int main()
{
//	test01();
	test02();
	system("pause");
}

adjacent_find

功能描述：
查找相邻重复元素        stl面试会用
函数原型：
adjacent_find(iterator beg, iterator end) ;
// 查找 相邻重复元素 , 返回相邻元素的第一个位置的迭代器
// beg 开始迭代器
// end 结束迭代器

vector<int>::iterator pos=adjacent_find(v.begin(),v.end());//返回迭代器的位置  

特点，其每个算法基本都返回迭代器了

代码如下

#include <iostream>
#include<vector>
#include<algorithm>//算法 
//相邻且重复才满足 
using namespace std;
void test01(){
	vector<int>v;
	v.push_back(0);
	v.push_back(2);
	v.push_back(0);
	v.push_back(3);
	v.push_back(1);
	v.push_back(4);
	v.push_back(3);
	v.push_back(3);
	
	vector<int>::iterator pos=adjacent_find(v.begin(),v.end());//返回迭代器的位置 
	if(pos==v.end()){
		cout<<"未找到相邻重复元素"<<endl;
	}
	else{
		cout<<"找到相邻重复元素:"<<*pos<<endl;
	}
} 
int main()
{
	test01();
	system("pause");
}

 binary_search

这个就和上面的有所不同了，上面的是查到了返回迭代器，查不到也返回迭代器。但binary_search返回的是真或假，是bool类型，告诉这个元素是否存在

    //查找容器中是否有9元素
    bool ret= binary_search(v.begin(),v.end(),9);

返回是bool类型

功能描述：
查找指定元素是否存在
函数原型：
bool binary_search(iterator beg, iterator end, value) ;
// 查找指定的元素，查到 返回 true 否则 false
// 注意 : 在无序序列中不可用
// beg 开始迭代器
// end 结束迭代器
// value 查找的元素 

#include <iostream>
#include<vector>
#include<algorithm>//算法 

using namespace std;
void test01(){
	vector<int>v;
	for(int i=0;i<10;i++){
		v.push_back(i);
	}
	//查找容器中是否有9元素
	bool ret= binary_search(v.begin(),v.end(),9);
	if(ret){
		cout<<"找到了元素"<<endl;
	}
	else{
		cout<<"未找到"<<endl;
	}
} 
int main()
{
	test01();
	system("pause");
}

count

功能描述：
统计元素个数
函数原型：
count(iterator beg, iterator end, value) ;
// 统计元素出现次数
// beg 开始迭代器
// end 结束迭代器
// value 统计的元素

统计内置的数据类型 

#include <iostream>
#include<vector>
#include<algorithm>//算法 头文件
using namespace std;
//1.统计内置数据类型
void test01(){
	vector<int>v;
	v.push_back(10);
	v.push_back(20);
	v.push_back(40);
	v.push_back(30);
	v.push_back(20);
	v.push_back(40);
	
	int num=count(v.begin(),v.end(),40);
	cout<<"40的元素个数为:"<<num<<endl;
}

int main()
{
	test01();
	system("pause");
}

 统计自定义数据类型

#include <iostream>
#include<vector>
#include<algorithm>//算法 头文件
#include<string>
using namespace std;
//2统计自定义数据类型
class Person{
	public:
		Person(string name,int age){
			this->m_Name=name;
			this->m_Age=age;
		}
//	定义类型要重载 "=="    系统才知道如何比较大小	
	bool operator==(const Person & p)//传一个人进来 
	{
		if(this->m_Age==p.m_Age){
			return true;
		}
		else{
			return false;
		}
	}
	
	string m_Name;
	int m_Age;
};


void test02(){
	vector<Person>v;
	Person p1("刘备",35);
	Person p2("关羽",35);
	Person p3("张飞",35);
	Person p4("赵云",30);
	Person p5("曹操",40);
	//将人员插入在容器中
	v.push_back(p1);
	v.push_back(p2);
	v.push_back(p3);
	v.push_back(p4);
	v.push_back(p5); 
	
	Person p("诸葛亮",35);//编译器不知道自定义的数据类型对象该怎么去对比	所以定义类型要重载 "==" 
	int num=count(v.begin(),v.end(),p);
	cout<<"和诸葛亮同岁数的人员个数为"<<num<<endl;
}
int main()
{
//	test01();
	test02();
	system("pause");
}

count_if

功能描述：
按条件统计元素个数
函数原型：
count_if(iterator beg, iterator end, _Pred) ;
// 按条件统计元素出现次数
// beg 开始迭代器
// end 结束迭代器
// _Pred 谓词                 很多算法使用函数对象来指定要进行的二元运算，或者指定谓词来确定进行特定运算。谓词是一个返回bool类型的值的函数，因为函数对象是一种类型的对象，实现operator()()成员函数并返回bool类型的值，所以函数对象也是谓词。
谓词（返回bool类型的仿函数）
经过代码验证发现谓词不止用仿函数(函数对象)来定义,用普通函数类型定义就行，主要是返回bool类型

 内置数据类型

#include <iostream>
#include<vector>
#include<algorithm>//算法 头文件

using namespace std;
//统计内置数据类型
class Greater20//仿函数 
{
	public:
		bool operator()(int val){
			return val>20;
		}
}; 
void test01(){
	vector<int>v;
	v.push_back(10);
	v.push_back(40);
	v.push_back(30);
	v.push_back(20);
	v.push_back(40);
	v.push_back(20);
	
	int num=count_if(v.begin(),v.end(),Greater20());//谓词
//	很多算法使用函数对象来指定要进行的二元运算，或者指定谓词来确定进行特定运算。谓词是一个返回bool类型的值的函数，
//	因为函数对象是一种类型的对象，实现operator()()成员函数并返回bool类型的值，所以函数对象也是谓词。
	cout<<"大于20的元素个数为"<<num<<endl;
	 
} 
int main()
{
	test01();
	system("pause");
}

自定义数据类型

#include <iostream>
#include<vector>
#include<algorithm>//算法 头文件
//统计自定义数据类型
class Person{
	public:
		Person(string name,int age){
			this->m_Name=name;
			this->m_Age=age;
		}
		string m_Name;
		int m_Age;
};

class AgeGreater20{
	public:
//		谓词（返回bool类型的仿函数）
		bool operator()(const Person &p){
			return p.m_Age>20;
		}
};


void test02(){
	vector<Person>v;
	Person p1("刘备",35);
	Person p2("关羽",35);
	Person p3("张飞",35);
	Person p4("赵云",30);
	Person p5("曹操",20);
	//将人员插入在容器中
	v.push_back(p1);
	v.push_back(p2);
	v.push_back(p3);
	v.push_back(p4);
	v.push_back(p5);
	
	//统计  大于20岁人员个数
	int num=count_if(v.begin(),v.end(),AgeGreater20());//谓词 
	cout<<"大于20岁的人员个数为:"<<num<<endl;
} 
	 
 
int main()
{
	
	test02();
	system("pause");
}

骑自行车带头盔
关注
  • 18
    点赞
  • 踩
  • 17
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
c++模板stl常用算法
09-01
stl常用算法，模板stl常用算法，
STL常用算法
06-18
STL常用算法 七十个 12
C++中STL常用算法
兰天禄的博客
04-02 867
STL的常用算法1、常用的遍历算法1、for_each:遍历容器元素2、transform算法 将指定容器区间元素搬运到另一容器中2、常用的查找算法2.1、find算法 查找元素2、find_if条件查找2.3、adjacent_find算法 查找相邻重复元素2.4、binary_search算法 二分查找法（容器必须有序）2.5、count算法 统计元素出现次数2.6、count_if算法 统计...
STL【算法】| 常用算法大集合
weixin_45926547的博客
03-08 1705
文章目录一、简介1.1 类别1.1.1 _if结尾1.1.2 _copy尾词1.1.3 算法类别二、非变动性算法2.1 简介2.2 常见算法2.2.1 元素计数2.2.2 最大值和最小值2.2.3 搜寻元素三、变动性算法3.1 简介3.2 常用3.3 移除性算法四、变序性算法五、排序算法六、已序区间算法七、数值算法 一、简介 STL算法都被设计用来处理一个或多个迭代器区间；多数情况下只需提供起点即可； STL算法采用覆盖模式而非安插模式； 1.1 类别 1.1.1 _if结尾 当此类算法有两种形式
C++STL常用算法
hcx的博客
02-04 951
包含容器中常用的遍历算法、查找算法、排序算法、拷贝、替换算法、算术生成算法、集合算法。注意要包含相应的头文件
STL常用算法——遍历算法
万里顾一程的博客
10-28 438
ransform() 可以将函数应用到容器的元素上，并将这个函数返回的值保存到另一个容器中，它返回的迭代器指向输出容器所保存的最后一个元素的下一个位置。for_each：遍历容器，对容器中的每一个元素调用函数或函数对象。
c++---STL常用算法
m0_50046535的博客
04-25 3323
概述： 算法主要是由头文件<algorithm><functional><numeric>组成 <algorithm>是所有stl头文件中最大的一个，涉及比较，交换，查找，遍历，复制，修改等操作 <numeric>体积很小，只包括几个在序列上进行简单数学运算的模板函数 <functional>定义了一些类模板，用以声明函数对象 一、常用遍历算法 for_each 遍历容器 transform 搬运容...
C++ —— STL常用算法
wx微信公众号“码农总动员”，获取更多编程知识
12-21 833
STL      标准模板库是一个C++软件库，大量影响了C++标准程序库但并非是其的一部分。其中包含4个组件，分别为算法、容器、函数、迭代器。      模板是C++程序设计语言中的一个重要特征，而标准模板库正是基于此特征。标准模板库使得C++编程语言在有了同Java一样强大的类库的同时，保有了更大的可扩展性。       STL常用算法总结   集合算法   关注 笔者 - jxd 微信公众号搜索 “码农总动员” 或 微信扫描下方二维码，了解更多你不知道的XX，O(∩_∩)O ...
详解c++STL—STL常用算法
怀秋秋意的博客
05-22 1003
详解c++STL—STL常用算法
C++STL常用算法(超详细!)
qq_62855390的博客
12-24 1819
v1中是有4的,但是它结果显示为未找到,就是因为v1是无序的。，找到返回相邻元素的第一个位置的迭代器,找不到返回结束迭代器。，找到返回指定元素的迭代器，找不到返回结束迭代器end（），找到返回指定元素的迭代器，找不到返回结束迭代器end（）注:两个容器必须是有序的,合并完之后也是一个有序序列。,也就是最特殊的那种情况--大容器和小容器无交集。,也就是最特殊的那种情况--大容器和小容器无交集。,也就是最特殊的那种情况--大容器包小容器。返回值:并集中最后一个元素的迭代器位置。
STL常用算法——排序算法
万里顾一程的博客
10-31 1228
合并排序，merge() 函数用于将 2 个有序序列合并为 1 个有序容器，前提是这 2 个有序容器的排序规则相同（要么都是升序，要么都是降序）。并且最终借助该函数获得的新有序容器，其排序规则也和这 2 个有序容器要相同。sort() 函数在对自定义的类对象实现排序时，需要在该类的内部提供移动构造函数和移动赋值运算符。sort()：对容器或普通数组中范围内的元素进行排序，默认进行升序排序，也可以自定义排序规则。reverse()函数：将容器指定范围内的元素进行反转。函数原型：该函数有以下两种格式。
STL常用算法大全
12-02
STL 常用算法大全 STL（Standard Template Library）提供了丰富的算法库，涵盖了查找、排序、数值计算等多方面的算法。这些算法可以帮助开发者快速、高效地处理数据。 查找算法（13 个） 1. `adjacent_find`：在...
stl常用算法(Algorithms)介绍(stl排序算法、非变序型队列)
09-04
在这个话题中，我们将深入探讨STL中的一些常用算法，特别是排序算法和非变序型队列算法。 首先，让我们来看一下排序算法。在STL中，最常用的排序算法是`std::sort`，它位于`<algorithm>`头文件中。`std::sort`可以...
STL常用算法简介
11-14
STL常用算法简介 STL常用算法简介 STL常用算法简介 STL常用算法简介 STL常用算法简介
C++ 继承篇
2301_79201049的博客
07-18 675
必须对继承而来的成员进行初始化直接通过初始化列表或者赋值的方式进行初始化调用父类构造函数进行初始化
商品信息管理系统(C语言)
zeyeqianli的博客
07-22 176
该案例使用了C语言中最具特色的结构体，将每个商品的所有信息存在结构体中，并且定义一个结构体类型的数组保存所有商品的信息，并且按照模块化的编程思想，将要实现的每个功能编写成独立的函数，这样即方便阅读同时也方便差错修改。该系统的主要功能如下：(1) 登录系统。(2) 创建商品信息。(3) 打印商品信息。(4) 查询商品信息。(5) 修改商品信息。(6) 删除商品信息。(7) 商品价格排名显示。(8) 退出系统。
【C++】操作符“new”和“delete”（创建和销毁对象）
qq_65596720的博客
07-19 368
由于C++引入了类的概念所以创建空间和销毁空间变得复杂，使用malloc和free会更加复杂，所以C++引入了new和delete来简化代码。
C语言动态内存管理
最新发布
m0_62183318的博客
07-22 677
⚽️动态内存管理是一种内存管理方法。它允许程序在运行时根据需要🍤动态地申请和回收内存空间🍤。与静态内存管理（如变量和数组的预先分配）不同，动态内存管理根据程序的需求即时分配内存，并且分配的内存大小就是程序要求的大小。🥪能更好地适应系统的动态需求，提高内存的利用率🥪可以根据程序的实际需要分配内存，而不是预先分配固定大小的内存🥪允许程序在不需要时释放内存空间，供其他应用程序使用总结来说，🍔动态内存管理。
C++函数模板与类模板详解：STL常用算法实现
- 逻辑抽象：类模板使程序员能够将算法从数据类型的具体实现中抽离出来，专注于逻辑结构，提高代码的可重用性和模块化。 - 举例： ```cpp template class ArraySorter { public: void sortArray(T* array, ...

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

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

余额充值