C++ STL模板是惠普实验室开发的标准开发模板,STL是C++的一部分,STL可分为容器(containers)、迭代器(iterators)、空间配置器(allocator)、配接器(adapters)、算法(algorithms)、仿函数(functors)六个部分,以下案例是针对算法中的非变易与变易算法的总结知识点。

STL 非变易算法(查找遍历)

C++ 非变易算法是一组不破坏操作数据的模板函数,用来对序列数据进行逐个处理,元素查找,统计等,并通过迭代器实现元素的遍历,由于迭代器与算法是分离的,因此非变易算法本身具有极为广泛的通用性,基本上可以应用于各种容器上.

逐个遍历容器元素 for_each: 该函数用于对容器的元素进行循环操作,常用于元素遍历.

#include <iostream>
#include <list>
#include <algorithm>
using namespace std; struct MyPrint{
int count; // 设置元素计数
MyPrint(){ count = 0; } // 初始化元素
void operator()(int x) // 重载小括号
{
cout << x << endl;
count++;
}
}; int main(int argc, char* argv[])
{
list<int> ls {1,2,3,4,5,6,7,8,9}; MyPrint p = for_each(ls.begin(), ls.end(), MyPrint());
cout << "Link Count: " << p.count << endl;
system("pause");
return 0;
}

普通查找容器元素 find: 该算法用于查找某个值等于某值得元素,它在迭代区间是(frist,last)之间寻找value值.

#include <iostream>
#include <list>
#include <algorithm>
using namespace std; int main(int argc, char* argv[])
{
list<int> ls{ 1, 2, 3, 4, 5, 6, 7, 8, 9 }; list<int>::iterator it = find(ls.begin(), ls.end(),6);
if (it != ls.end())
{
cout << "找到了元素" << endl;
cout << "前一个元素: " << *(--it) << endl;
} system("pause");
return 0;
}

类查找容器元素 find: 该算法不仅可以查询普通数据结构,还可以查询结构与类中数据.

#include <iostream>
#include <vector>
#include <string>
#include <algorithm>
using namespace std; class Person
{
public:
string m_name;
int m_age;
public:Person(string name, int age){
this->m_name = name;
this->m_age = age;
}
public: bool operator==(const Person &p){
// 重载 == 实现遍历数据
if (this->m_name == p.m_name && this->m_age == p.m_age)
return true;
return false;
}
}; int main(int argc, char* argv[])
{
vector<Person> var; Person p1("aaa", 10);
Person p2("bbb", 20);
Person p3("ccc", 30);
var.push_back(p1);
var.push_back(p2);
var.push_back(p3); vector<Person>::iterator pos = find(var.begin(), var.end(), p1);
if (pos != var.end())
cout << "找到姓名: " << (*pos).m_name << endl;
system("pause");
return 0;
}

条件查找容器元素 find_if: 该查询与上方的普通查找相比,该查找可以添加回调函数,用于对查到的数据进行筛选.

#include <iostream>
#include <vector>
#include <algorithm>
using namespace std; bool MyFunction(int x) { return x % 5 ? 0 : 1; } int main(int argc, char* argv[])
{
vector<int> var(20); // 循环生成数据
for (unsigned int x = 0; x < var.size(); x++)
var[x] = (x + 1) * (x + 3); // 循环遍历,并判断是否符合条件
vector<int>::iterator it = find_if(var.begin(),var.end(),MyFunction);
if (it != var.end())
{ // 寻找第一个被5整除的元素
cout << *it << endl;
cout << "元素索引: " << it - var.begin() << endl;
}
system("pause");
return 0;
}

条件查找类容器元素 find_if: 查找ptr类中的数据,是否存在于我们的结构中.

