C++ STL 常用算法

最新推荐文章于 2024-07-21 22:06:29 发布
最新推荐文章于 2024-07-21 22:06:29 发布
阅读量195 收藏 1
点赞数 1
文章标签： c++ 算法 数据结构
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_31034951/article/details/129112906
版权

常用算法

文章目录


记录刷题中没明确说明手动实现的话就能直接用的算法，比如 sort， reverse之类的，

实例都是用的vector作为容器，有些容器可能没有这些算法

以下除特殊说明都需要#include <algorithm>头文件

来自黑马程序员C++教程的笔记，留个存档

常用遍历算法

  • for_each //遍历容器
  • transform //搬运容器到另一个容器中

1.for_each

函数原型：

  • for_each(iterator beg, iterator end, _func);

    // 遍历算法 遍历容器元素

    // beg 开始迭代器

    // end 结束迭代器

    // _func 为函数或者函数对象

//普通函数
void print01(int val) 
{
	cout << val << " ";
}
//函数对象
class print02 
{
 public:
	void operator()(int val) 
	{
		cout << val << " ";
	}
};

//用的时候：
for_each(v.begin(), v.end(), print01);
for_each(v.begin(), v.end(), print02());
//注意函数对象print02后面需要使用这个重载的函数调用！

for_each在实际开发中是最常用遍历算法，需要熟练掌握

2.transform

函数原型

  • transform(iterator beg1, iterator end1, iterator beg2, _func);

    //beg1 源容器开始迭代器

    //end1 源容器结束迭代器

    //beg2 目标容器开始迭代器

    //_func 为函数或者函数对象

描述: 将1的始末迭代器位置的数据放到指定的2的迭代器的位置，一般是一个的始末放到另一个的开头，最后的函数表示对每个数据怎么处理，不处理就是像如下的直接返回原值，要处理的话就可以放其他的函数或是仿函数，比如取反，逻辑非等。

class TransForm
{
public:
	int operator()(int val)
	{
		return val;  //保留原值
	}
};

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());  //使用上面的仿函数

搬运的目标容器必须要提前开辟空间，否则无法正常搬运

常用查找算法

  • find //查找元素
  • find_if //按条件查找元素
  • adjacent_find //查找相邻重复元素
  • binary_search //二分查找法
  • count //统计元素个数
  • count_if //按条件统计元素个数

1.find

  • find(iterator beg, iterator end, value);

    // 按值查找元素，找到返回指定位置迭代器，找不到返回结束迭代器位置

    // beg 开始迭代器

    // end 结束迭代器

    // value 查找的元素

返回查找到的值的迭代器，找不到时为end();

针对自定义的类型，比如自定义的类的对象，需要自己在类里面重载==符号，给出相等的判定条件：

class Person {
public:
	Person(string name, int age) 
	{
		this->m_Name = name;
		this->m_Age = age;
	}
	//重载==
	bool operator==(const Person& p)  //给出相等的判定
	{
		if (this->m_Name == p.m_Name && this->m_Age == p.m_Age) 
		{
			return true;
		}
		return false;
	}
public:
	string m_Name;
	int m_Age;
};

//main
vector<Person> v;
//创建数据
Person p1("aaa", 10);
Person p2("bbb", 20);
Person p3("ccc", 30);
v.push_back(p1);
v.push_back(p2);
v.push_back(p3);

vector<Person>::iterator it = find(v.begin(), v.end(), p2);
if (it == v.end()) {
	cout << "没有找到!" << endl;
}
else {
	cout << "找到姓名:" << it->m_Name << " 年龄: " << it->m_Age << endl;
}

2.find_if

按条件查找

  • find_if(iterator beg, iterator end, _Pred);

    // 按条件查找元素，找到返回指定位置迭代器，找不到返回结束迭代器位置

    // beg ：开始迭代器

    // end ：结束迭代器

    // _Pred ：函数或者谓词（返回bool类型的仿函数） 因为是if。

针对自定义的数据类型，同样需要给定条件满足的判定方法，根据句意，应该是要重载函数调用，返回bool类型。

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

class Greater20  //自建仿函数，给定能够find成功的条件！
{
public:
	bool operator()(Person &p)
	{
		return p.m_Age > 20;
	}

};