#include <iostream>
#include <vector>
#include <string>
#include <functional>
#include <algorithm>
using namespace std; class Person
{
public:
string m_name;
int m_age;
public:Person(string name, int age){
this->m_name = name;
this->m_age = age;
}
public: bool operator==(const Person &p){
// 重载 == 实现遍历数据
if (this->m_name == p.m_name && this->m_age == p.m_age)
return true;
return false;
}
};
// 使用binary_function适配函数实现传递两个Person数据
class MyCompare:public binary_function<Person *,Person *,bool>
{
public: bool operator()(Person *p1,Person *p2) const {
// 对比函数,重载() 用于实现指针元素的对比
if (p1->m_name == p2->m_name && p1->m_age == p2->m_age)
return true;
return false;
}
}; int main(int argc, char* argv[])
{
vector<Person *> var; Person p1("aaa", 10);
Person p2("bbb", 20);
Person p3("ccc", 30);
var.push_back(&p1);
var.push_back(&p2);
var.push_back(&p3); Person *ptr = new Person("bbb", 20); // 查找这个属性的类成员
// 通过使用bind2nd绑定事件,将ptr传递给MyCompare() 即可实现两个类属性的对比查找
vector<Person *>::iterator pos = find_if(var.begin(), var.end(), bind2nd(MyCompare(),ptr));
if (pos != var.end())
cout << "找到姓名: " << (*pos)->m_name << endl;
system("pause");
return 0;
}

邻近查找容器元素 adjacent_find:用于查找相等或满足条件的相邻的重复的元素,找到了返回第一个位的迭代器.

#include <iostream>
#include <list>
#include <algorithm>
using namespace std; bool MyFunction(int x,int y) { return (x - y) % 2 == 0 ? 1 : 0; } int main(int argc, char* argv[])
{
list<int> ls {1,2,3,4,5,6,6,7,8,9,10}; // 查找链表中邻接相等的元素
list<int>::iterator it = adjacent_find(ls.begin(), ls.end());
if (it != ls.end())
cout << *it << endl; // 查找基偶性相同的邻接元素
it = adjacent_find(ls.begin(), ls.end(), MyFunction);
if (it != ls.end())
{
cout << *it << endl;
it++;
cout << *it << endl;
}
system("pause");
return 0;
}

范围查找容器元素 find_first_of: 该算法可用于查找位于某个范围之内的元素.

#include <iostream>
#include <string>
#include <algorithm>
using namespace std; int main(int argc, char* argv[])
{
char * str1 = "hello";
char * str2 = "lyshark This is a test case. Thank you for using it lyshark."; char * result = find_first_of(str1, str1 + strlen(str1),
str2, str2 + strlen(str2));
// 字符串str1的第一个字符,第一次出现在str2中的字符为.
cout << *result << endl;
system("pause");
return 0;
}

普通元素计数统计 count: 该算法用于计算容器中某个给定值得出现次数.

#include <iostream>
#include <list>
#include <algorithm>
using namespace std; int main(int argc, char* argv[])
{
list<int> ls; // 批量插入测试数据
for (int x = 0; x < 100; x++)
{
ls.push_back(x % 20);
}
// 统计元素value出现次数,将次数放入num中.
int num = 0; int value = 9;
num = count(ls.begin(), ls.end(), value);
cout << "The number of occurrences is: " << num << endl; system("pause");
return 0;
}

条件元素计数统计 count_if: 与Count算法类似,该算法可以在统计前增加判断条件.

#include <iostream>
#include <map>
#include <algorithm>
using namespace std; struct Student{
struct Info{
char *name; // 学生姓名
int year; // 学生年龄
};
int id; // 学号
Info stu; // 学生Info数据 Student(int _id, char *_name, int _year)
{
id = _id;
stu.name = _name;
stu.year = _year;
}
}; // 获取学生年龄大于20岁并且小于30岁的人
bool GetRange(pair<int, Student::Info> s)
{
if (s.second.year > 20 && s.second.year < 30)
return 1;
return 0;
} int main(int argc, char* argv[])
{
// 初始化学生数据
Student stu1 = Student(1, "admin", 10);
Student stu2 = Student(2, "guest", 21);
Student stu3 = Student(3, "lyshark", 35); // 映射Map结构数据,并将上方的数据插入到Map中
map<int, Student::Info> mp;
pair<int, Student::Info> pairSt1(stu1.id, stu1.stu);
mp.insert(pairSt1);
pair<int, Student::Info> pairSt2(stu2.id, stu2.stu);
mp.insert(pairSt2);
pair<int, Student::Info> pairSt3(stu3.id, stu3.stu);
mp.insert(pairSt3); // 条件统计,统计出年龄大于20岁并且小于30岁的人有多少个= num
int num = 0;
num = count_if(mp.begin(), mp.end(), GetRange);
cout << num << endl;
system("pause");
return 0;
}