//main
vector<Person> v;
Person p1("aaa", 10);
Person p2("bbb", 20);
Person p3("ccc", 30);
v.push_back(p1);
v.push_back(p2);
v.push_back(p3);

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

3.adjacent_find

查找相邻重复元素

adjacent_find(iterator beg, iterator end);

// 查找相邻重复元素,返回相邻元素的第一个位置的迭代器

// beg 开始迭代器

// end 结束迭代器

vector<int> r = {1,2,2,5,3,3,5};
vector<int>::iterator it = adjacent_find(r.begin(), r.end());
//返回的是第一个2的迭代器！。

不用指定查哪个，只要查到有相邻重复的就返回。

面试题中如果出现查找相邻重复元素，记得用STL中的adjacent_find算法

4.binary_**search**

使用二分查找的方法查找某值是否存在（既然二分了，那显然需要有序的，无序序列不能用）

**bool** binary_search(iterator beg, iterator end, value);

// 查找指定的元素，查到 返回true 否则false

// 注意: 在无序序列中不可用

// beg 开始迭代器

// end 结束迭代器

// value 查找的元素

vector<int> r = {1,2,3,4,5,6,7};

~~vector<int>::iterator it = binary_search(r.begin(), r.end(), 2);~~
bool has_num = binary_search(r.begin(), r.end(), 2);
//注意只能查到是否存在，返回存在或不存在，不能返回下标或是迭代器
//

二分查找法查找效率很高，值得注意的是查找的容器中元素必须的有序序列

自定义的数据类型则需要重载<号

5.count

统计元素个数，也是一种查找

count(iterator beg, iterator end, value);

// 统计元素出现次数，返回为int

// beg 开始迭代器

// end 结束迭代器

// value 统计的元素

同样的针对自定义的数据类型，需要给定相等的判定条件（为什么是相等的？因为统计数量，本来就是判等操作），因此需要类里面重载== 。相当于告诉外界我自己创建的这个类如何判等!

//自定义数据类型
class Person
{
public:
	Person(string name, int age)
	{
		this->m_Name = name;
		this->m_Age = age;
	}
	bool operator==(const Person & p)  //当前(this)与另一个对象比
	{
		if (this->m_Age == p.m_Age)  //规定是年龄相同就是相等
		{
			return true;
		}
		else
		{
			return false;
		}
	}
	string m_Name;
	int m_Age;
};
//main
vector<Person> v;
Person p1("刘备", 35);
Person p2("关羽", 35);
Person p3("张飞", 35);
Person p4("赵云", 30);
Person p5("曹操", 25);
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); //3

6.count_if

按条件统计元素个数，需要自行通过仿函数的方式给定条件！

count_if(iterator beg, iterator end, _Pred);

// 按条件统计元素出现次数

// beg 开始迭代器

// end 结束迭代器

// _Pred 谓词

需要自定义这个条件，利用仿函数：

class Greater4  //针对自带的数据类型
{
public:
	bool operator()(int val)
	{
		return val >= 4;
	}
};

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

	string m_Name;
	int m_Age;
};
//仿函数，作为统计的条件。
//注意与类内重载某些符号是不一样的。
//仿函数都是重载函数调用符，而类内重载则是根据要求的对对象的操作进行相应的重载
//比如比较大小，需要重载<号，让this对象跟传进来的比，或是比较是否相等，需要重载==号
class AgeLess35  
{
public:
	bool operator()(const Person &p)
	{
		return p.m_Age < 35;
	}
};

常用排序算法

  • sort //对容器内元素进行排序
  • random_shuffle //洗牌 指定范围内的元素随机调整次序
  • merge // 容器元素合并，并存储到另一容器中
  • reverse // 反转指定范围的元素

1.sort

sort(iterator beg, iterator end, _Pred);

// 排序

// beg 开始迭代器

// end 结束迭代器

// _Pred 谓词 返回类型为bool的重载了函数调用的函数对象

主要是想自定义排序规则时，需要自定义仿函数，设定两个数之间的排序规则

class Person
{
public:
    Person(string name, int age)
    {
        this->m_Name = name;
        this->m_Age = age;
    }

    string m_Name;
    int m_Age;

};

class sortPerson {
public:
    bool operator()(const Person& p1, const Person& p2) {
        if (p1.m_Age > p2.m_Age) {
            return true;
        }
        else return false;
    }
};

//注意先写类，再写仿函数，仿函数里的return false不能少
vector<Person> s;
Person p1("刘备", 23);
Person p2("关羽", 27);
Person p3("张飞", 25);
Person p4("赵云", 21);
s.push_back(p1);
s.push_back(p2);
s.push_back(p3);
s.push_back(p4);

sort(s.begin(), s.end(), sortPerson());

2.random_shuffle

将容器中指定范围内的元素随机打乱

random_shuffle(iterator beg, iterator end);

// 指定范围内的元素随机调整次序

// beg 开始迭代器

// end 结束迭代器

需要随机种子：srand(unsigned int)time(NULL); ,它又需要ctime头

3.merge

两个容器元素合并，并存储到另一容器中

merge(iterator beg1, iterator end1, iterator beg2, iterator end2, iterator dest);

// 容器元素合并，并存储到另一容器中

// 注意: 两个容器必须是有序的

// beg1 容器1开始迭代器
// end1 容器1结束迭代器
// beg2 容器2开始迭代器
// end2 容器2结束迭代器
// dest 目标容器开始迭代器

就是归并排序的归并的过程，前提是两边都需要有序，dest需要先有大小（像transform一样）

vector<int> vtarget;
//目标容器需要提前开辟空间
vtarget.resize(v1.size() + v2.size());
//合并  需要两个有序序列
merge(v1.begin(), v1.end(), v2.begin(), v2.end(), vtarget.begin());

4.reverse

将容器内元素进行反转

reverse(iterator beg, iterator end);

// 反转指定范围的元素

// beg 开始迭代器

// end 结束迭代器

vector<int> v = {1,2,3,4,5};
reverse(v.begin(), v.end());

常用拷贝和替换算法

  • copy // 容器内指定范围的元素拷贝到另一容器中
  • replace // 将容器内指定范围的旧元素修改为新元素
  • replace_if // 容器内指定范围满足条件的元素替换为新元素
  • **swap** // 互换两个容器的元素

1.copy

容器内指定范围的元素拷贝到另一容器中

copy(iterator beg, iterator end, iterator dest);

// 将一个容器的beg到end范围内的元素拷贝到另一个容器的dest处

// beg 开始迭代器

// end 结束迭代器

// dest 目标起始迭代器

显然，目标需要先有大小，才能放东西

copy(v1.begin(), v1.end(), v2.begin());
// 将容器v1的全部内容(begin到end)全部复制到v2里，从v2的begin处开始

利用copy算法在拷贝时，目标容器记得提前开辟空间

2.replace

将容器内指定范围的旧元素修改为新元素，针对的是某一个容器，而不是说把一个容器的内容替换成另一个容器的

replace(iterator beg, iterator end, oldvalue, newvalue);

// 将区间内旧元素 替换成 新元素

// beg 开始迭代器

// end 结束迭代器

// oldvalue 旧元素

// newvalue 新元素

vector<int> v1 = {1,2,2,3,4,5};
replace(v1.begin(), v1.end(), 2, 5); //v1变为 {1,5,5,3,4,5}

如果是自定义的数据类型，第三个参数就相当于是在容器里找相等的，因此需要在类里重载==

3.replace_if

将区间内满足条件的元素，替换成指定元素。牵扯到条件，则需要考虑对函数调用的重载，也就是要考虑谓词（返回bool的重载了函数调用运算符的类的对象—仿函数（函数对象））

replace_if(iterator beg, iterator end, _pred, newvalue);

// 按条件替换元素，满足条件的替换成指定元素

// beg 开始迭代器

// end 结束迭代器

// _pred 谓词

// newvalue 替换的新元素

比如将大于某个值的数替换为newvalue（这里示例直接用自定义数据类型）

class Person
{
public:
    Person(string name, int age)
    {
        this->m_Name = name;
        this->m_Age = age;
    }

    string m_Name;
    int m_Age;

};
class replaceIFPerson {
public:
    bool operator()(const Person& p1) {
        if (p1.m_Age > 23) {
            return true;
        }
        else return false;
    }
};

//main
vector<Person> s;
Person p1("刘备", 23);
Person p2("关羽", 27);
Person p3("张飞", 25);
Person p4("赵云", 21);
s.push_back(p1);
s.push_back(p2);
s.push_back(p3);
s.push_back(p4);
Person p5("诸葛亮", 20);  //
replace_if(s.begin(), s.end(), replaceIFPerson(), p5);
//最后结果为关羽和张飞由于大于23岁，被替换掉了
/*
姓名： 刘备 年龄23
姓名： 诸葛亮 年龄20
姓名： 诸葛亮 年龄20
姓名： 赵云 年龄21
*/