二分法查找算法 binary_search: 该算法就是折半查找法,查找的元素集合必须是一个有序的序列.

#include <iostream>
#include <vector>
#include <algorithm>
using namespace std; int main(int argc, char* argv[])
{
vector<int> var{ 1, 2, 3, 4, 5, 6, 6, 7, 8, 9, 10 }; bool ret = binary_search(var.begin(), var.end(), 4);
if (ret)
cout << "found ok" << endl;
else
cout << "not found" << endl; system("pause");
return 0;
}

元素不匹配查找 mismatch: 该算法函数比较两个序列,并从中找出首个不匹配元素的位置.

#include <iostream>
#include <vector>
#include <cstring>
#include <algorithm>
using namespace std; bool StrEqual(const char* x, const char* y)
{
return strcmp(x, y) == 0 ? 1 : 0;
} int main(int argc, char* argv[])
{
vector<int> var1{ 2, 0, 0, 6 };
vector<int> var2{ 2, 0, 0, 7 }; // 检测var1与var2中不匹配元素数,并输出
pair<vector<int>::iterator, vector<int>::iterator> result;
result = mismatch(var1.begin(), var1.end(), var2.begin());
if (result.first == var1.end() && result.second == var1.end())
cout << "var1 与var2完全一致" << endl;
else
// var1 和var2不相同,不匹配的数是
cout << "var1 = " << *result.first << " --> var2= " << *result.second << endl; // ---------------------------------------------------------------------------------
// 针对字符串的不匹配检测
char * str1[] = { "apple", "pear", "banana", "grape" };
char * str2[] = { "apple", "pear", "banana", "zoops" }; pair<char **, char **> result2 = mismatch(str1, str1 + 4, str2, StrEqual);
if (result2.first != str1 + 4 && result2.second != str2 + 4)
{ // 成立则说明两个str子串有不同的地方,并输出他们之间的不同点
cout << "str1 = > " << str1[result2.first - str1] << endl << endl;
cout << "str2 = > " << str2[result2.second - str2] << endl;
}
system("pause");
return 0;
}

元素相等的判断 equal: 该算法实现逐一比较两个序列的元素是否相等,该函数不返回迭代器.

#include <iostream>
#include <vector>
#include <algorithm>
using namespace std; bool absEqual(const int x,const int y)
{
return (x == abs(y) || abs(x) == y) ? 1 : 0;
} int main(int argc, char* argv[])
{
vector<int> var1;
vector<int> var2; // 初始化向量
for (unsigned int x = 0; x < var1.size(); x++)
{
var1[x] = x;
var2[x] = -1 * x;
} // 判断v1和v2元素的绝对值是否完全相等
if (equal(var1.begin(), var1.end(), var2.begin(), absEqual))
{
cout << "完全相等" << endl;
}
system("pause");
return 0;
}

子序列搜索算法 search: 该算法实现了在一个序列中搜索与另一个序列匹配的子序列.

#include <iostream>
#include <vector>
#include <algorithm>
using namespace std; int main(int argc, char* argv[])
{
vector<int> var1 = { 5, 6, 7, 8, 9 };
vector<int> var2 = { 7, 8 }; // 检查var2是否构成var1的子序列
vector<int>::iterator it;
it = search(var1.begin(), var1.end(), var2.begin(),var2.end());
if (it != var1.end())
{ // 输出var2元素包含在var1中,的起始元素为
cout << "Offset = " << it - var1.begin() << endl;
} system("pause");
return 0;
}

重复元素子序列搜索 search_n: 该算法搜索序列中是否有一系列元素值均为某个给定值得子序列.

#include <iostream>
#include <vector>
#include <algorithm>
using namespace std; int main(int argc, char* argv[])
{
vector<int> var1 = { 5, 6, 7, 8,8,8,9 }; // 查找var1中存在三个连续是8的数据
vector<int>::iterator it;
it = search_n(var1.begin(), var1.end(), 3, 8);
if (it != var1.end())
{
cout << "var1中存在三连8" << endl;
} system("pause");
return 0;
}

最后一个子序列搜索 find_end: 该算法在一个序列中搜索出最后一个与另一个序列匹配的子序列.