4.swap

互换两个同种类型的容器的元素

swap(container c1, container c2);

// 互换两个容器的元素

// c1容器1

// c2容器2

之前讲过的可以用来收缩内存的：

vector<int> v;
for (int i = 0; i < 100000; i++) {
	v.push_back(i);
}

cout << "v的容量为：" << v.capacity() << endl; // 138255
cout << "v的大小为：" << v.size() << endl;   // 100000

v.resize(3); //突然变小 ，还是很占内存

cout << "v的容量为：" << v.capacity() << endl; //138255
cout << "v的大小为：" << v.size() << endl;    //3

//收缩内存
vector<int>(v).swap(v); //匿名对象  如果v突然变的很小，仍会占用很大内存，再这样操作，来缩减
//先看vector<int>(v)，利用v拷贝创建了一个匿名对象，它的大小是3，容量是比较小的。再与原本很大的v进行swap
//交换完，匿名对象占空间很大，而v变小了，系统会回收这个匿名对象。实现内存收缩

cout << "v的容量为：" << v.capacity() << endl;
cout << "v的大小为：" << v.size() << endl;

常用算术生成算法

算术生成算法属于小型算法，使用时包含的头文件为 **#include <numeric>**

  • accumulate // 计算容器元素累计总和
  • fill // 向容器中添加元素

1.accumulate

计算区间内 容器元素累计总和

accumulate(iterator beg, iterator end, value);

// 计算容器元素累计总和

// beg 开始迭代器

// end 结束迭代器

// value 起始值

vector<int> v = { 1,2,3,4,5 };
int total = accumulate(v.begin(), v.end(), 10);
// total = 25;

计算方法是value+迭代器中起始位置的值的和。迭代器中起始位置和值的和求完之后再加上这个value。如果想只求迭代器的数据和，value=0即可

2.fill

向容器中填充指定的元素，适用于初始值不喜欢了，重新填充新的默认值

fill(iterator beg, iterator end, value);

// 向容器中填充元素

// beg 开始迭代器

// end 结束迭代器

// value 填充的值

会将迭代器指向的范围（左闭右开）内的元素全部都替换成value

常用集合算法

常用的对集合的操作算法，这个集合并不是非得是set数据类型，vector也行

  • set_intersection // 求两个容器的交集
  • set_union // 求两个容器的并集
  • set_difference // 求两个容器的差集

三个都是求完相应的集合之后保存到另外一个容器里，并且返回的是那个容器的求完集合后最后一个元素的end，并不一定是整个容器的end。并且要求数据有序。

1.set_intersection

求两个容器的交集并保存

set_intersection(iterator beg1, iterator end1, iterator beg2, iterator end2, iterator dest);

// 求两个集合的交集

// 注意:两个集合必须是有序序列（像是需要用到归并），且必须存的是同类型的数据，且目标容器要提前设置大小。

// beg1 容器1开始迭代器
// end1 容器1结束迭代器
// beg2 容器2开始迭代器
// end2 容器2结束迭代器
// dest 目标容器开始迭代器

求的是两个集合指定迭代器范围内的交集，并保存下来，从指定的目标容器的迭代器位置开始存，并不一定非的是开始迭代器。返回值是目标容器的尾部的迭代器！

为啥要返回尾部迭代器？

见下面差集的示例

vector<int> vTarget;
//取两个里面较小的值给目标容器开辟空间
vTarget.resize(min(v1.size(), v2.size()));

//返回目标容器的最后一个元素的迭代器地址
vector<int>::iterator **itEnd** = set_intersection(v1.begin(), v1.end(), v2.begin(), v2.end(), vTarget.begin());

2 set_union

求两个容器的并集并保存

set_union(iterator beg1, iterator end1, iterator beg2, iterator end2, iterator dest);

// 求两个集合的并集

// 注意:两个集合必须是有序序列，且必须存的是同类型的数据，且目标容器要提前设置大小。

// beg1 容器1开始迭代器
// end1 容器1结束迭代器
// beg2 容器2开始迭代器
// end2 容器2结束迭代器
// dest 目标容器开始迭代器

求的是两个集合指定迭代器范围内的并集，并保存下来，从指定的目标容器的迭代器位置开始存，并不一定非的是开始迭代器。返回值是目标容器的尾部的迭代器！

vector<int> vTarget;
//取两个容器的和给目标容器开辟空间
vTarget.resize(**v1.size() + v2.size()**);

//返回目标容器的最后一个元素的迭代器地址
vector<int>::iterator itEnd = set_union(v1.begin(), v1.end(), v2.begin(), v2.end(), vTarget.begin());

3.set_difference

求两个集合的差集

set_difference(iterator beg1, iterator end1, iterator beg2, iterator end2, iterator dest);

// 求两个集合的差集

// 注意:两个集合必须是有序序列，且必须存的是同类型的数据，且目标容器要提前设置大小。

// beg1 容器1开始迭代器
// end1 容器1结束迭代器
// beg2 容器2开始迭代器
// end2 容器2结束迭代器
// dest 目标容器开始迭代器

求的是两个集合指定迭代器范围内的差集，并保存下来，从指定的目标容器的迭代器位置开始存，并不一定非的是开始迭代器。返回值是目标容器的尾部的迭代器！

注意：是前面的与后面的之差，比如

vector<int> v1 = { 1,2,3,4,5 }; 
vector<int> v2 = { 4,5,6,7 };
vector<int> v3;
v3.resize(max(v1.size(), v2.size()));
vector<int>::iterator itEnd = set_difference(v2.begin(), v2.end(), v1.begin(), v1.end(), v3.begin());
// 即为v2与v1的差集
// 结果为{6,7,0,0,0} 后面3个0是因为他的大小设为v1和v2的最大值，而默认值为0
for(vector<int>::iterator it = v3.begin(); it!=itEnd; it++){
	cout << *it<< endl; // 这样就仅是求到的部分，没有多余的0
}

↑上面的例子就说明了为啥要返回尾部迭代器，当遍历结果的时候，结束位置为上面返回的就可以不打印多余的内容，切切实实是交集（并集/差集）的内容！

讲义给的例子：

cout << "v1与v2的差集为： " << endl;
vector<int>::iterator itEnd = 
      set_difference(v1.begin(), v1.end(), v2.begin(), v2.end(), vTarget.begin());
for_each(vTarget.begin(), itEnd, myPrint());
cout << endl;