#include <iostream>
#include <vector>
#include <algorithm>
using namespace std; int main(int argc, char* argv[])
{
vector<int> var1 = { -5,1,2,-6,-8,1,2,-11 };
vector<int> var2 = { 1, 2 }; // var1中查找最后一个子序列var2
vector<int>::iterator it; it = find_end(var1.begin(), var1.end(), var2.begin(), var2.end());
// 打印子序列在var1的起始位置,输出起offset
if (it != var1.end())
cout << "offset = [" << it - var1.begin() << "]" << endl; system("pause");
return 0;
}

STL 变易算法(复制与拷贝)

C++ 变易算法是一组能够修改容器元素数据的模板函数,可进行序列数据的复制,交换,替换,分割,等特殊需求,这些算法对迭代器有较高的要求,具体的迭代器类型随各个算法而定,使用变易算法时应先要检查容器的迭代器是否符合要求,避免出现错误.

元素复制算法 copy: 实现容器之间元素的拷贝复制操作,将两个迭代器进行互相拷贝.

#include <iostream>
#include <vector>
#include <algorithm>
using namespace std; void MyPrint(int x) { cout << x << " "; } int main(int argc, char* argv[])
{
vector<int> var1 = { 1,3,5,7,9 };
vector<int> var2 = { 2,4,6,8,10 }; // 复制var1到var2 此时var2中的内容将被覆盖
copy(var1.begin(), var1.end(), var2.begin());
// var1 -> 覆盖到 --> var2
for_each(var2.begin(), var2.end(), MyPrint);
cout << endl; // 复制var1中的前3个元素,并输出
copy_backward(var1.begin(), var1.begin() + 2, var1.end());
for_each(var1.begin(), var1.end(), MyPrint); system("pause");
return 0;
}

元素交换算法 swap: 该算法可用于实现两个数或两个结构之间数据的互换,使用非常方便.

#include <iostream>
#include <vector>
#include <algorithm>
using namespace std; void MyPrint(int x) { cout << x << " "; } int main(int argc, char* argv[])
{
vector<int> var1 = { 1,3,5,7,9 };
vector<int> var2 = { 2,4,6,8,10 }; swap(var1, var2); // 两个容器之间数值互换
for_each(var1.begin(), var1.end(), MyPrint); iter_swap(&var1, &var2); // 通过迭代的方式实现数值互换
for_each(var2.begin(), var2.end(), MyPrint); swap_ranges(var1.begin(), var1.end(), var2.begin()); // 区间选择交换
for_each(var2.begin(), var2.end(), MyPrint); system("pause");
return 0;
}

元素搬运算法 transform: 该算法用于实现容器元素的变换操作,例如两个容器相加等操作.

#include <iostream>
#include <vector>
#include <algorithm>
using namespace std; void MyPrint(int x) { cout << x << " "; } class TransForm
{
// 在搬运的过程中每次+10写入到vTarget;
public: int operator()(int val)
{
return val + 10;
}
};
class New_TransForm
{
// 使用仿函数,将两个数组中的值相加
public: int operator()(int val1, int val2)
{
return val1 + val2;
}
}; int main(int argc, char* argv[])
{
vector<int> var = { 1,2,3,4,5 }; // 原容器
vector<int > vTarget; // 目标容器 // 第一种形式:将var中的数据每次+10后搬运到vTarget中
vTarget.resize(5); // transform 不会自动开辟内存,需要我们手动开辟
transform(var.begin(), var.end(), vTarget.begin(), TransForm());
// 循环输出 此处的 [](int val){cout << val << " "; 其实是 MyPrint 不过是匿名了
for_each(vTarget.begin(), vTarget.end(), [](int val){cout << val << " "; });
cout << endl; // 第二种形式:将var1,var2两个容器中的值相加,相加后搬运到new_vTarget容器中
vector<int> var1 = { 1, 2, 3, 4, 5 }; // 原容器
vector<int> var2 = { 6, 7, 8, 9, 10 }; // 原容器
vector<int> new_vTarget; // 目标容器
new_vTarget.resize(5);
transform(var1.begin(), var1.end(), var2.begin(), new_vTarget.begin(), New_TransForm());
for_each(new_vTarget.begin(), new_vTarget.end(), MyPrint); system("pause");
return 0;
}

元素替换算法 replace: 该算法的作用是将指定元素的旧值替换为新值.