cout << "v2与v1的差集为： " << endl;
itEnd = set_difference(v2.begin(), v2.end(), v1.begin(), v1.end(), vTarget.begin());
for_each(vTarget.begin(), itEnd, myPrint());
cout << endl;
Longer404
关注
  • 1
    点赞
  • 踩
  • 1
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
c++模板stl常用算法
09-01
stl常用算法，模板stl常用算法，
Day20:C++STL算法篇(1/2)
zjjaibc的博客
06-30 469
STL查找算法、排序算法、删除和替换算法
C++ STL算法（一）利用STL算法解决很常见的一些子问题
ylh的博客
12-19 408
常见的一些子问题，例如《全排序》 《前缀和》《二分查找》《排序去重》等等
STL标准函数库 set容器（multiset）
xx_ii
09-03 948
set集合容器：实现了红黑树的平衡二叉检索树的数据结构，插入元素时，它会自动调整二叉树的排列，把元素放到适当的位置，以保证每个子树根节点键值大于左子树所有节点的键值，小于右子树所有节点的键值（实现了二叉搜索树的特点）；另外，还得保证根节点左子树的高度与右子树高度相等。 平衡二叉检索树使用中序遍历算法，检索效率高于vector、deque和list等容器，另外使用中序遍历可将键值按照从小到大遍历出来
C++常用stl算法.pdf
11-22
这篇文档主要讨论了C++ STL中的一些常用算法，包括函数对象适配器，如`for_each`、`bind`等。让我们深入探讨这些概念。 首先，函数对象在C++中是一个重要的概念，它是一个类，通过重载`()`操作符使得类的对象能够像...
C++ STL--数据结构与算法实现（余文溪）示例程序代码.rar
11-10
C++ STL，全称为Standard Template Library（标准模板库），是C++编程语言中的一部分，它提供了丰富的容器、迭代器、算法和函数对象等组件，极大地简化了数据结构和算法的实现。余文溪的《C++ STL--数据结构与算法...
C++STL实验报告-迭代器和非变异算法
12-30
在本篇"C++ STL实验报告-迭代器和非变异算法"中，我们将深入探讨C++标准模板库（STL）中的几个核心概念，包括容器、迭代器和非变异算法。实验的目标是熟悉set、multiset、map和multimap这四种关联容器的使用，以及...
C++ STL教程pdf
05-10
2. **标准模板**：在C++ STL中，模板被用来定义泛型类（如容器和迭代器）和泛型函数（如算法）。例如，`vector`、`list`、`map`等都是标准模板类，它们可以存储不同类型的数据。模板使代码更加模块化，易于维护和...
(C++二叉树02) 翻转二叉树 对称二叉树 二叉树的深度
qq_44962949的博客
07-17 221
【代码】(C++二叉树02) 翻转二叉树 对称二叉树 二叉树的深度。
C++笔试强训7
最新发布
m0_74189279的博客
07-21 517
这意味着编译器会尝试将函数的代码直接插入到每个调用该函数的地方，而不是像通常那样进行函数调用（即，生成调用指令，跳转到函数代码，执行函数体，然后返回）。友元函数是在类外部定义的普通函数，它只能通过传入的参数（如果有的话）来访问类的成员，或者通过类的对象显式地访问（如果该函数设计为接受类的对象作为参数）。函数参数默认值又叫缺省参数，缺省参数必须从右向左开始缺省，必须连续给定缺省值，也就是说，从左到右，一旦遇到一个参数是缺省的，那么之后的参数也必须都是缺省的。指针是类成员函数特有的，用于指向调用该函数的对象。
学懂C语言系列（三）：C语言基本语法
martian665的专栏
07-17 562
学懂C语言系列,C语言基本语法
c++ primer plus 第16章string 类和标准模板库, 16.3.2 可对矢量执行的操作
zhyjhacker的博客
07-21 716
c++ primer plus 第16章string 类和标准模板库, 16.3.2 可对矢量执行的操作。
C++笔记3：基类指针delete子类对象的内存泄漏问题
subtitle_的博客
07-21 123
C++笔记3：基类指针delete子类对象的内存泄漏问题
2024年华为OD机试真题-虚拟游戏理财-C++-OD统一考试（C卷D卷）
面试高手的博客
07-21 1462
现有一家Bank，它提供有若干理财产品m，风险及投资回报不同，你有N（元）进行投资，能接受的总风险值为X。第一行：产品数(取值范围[1, 20])，总投资额(整数，取值范围[1, 10000])，可接受的总风险(整数，取值范围[1, 200])投资第二项30个单位，第四项40个单位，总的投资风险为两项相加为4+6=10。第四行：最大投资额度序列，输入为整数，取值范围[1,10000]第二行：产品投资回报率序列，输入为整数，取值范围[1,60]第三行：产品风险值序列，输入为整数，取值范围[1,100]
【C++】获取环境变量
Badme
07-18 6139
【C++】获取环境变量
Windows 点云生成二维栅格图 [附C++完整代码实现]
weixin_43896283的博客
07-17 3029
三维点云数据转换为二维栅格图
C语言中的指针函数和函数指针
letterljhx的博客
07-18 466
C语言中的指针函数和函数指针
【C语言】逗号运算符详解 - 《不起眼的 “逗号”》
EleganceJiaBao的博客
07-19 667
逗号运算符是C语言中一个非常实用的运算符，但也常常被初学者忽视。本文将详细介绍逗号运算符的定义、用法和应用场景，通过示例和代码解释其工作原理。
浅谈C嘎嘎类与对象
2302_80418176的博客
07-17 651
关键字：class语法格式：class 类名//这里的分号不能少此外，class有三个属性分别是private、public、protected，这三个属性是干啥的，相信大家通过这三个单词的中文意思应该也能知道。那么我们来看一下下面的这个例子。从上面的图片中，我们可以看到整个类分为了两个部分：公共部分和私有部分，私有部分中声明变量，公有部分定义函数以及构造函数等等。
C++ STL算法详解：函数对象适配器与示例
"C++常用STL算法的学习资料，包括函数对象适配器、bind1st、bind2nd等常见算法的使用示例" 在C++编程中，STL（Standard Template Library，标准模板库）提供了丰富的算法和容器，极大地提高了代码的可复用性和效率...

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值