#include <iostream>
#include <vector>
#include <algorithm>
using namespace std; void MyPrint(int x) { cout << x << " "; }
class MyCompart
{
public: bool operator()(int val){
// 将大于5的数据替换
return val > 5;
}
}; int main(int argc, char* argv[])
{
vector<int> var = { 1,2,3,4,4,5,5,6,7,8,8,9,0,2,1,0 }; // 全部替换: 将var中的4全部替换为4000
replace(var.begin(), var.end(), 4, 4000);
for_each(var.begin(), var.end(), MyPrint); // 条件替换:将所有的大于5的数替换为0
replace_if(var.begin(), var.end(), MyCompart(), 0);
for_each(var.begin(), var.end(), MyPrint); system("pause");
return 0;
}

容器元素初始化算法 fill: 该函数将同一个值填充到容器的指定位置,可用于初始化操作.

#include <iostream>
#include <vector>
#include <algorithm>
using namespace std; void MyPrint(int x) { cout << x << " "; } int main(int argc, char* argv[])
{
vector<int> var = { 1,2,3,4,4,5,5,6,7,8,8,9,0,2,1,0 }; // 将前3个元素填充为0
fill_n(var.begin(), 3, 0);
for_each(var.begin(), var.end(), MyPrint); // 全部填充为0
fill_n(var.begin(), var.size(), 0);
for_each(var.begin(), var.end(), MyPrint); // 全部填充为10
fill(var.begin(), var.end(), 10);
for_each(var.begin(), var.end(), MyPrint); system("pause");
return 0;
}

普通条件移除 remove_if: 该算法可以将容器中不等于某个值的元素移除出容器.

#include <iostream>
#include <vector>
#include <algorithm>
using namespace std; void MyPrint(int x) { cout << x << " "; }
bool even(int val) { return val % 2 ? 0 : 1; } int main(int argc, char* argv[])
{
vector<int> var { 4,3,4,8,9,5,6,7,8,9,2,1,4 }; // 移除var里面的所有的4
vector<int>::iterator result;
result = remove(var.begin(), var.end(), 4);
for_each(var.begin(), var.end(), MyPrint);
cout << endl; // 移除var里面所有的偶数
vector<int>::iterator result1;
result1 = remove_if(var.begin(), var.end(), even);
for_each(var.begin(), var.end(), MyPrint); system("pause");
return 0;
}

条件移除复制 remove_copy: 该算法将原容器中不等于某个给定值的元素复制到新容器中.

#include <iostream>
#include <vector>
#include <algorithm>
using namespace std; void MyPrint(int x) { cout << x << " "; } bool even(int val){ return val % 2 ? 0 : 1; } int main(int argc, char* argv[])
{
vector<int> var { 4,3,4,8,9,5 };
int iarray[6] = { 0, 0, 0, 0, 0, 0, }; // 移除复制,将var中的数据的前4个数据复制到iarray中,var中数据保持不变
remove_copy(var.begin(), var.end(), iarray, 4);
for_each(iarray, iarray+6, MyPrint);
cout << endl; // 移除var中的偶数,剩余元素复制到iarray中
remove_copy_if(var.begin(), var.end(), iarray, even);
for_each(iarray, iarray + 6, MyPrint);
system("pause");
return 0;
}

容器元素去重算法 unique: 提供两个算法,unique_copy实现邻近元素去重,unique去除连续重复元素.

#include <iostream>
#include <vector>
#include <algorithm>
using namespace std; void MyPrint(int x) { cout << x << " "; } int main(int argc, char* argv[])
{
vector<int> var { 2,5,5,5,5,5,6,7,5,9,5};
int iarray[] = { 0, 0, 0, 0, 0, 0, 0, 0, 0, 0 }; // 实现邻近元素去重,只能去除相邻元素中重复的
unique_copy(var.begin(), var.end(), iarray);
for_each(iarray, iarray + 10, MyPrint);
cout << endl;
// 另一种邻近元素去重算法
vector<int>::iterator result;
result = unique(var.begin(), var.end());
for_each(var.begin(),result,MyPrint); system("pause");
return 0;
}

元素反向拷贝算法 reverse: 该算法实现了对容器中元素的反向排列,和反向复制容器中的数据.

#include <iostream>
#include <vector>
#include <algorithm>
using namespace std; void MyPrint(int x) { cout << x << " "; } int main(int argc, char* argv[])
{
vector<int> var { 1,2,3,4,5,6,7,8,9,10 }; // 将元素反向排列后输出
reverse(var.begin(), var.end());
for_each(var.begin(), var.end(), MyPrint);
cout << endl; // 将元素反向复制到iarray数组中存储
int iarray[10] = { 0, 0, 0, 0, 0, 0, 0, 0, 0, 0 };
reverse_copy(var.begin(), var.end(), iarray);
for_each(iarray,iarray+10, MyPrint);
system("pause");
return 0;
}

容器旋转复制算法 rotate: 该算法用于旋转数值,需要指定一个中心数.

#include <iostream>
#include <vector>
#include <algorithm>
using namespace std; void MyPrint(int x) { cout << x << " "; } int main(int argc, char* argv[])
{
vector<int> var { 1,2,3,4,5,6,7,8,9,10 };
for_each(var.begin(), var.end(), MyPrint); // 以元素6为中心,将两边数据旋转后输出
cout << "middle => " << *(var.begin() + 5) << endl;
rotate(var.begin(), var.begin() + 5, var.end());
for_each(var.begin(), var.end(), MyPrint);
cout << endl; // 旋转后复制到iarray数组中存储
int iarray[10] = { 0, 0, 0, 0, 0, 0, 0, 0, 0, 0 };
rotate_copy(var.begin(), var.begin() + 5, var.end(), iarray);
for_each(iarray,iarray+10, MyPrint); system("pause");
return 0;
}

随机数相关算法 random: 算法generate_n用于生成随机数,random_shuffle用于打乱数组.

#include <iostream>
#include <vector>
#include <ctime>
#include <algorithm>
using namespace std; void MyPrint(int x) { cout << x << " "; } int main(int argc, char* argv[])
{
// 增加此方法,每次都可以随机打乱
srand((unsigned int)time(NULL));
vector<int> var(10); // 生成随机数:生成5个随机数,并存入var
generate_n(var.begin(), 5, rand);
for_each(var.begin(), var.end(), MyPrint);
cout << endl; // 随机抖动: 随机的打乱一个数组
int iarray[10] = { 1, 2, 3, 4, 5, 6, 7, 8, 9, 10 };
random_shuffle(iarray, iarray + 10);
for_each(iarray, iarray + 10, MyPrint); system("pause");
return 0;
}

容器元素分割算法 partition: 该算法用于重新分割排列容器的元素,第一种无序分割,第二种为有序分割.

#include <iostream>
#include <vector>
#include <algorithm>
using namespace std; void MyPrint(int x) { cout << x << " "; }
bool Less(int y){ return y < 10 ? 1 : 0; } // 判断是否小于10 int main(int argc, char* argv[])
{
int iarray[10] = { 12,45,2,6,8,-5,-12,-78,-4,3 }; // 按照小于10对容器进行分割
int * result = partition(iarray, iarray + 10, Less);
for_each(iarray, result , MyPrint); // 输出小于10的元素
cout << endl; // 按照小于10对容器分割,但保持原来的次序
int * new_ret = stable_partition(iarray, iarray + 10, Less);
for_each(iarray, iarray + 10, MyPrint);
cout << " --> 分界元素 Mid:" << *new_ret << endl; system("pause");
return 0;
}

C++ STL 标准模板库(非变易/变易)算法的更多相关文章

  1. STL标准模板库(简介)

    标准模板库(STL,Standard Template Library)是C++标准库的重要组成部分,包含了诸多在计算机科学领域里所常见的基本数据结构和基本算法,为广大C++程序员提供了一个可扩展的应 ...

  2. STL标准模板库介绍

    1. STL介绍 标准模板库STL是当今每个从事C++编程的人需要掌握的技术,所有很有必要总结下 本文将介绍STL并探讨它的三个主要概念:容器.迭代器.算法. STL的最大特点就是: 数据结构和算法的 ...

  3. STL(标准模板库)基本概念

    一.什么是STL STL(Standard Template Library,标准模板库)的从广义上讲分为三类:algorithm(算法).container(容器)和iterator(迭代器),容器 ...

  4. STL学习系列一:STL(标准模板库)理论基础

    STL(Standard Template Library,标准模板库)是惠普实验室开发的一系列软件的统称.现然主要出现在C++中,但在被引入C++之前该技术就已经存在了很长的一段时间. STL的从广 ...

  5. STL(标准模板库)理论基础,容器,迭代器,算法

    基本概念 STL(Standard Template Library,标准模板库)是惠普实验室开发的一系列软件的统称.现然主要出现在C++中,但在被引入C++之前该技术就已经存在了很长的一段时间.   ...

  6. C++ Templates STL标准模板库的基本概念

    STL标准库包括几个重要的组件:容器.迭代器和算法.迭代器iterator,用来在一个对象群集的元素上进行遍历操作.这个对象群集或许是一个容器,或许是容器的一部分.迭代器的主要好处是,为所有的容器提供 ...

  7. STL标准模板库 向量容器(vector)

    向量容器使用动态数组存储.管理对象.因为数组是一个随机访问数据结构,所以可以随机访问向量中的元素.在数组中间或是开始处插入一个元素是费时的,特别是在数组非常大的时候更是如此.然而在数组末端插入元素却很 ...

  8. C++ STL标准模板库(list)

    //list的使用 #define _CRT_SECURE_NO_WARNINGS #include<iostream> #include<list> using namesp ...

  9. STL标准模板库之vector

    目录 vector容器 1)什么是vector 2)如何定义 3)常用的Vector函数 1.容量函数 2.增加函数 3.删除函数 4.迭代器 5.访问函数 6.其他函数及操作 7.算法 STL提供了 ...

  10. STL(标准模板库) 中栈(stack)的使用方法

    STL 中栈的使用方法(stack) 基本操作: stack.push(x)  将x加入栈stack中,即入栈操作 stack.pop()  出栈操作(删除栈顶),只是出栈,没有返回值 stack.t ...

随机推荐

  1. modint 板子

    自动对 int 取模 // modint template<int MOD> struct Fp { ll val; constexpr Fp(ll v = 0) noexcept : v ...

  2. Codeforces 1092C Prefixes and Suffixes【字符串+思维】

    题目链接:点这里 题意:理解错了题意导致WA好几发,QAQ暴击 题意是判断给你的2*n-2个字符串是前缀还是后缀,不是判断这个字符串的内容...我真的欲哭无泪,理解能力太菜了 思路:将两个n-1长的字 ...

  3. 2.5D 组态案例合集 | 智慧园区、数据中心、SMT 生产线、汽车制造

    在阅读文章之前,大家可以思考下 2.5D 设计属于哪种界定? 2.5D 是通过二维的元素来呈现出三维的效果.其实在国外并没有 2.5D 这样的称呼,标准说法是 Isometric 风格,翻译过来就是等 ...

  4. 打包报错,提示UglifyJs Unexpected token: keyword «const»

    https://blog.csdn.net/weixin_43473561/article/details/102816018 原因:ugluifyjs当前版本不符合项目预期(可能不能解析es6) 解 ...

  5. nginx 工作原理及特点

    本文为博主原创,未经允许不得转载: nginx 简介:是一个高性能 HTTP 和 反向代理 服务器. Nginx 特点是占有内存少,并发能力强,事实上 Nginx 的并发能力确实在同类型的网页服务器中 ...

  6. pojo层、dao层、service层、controller层的作用

    分层解耦介绍 1.pojo层(model) 实体层 数据库在项目中的类 model是模型的意思,与entity.domain.pojo类似,是存放实体的类. 类中定义了多个类属性,并与数据库表的字段保 ...

  7. 【TouchGFX】IAR 下实现 touchgfx Caching Bitmaps 通过文件方式获取图像资源

    1.Caching Bitmaps 修改缓存方式 2.修改 blockCopy 方法(注意:忘记返回状态导致发生错误) 3.修改分散文件将位于 ExtFlashSection section 数据重定 ...

  8. [转帖]高并发下nginx配置模板

    user web;       # One worker process per CPU core.   worker_processes 8;       # Also set   # /etc/s ...

  9. 人大金仓学习之四-kmonitor

    人大金仓学习之四-kmonitor 背景 kmonitor 其实时一个很好的工具和思路 开元的软件封装一下, 减轻技术复杂度,提高部署效率 并且能够更加快速的定位解决问题. 能够极大的提升客户体验. ...

  10. [转帖]/dev/null 2>&1详解

    https://www.diewufeiyang.com/post/1045.html shell中可能经常能看到:>/dev/null 2>&1 命令的结果可以通过%>的形 ...