算法库
算法概念
算法主要是由头文件
组成。
是所有STL头文件中最大的一个,其中常用的功能涉及到比较，交换，查找,遍历，复制，修改，反转，排序，合并等...
体积很小，只包括在几个序列容器上进行的简单运算的模板函数.
定义了一些模板类,用以声明函数对象。
1.算法通过迭代器来操作容器中元素
2.算法的头文件:
遍历算法
1.for_each：遍历打印
1.for_each(开始迭代器，结束迭代器，函数对象)
/*
遍历算法 遍历容器元素
@param beg 开始迭代器
@param end 结束迭代器
@param _callback 函数回调或者函数对象
@return 函数对象
*/
for_each(iterator beg, iterator end, _callback);
for_each:
/*
template<class _InIt,class _Fn1> inline
void for_each(_InIt _First, _InIt _Last, _Fn1 _Func)
{
for (; _First != _Last; ++_First)
_Func(*_First);
}
*/
//普通函数
void print01(int val){
cout << val <<" ";
}
//函数对象
struct print001{
voidoperator()(int val){
cout << val <<" ";
}
};
//for_each算法基本用法
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(), print001());
cout << endl;
}
struct print02{
print02(){
mCount =0;
}
voidoperator()(int val){
cout << val <<" ";
mCount++;
}
int mCount;
};
//for_each返回值 返回仿函数的class
void test02(){
vector<int> v;
for(int i =0; i <10; i++){
v.push_back(i);
}
print02& p = for_each(v.begin(), v.end(), print02());
cout << endl;
cout << p.mCount << endl; //打印了几次
}
//将二元仿函数 配置成 一元仿函数
struct print03 :public binary_function<int,int,void>{
voidoperator()(int val,int bindParam)const{
cout << val + bindParam <<" ";
}
};
//for_each绑定参数输出
void test03(){
vector<int> v;
for(int i =0; i <10; i++){
v.push_back(i);
}
for_each(v.begin(), v.end(), bind2nd(print03(),100));
}
2.transform:搬运
1.transform（源开始迭代器，源结束迭代器，目标开始迭代器，函数对象）
2.transform（源1开始迭代器，源1结束迭代器，源2开始迭代器，目标开始迭代器，函数对象）
//transform 将一个容器中的值搬运到另一个容器中
/*
transform算法 将指定容器区间元素搬运到另一容器中
** 注意 : transform 不会给目标容器分配内存，所以需要我们提前分配好内存
@param beg1 源容器开始迭代器
@param end1 源容器结束迭代器
@param beg2 目标容器开始迭代器
@param _cakkback 回调函数或者函数对象
@return 返回目标容器迭代器
*/
transform(iterator beg1, iterator end1, iterator beg2, _callbakc)
/*
template<class _InIt, class _OutIt, class _Fn1> inline
_OutIt _Transform(_InIt _First, _InIt _Last,_OutIt _Dest, _Fn1 _Func)
{
for (; _First != _Last; ++_First, ++_Dest)
*_Dest = _Func(*_First);
return (_Dest);
}
template<class _InIt1,class _InIt2,class _OutIt,class _Fn2> inline
_OutIt _Transform(_InIt1 _First1, _InIt1 _Last1,_InIt2 _First2, _OutIt _Dest, _Fn2 _Func)
{
for (; _First1 != _Last1; ++_First1, ++_First2, ++_Dest)
*_Dest = _Func(*_First1, *_First2);
return (_Dest);
}
*/
struct transformTest01{
intoperator()(int val){
return val +100;
}
};
struct print01{
voidoperator()(int val){
cout << val <<" ";
}
};
void test01(){
vector<int> vSource;
for(int i =0; i <10;i ++){
vSource.push_back(i +1);
}
//目标容器
vector<int> vTarget;
//给vTarget开辟空间
vTarget.resize(vSource.size());
//将vSource中的元素搬运到vTarget
//当左右值都可以
vector<int>::iterator it = transform(vSource.begin(), vSource.end(), vTarget.begin(), transformTest01());
//打印
for_each(vTarget.begin(), vTarget.end(), print01()); cout << endl;
}
//将容器1和容器2中的元素相加放入到第三个容器中
struct transformTest02{
intoperator()(int v1,int v2){
return v1 + v2;
}
};
void test02(){
vector<int> vSource1;
vector<int> vSource2;
for(int i =0; i <10; i++){
vSource1.push_back(i +1);
}
//目标容器
vector<int> vTarget;
//给vTarget开辟空间
vTarget.resize(vSource1.size());
transform(vSource1.begin(), vSource1.end(), vSource2.begin(),vTarget.begin(), transformTest02());
//打印
for_each(vTarget.begin(), vTarget.end(), print01()); cout << endl;
}
查找算法
1.find:查找元素
find(开始迭代器，结束迭代器，要查找的数值);
find_if(开始迭代器，结束迭代器,谓词或函数对象);
//谓词
bool Myprint(int v)
{
return v > 30;
}
void test01()
{
vector<int> v;
v.push_back(10);
v.push_back(20);
v.push_back(30);
v.push_back(40);
v.push_back(50);
/*
_InIt _Find(_InIt _First, _InIt _Last, const _Ty& _Val, false_type)
{
for (; _First != _Last; ++_First)
if (*_First == _Val)
break;
return (_First);
}
*/
vector<int>::iterator it=find(v.begin(), v.end(), 20);
if (it == v.end())
{
cout << "查找失败" << endl;
}
else
{
cout << "查找成功=" << *it << endl;
}
/*
_InIt _Find_if(_InIt _First, _InIt _Last, _Pr _Pred)
{ // find first satisfying _Pred
for (; _First != _Last; ++_First)
if (_Pred(*_First))
break;
return (_First);
}
*/
it=find_if(v.begin(), v.end(), Myprint);
if (it == v.end())
{
cout << "查找失败" << endl;
}
else
{
cout << "查找成功=" << *it << endl;
}
}
//查找对象
class Maker
{
public:
Maker(string name, int age)
{
this->name = name;
this->age = age;
}
//重载==
bool operator==(const Maker& m)
{
return this->name == m.name && this->age == m.age;
}
public:
string name;
int age;
};
//为仿函数增加参数
struct MyFind:public binary_function<Maker,Maker,bool>
{
bool operator()(Maker m,Maker m2)const
{
return m.name == m2.name && m.age == m2.age;
}
};
void test02()
{
vector<Maker> v;
v.push_back(Maker("aaa1", 18));
v.push_back(Maker("aaa2", 20));
v.push_back(Maker("aaa3", 21));
v.push_back(Maker("aaa4", 22));
v.push_back(Maker("aaa5", 23));
vector<Maker>::iterator it = find(v.begin(), v.end(), Maker("aaa2", 20));
if (it == v.end())
{
cout << "查找失败" << endl;
}
else
{
cout << "查找成功=" << it->name<<" "<<it->age<< endl;
}
it = find_if(v.begin(), v.end(), bind2nd(MyFind(),Maker("aaa3",21)));
if (it == v.end())
{
cout << "查找失败" << endl;
}
else
{
cout << "查找成功=" << it->name << " " << it->age << endl;
}
}
2.adjacent_find算法 查找相邻重复元素
adjacent_find(开始迭代器，结束迭代器)
adjacent_find(开始迭代器，结束迭代器,谓词或函数对象);
class Maker2
{
public:
Maker2(string name, int age)
{
this->name = name;
this->age = age;
}
public:
string name;
int age;
};
//二元谓词
bool myadjacent_find(Maker2 &m1,Maker2 &m2)
{
return m1.name == m2.name &&m1.age == m2.age;
}
void test03()
{
vector<int> v;
v.push_back(10);
v.push_back(40);
v.push_back(40);
v.push_back(40);
v.push_back(50);
v.push_back(60);
/*
_FwdIt adjacent_find(_FwdIt _First, _FwdIt _Last)
{ // find first matching successor
return (_STD adjacent_find(_First, _Last, equal_to<>()));
}
*/
vector<int>::iterator it=adjacent_find(v.begin(), v.end()); //默认使用内建函数对象equal_to<>()
if (it == v.end())
{
cout << "查找相邻的重复元素失败" << endl;
}
else
{
cout << "查找成功:" << *it << endl;
}
/*
_FwdIt _Adjacent_find(_FwdIt _First, _FwdIt _Last, _Pr _Pred)
{
if (_First != _Last)
for (_FwdIt _Firstb; (_Firstb = _First), ++_First != _Last; )
if (_Pred(*_Firstb, *_First)) //二元谓词
return (_Firstb);
return (_Last);
}
*/
vector<Maker2> v2;
v2.push_back(Maker2("aaa1", 10));
v2.push_back(Maker2("aaa4", 40));
v2.push_back(Maker2("aaa4", 30));
v2.push_back(Maker2("aaa4", 40));
v2.push_back(Maker2("aaa5", 50));
vector<Maker2>::iterator it2 = adjacent_find(v2.begin(), v2.end(), myadjacent_find);
if (it2 == v2.end())
{
cout << "查找相邻的重复元素失败" << endl;
}
else
{
cout << "查找成功:" << it2->name<<" "<<it2->age << endl;
}
}
3.binary_search算法 二分查找法,注意：数据必须要有序，返回值是bool
binary_search(开始迭代器，结束迭代器,数值)；
binary_search（开始迭代器，结束迭代器,对象，函数对象）；
注意：存储对象，如果使用less，那么数据要是升序,并且要重载<，greater这需要数据是降序，并且要重载>
class Student
{
public:
Student(string name, int age)
{
this->name = name;
this->age = age;
}
//greater
bool operator>(const Student &stu)const
{
return this->age > stu.age;
}
//less
bool operator<(const Student &stu)const
{
return this->age < stu.age;
}
public:
string name;
int age;
};
void test04()
{
vector<int> v;
v.push_back(10);
v.push_back(20);
v.push_back(30);
v.push_back(40);
v.push_back(50);
v.push_back(60);
bool flg = binary_search(v.begin(), v.end(), 30);
if (flg)
{
cout << "找到" << endl;
}
else
{
cout << "没有找到" << endl;
}
vector<Student> vs;
vs.push_back(Student("a1", 1));
vs.push_back(Student("a2", 2));
vs.push_back(Student("a3", 3));
vs.push_back(Student("a4", 4));
vs.push_back(Student("a5", 5));
/*
bool binary_search(_FwdIt _First, _FwdIt _Last,const _Ty& _Val, _Pr _Pred)
{
_First = _STD lower_bound(_First, _Last, _Val, _Pred);
return (_First != _Last && !_Pred(_Val, *_First));
}
*/
//存储对象，如果使用less，那么数据要是升序,并且要重载<，greater这需要数据是降序，并且要重载>
bool flg2 = binary_search(vs.begin(), vs.end(), Student("a4", 4), less<Student>()); //缺省使用less
if (flg2)
{
cout << "找到" << endl;
}
else
{
cout << "没有找到" << endl;
}
}
4.count 统计元素个数
count（开始迭代器，结束迭代器,数值）；
count（开始迭代器，结束迭代器，谓词或函数对象）；
void test05()
{
vector<int> v;
v.push_back(1);
v.push_back(1);
v.push_back(2);
v.push_back(1);
v.push_back(3);
v.push_back(4);
v.push_back(4);
//查询1有多少个元素
int n=count(v.begin(), v.end(), 1);
cout << n << endl;
//大于2的元素有多少个
n = count_if(v.begin(), v.end(), [](int val)->bool{return val > 2; });
cout << n << endl;
}
/*
find算法 查找元素
@param beg 容器开始迭代器
@param end 容器结束迭代器
@param value 查找的元素
@return 返回查找元素的位置
*/
find(iterator beg, iterator end, value)
/*
adjacent_find算法 查找相邻重复元素
@param beg 容器开始迭代器
@param end 容器结束迭代器
@param _callback 回调函数或者谓词(返回bool类型的函数对象)
@return 返回相邻元素的第一个位置的迭代器
*/
adjacent_find(iterator beg, iterator end, _callback);
/*
binary_search算法 二分查找法
注意: 在无序序列中不可用
@param beg 容器开始迭代器
@param end 容器结束迭代器
@param value 查找的元素
@return bool 查找返回true 否则false
*/
bool binary_search(iterator beg, iterator end, value);
/*
find_if算法 条件查找
@param beg 容器开始迭代器
@param end 容器结束迭代器
@param callback 回调函数或者谓词(返回bool类型的函数对象)
@return bool 查找返回true 否则false
*/
find_if(iterator beg, iterator end, _callback);
/*
count算法 统计元素出现次数
@param beg 容器开始迭代器
@param end 容器结束迭代器
@param value回调函数或者谓词(返回bool类型的函数对象)
@return int返回元素个数
*/
count(iterator beg, iterator end, value);
/*
count算法 统计元素出现次数
@param beg 容器开始迭代器
@param end 容器结束迭代器
@param callback 回调函数或者谓词(返回bool类型的函数对象)
@return int返回元素个数
*/
count_if(iterator beg, iterator end, _callback);
排序算法
1.merge算法 容器元素合并，并存储到另一容器中
1.如果数据是升序，那么第六个参数就不用写
merge(开始迭代器1，结束迭代器1，开始迭代器2，结束迭代器2，目标开始迭代器)；
2.如果数据是降序，那么第六个参数就要写greater
merge(开始迭代器1，结束迭代器1，开始迭代器2，结束迭代器2，目标开始迭代器，greater
//merge算法 容器元素合并，并存储到另一容器中
void test01()
{
vector<int> v1;
vector<int> v2;
for (int i = 5; i >=0; i--)
{
v1.push_back(i + 1);
v2.push_back(i + 2);
}
vector<int> v3;
v3.resize(v1.size() + v2.size());
//如果数据是升序，那么第六个参数就不用写
/*merge(v1.begin(), v1.end(), v2.begin(), v2.end(), v3.begin());
for_each(v3.begin(), v3.end(), [](int val){cout << val << " "; });*/
////如果数据是降序，那么第六个参数就要写greater<int>()
merge(v1.begin(), v1.end(), v2.begin(), v2.end(), v3.begin(),greater<int>());
for_each(v3.begin(), v3.end(), [](int val){cout << val << " "; });
}
2.sort算法 容器元素排序
1.sort(开始迭代器，结束迭代器)；
2.存储的是对象时,sort(开始迭代器，结束迭代器,函数对象)；
void test02()
{
vector<int> v;
v.push_back(8);
v.push_back(12);
v.push_back(2);
v.push_back(7);
v.push_back(3);
sort(v.begin(), v.end());
for_each(v.begin(), v.end(), [](int val){cout << val << " "; });
//如果元素是对象，那么要写第三个参数
//sort(v.begin(), v.end(),函数对象);
}
3.random_shuffle：洗牌
定义随机种子：srand((unsigned int)time(NULL));
random_shuffle（开始迭代器，结束迭代器）
void test03()
{
vector<int> v1;
for (int i = 0; i < 10; i++)
{
v1.push_back(i + 1);
}
for_each(v1.begin(), v1.end(), [](int val){cout << val << " "; });
cout << endl;
srand((unsigned int)time(NULL)); //保证程序在不同时间会不同的数
random_shuffle(v1.begin(), v1.end());
for_each(v1.begin(), v1.end(), [](int val){cout << val << " "; });
cout << endl;
}
4.reverse算法 反转指定范围的元素
reverse（开始迭代器，结束迭代器）
void test04()
{
vector<int> v1;
for (int i = 0; i < 10; i++)
{
v1.push_back(i + 1);
}
for_each(v1.begin(), v1.end(), [](int val){cout << val << " "; });
cout << endl;
reverse(v1.begin(), v1.end());
for_each(v1.begin(), v1.end(), [](int val){cout << val << " "; });
cout << endl;
}
/*
merge算法 容器元素合并，并存储到另一容器中
@param beg1 容器1开始迭代器
@param end1 容器1结束迭代器
@param beg2 容器2开始迭代器
@param end2 容器2结束迭代器
@param dest 目标容器开始迭代器
*/
merge(iterator beg1, iterator end1, iterator beg2, iterator end2, iterator dest)
/*
sort算法 容器元素排序
注意:两个容器必须是有序的
@param beg 容器1开始迭代器
@param end 容器1结束迭代器
@param _callback 回调函数或者谓词(返回bool类型的函数对象)
*/
sort(iterator beg, iterator end, _callback)
/*
random_shuffle算法 对指定范围内的元素随机调整次序
@param beg 容器开始迭代器
@param end 容器结束迭代器
*/
random_shuffle(iterator beg, iterator end)
/*
reverse算法 反转指定范围的元素
@param beg 容器开始迭代器
@param end 容器结束迭代器
*/
reverse(iterator beg, iterator end)
拷贝和替换算法
1.copy：拷贝
copy(源开始迭代器，源结束迭代器，目标开始迭代器)；
//拷贝
void test01()
{
vector<int> v;
v.push_back(10);
v.push_back(20);
v.push_back(30);
v.push_back(40);
vector<int> v2;
v2.resize(v.size());
copy(v.begin(), v.end(), v2.begin());
for_each(v2.begin(), v2.end(), [](int val){cout << val << " "; });
}
2.replace算法 将容器内指定范围的旧元素修改为新元素，replace_if算法 将容器内指定范围满足条件的元素替换为新元素
1.replace（开始迭代器，结束迭代器，旧值，新值）；
//replace算法 将容器内指定范围的旧元素修改为新元素
//replace_if算法 将容器内指定范围满足条件的元素替换为新元素
void test02()
{
vector<int> v;
v.push_back(10);
v.push_back(20);
v.push_back(30);
v.push_back(40);
for_each(v.begin(), v.end(), [](int val){cout << val << " "; });
cout << endl;
replace(v.begin(), v.end(), 20, 200);
for_each(v.begin(), v.end(), [](int val){cout << val << " "; });
cout << endl;
}
2.replace_if(开始迭代器，结束迭代器,谓词,新值)；
bool myfunc(int val)
{
return val > 30;
}
/*
void _Replace_if(_FwdIt _First, _FwdIt _Last, _Pr _Pred, const _Ty& _Val)
{ // replace each satisfying _Pred with _Val
for (; _First != _Last; ++_First)
if (_Pred(*_First))
*_First = _Val;
}
*/
void test02()
{
vector<int> v;
v.push_back(10);
v.push_back(20);
v.push_back(30);
v.push_back(40);
replace_if(v.begin(), v.end(), myfunc, 300);
for_each(v.begin(), v.end(), [](int val){cout << val << " "; });
cout << endl;
}
3.swap，交换容器
swap(容器1，容器2)；
void test03()
{
vector<int> v1;
v1.push_back(1);
v1.push_back(2);
v1.push_back(3);
vector<int> v2;
v2.push_back(100);
v2.push_back(200);
v2.push_back(300);
swap(v1, v2);
for_each(v1.begin(), v1.end(), [](int val){cout << val << " "; });
cout << endl;
for_each(v2.begin(), v2.end(), [](int val){cout << val << " "; });
cout << endl;
}
/*
copy算法 将容器内指定范围的元素拷贝到另一容器中
@param beg 容器开始迭代器
@param end 容器结束迭代器
@param dest 目标容器结束迭代器
*/
copy(iterator beg, iterator end, iterator dest)
/*
replace算法 将容器内指定范围的旧元素修改为新元素
@param beg 容器开始迭代器
@param end 容器结束迭代器
@param oldvalue 旧元素
@param oldvalue 新元素
*/
replace(iterator beg, iterator end, oldvalue, newvalue)
/*
replace_if算法 将容器内指定范围满足条件的元素替换为新元素
@param beg 容器开始迭代器
@param end 容器结束迭代器
@param callback函数回调或者谓词(返回Bool类型的函数对象)
@param oldvalue 新元素
*/
replace_if(iterator beg, iterator end, _callback, newvalue)
/*
swap算法 互换两个容器的元素
@param c1容器1
@param c2容器2
*/
swap(container c1, container c2)
算术生成算法
头文件 #include
1.accumulate算法 计算容器元素累计总和
1.int ret=accumulate（开始迭代器，结束迭代器，数值）；//第三个参数是在总和上再加上0
2.int ret=accumulate(开始迭代器，结束迭代器，数值,函数对象)；//针对存储对象
void test01()
{
vector<int> v;
v.push_back(10);
v.push_back(20);
v.push_back(30);
//第三个参数是在总和上再加上0
int ret=accumulate(v.begin(), v.end(), 0);
cout << ret << endl;
}
class Maker
{
public:
Maker(int age)
{
this->age = age;
}
public:
int age;
};
struct MyPuls
{
int operator()(int val,Maker &m)
{
return val + m.age;
}
};
void test02()
{
vector<Maker> v;
v.push_back(Maker(10));
v.push_back(Maker(20));
v.push_back(Maker(30));
int ret = accumulate(v.begin(), v.end(),0, MyPuls());
cout << ret << endl;
}
2.fill算法 向容器中添加元素
1.要开辟容器的空间.v.resize(10);
2.fill(开始迭代器，结束迭代器,要填充的数值)
void test03()
{
vector<int> v;
//要开辟空间
v.resize(10);
fill(v.begin(), v.end(), 100);
for_each(v.begin(), v.end(), [](int val){cout << val << " "; });
}
c
/*
accumulate算法 计算容器元素累计总和
@param beg 容器开始迭代器
@param end 容器结束迭代器
@param value累加值
*/
accumulate(iterator beg, iterator end, value)
/*
fill算法 向容器中添加元素
@param beg 容器开始迭代器
@param end 容器结束迭代器
@param value t填充元素
*/
fill(iterator beg, iterator end, value)
集合算法
1.注意:两个集合必须是有序序列
2.set_intersection算法 求两个集合的交集
set_intersection（源开始迭代器1，源结束迭代器1，源开始迭代器2，源结束迭代器2，,目标开始迭代器）；
//set_intersection算法 求两个set集合的交集
//注意:两个集合必须是有序序列
void test01()
{
vector<int> v1;
for (int i = 0; i < 10; i++)
{
v1.push_back(i);
}
vector<int> v2;
for (int i = 5; i < 15; i++)
{
v2.push_back(i);
}
vector<int> v3;
v3.resize(min(v1.size(), v2.size()));
set_intersection(v1.begin(), v1.end(), v2.begin(), v2.end(), v3.begin());
for_each(v3.begin(), v3.end(), [](int val){cout << val << " "; });
}
3.set_union算法 求两个set集合的并集
set_union（源开始迭代器1，源结束迭代器1，源开始迭代器2，源结束迭代器2，,目标开始迭代器）；
//set_union算法 求两个set集合的并集
void test02()
{
vector<int> v1;
for (int i = 0; i < 10; i++)
{
v1.push_back(i);
}
vector<int> v2;
for (int i = 5; i < 15; i++)
{
v2.push_back(i);
}
vector<int> v3;
v3.resize(v1.size() + v2.size());
set_union(v1.begin(), v1.end(), v2.begin(), v2.end(), v3.begin());
for_each(v3.begin(), v3.end(), [](int val){cout << val << " "; });
}
4.set_difference算法 求两个set集合的差集
//假如A集合有1,2,3,4,5 B集合有2,3,4,5,6 A集合减B集合的结果就是1
set_difference（源开始迭代器1，源结束迭代器1，源开始迭代器2，源结束迭代器2，,目标开始迭代器）；
void test03()
{
vector<int> v1;
for (int i = 1; i < 6; i++)
{
v1.push_back(i);
}
vector<int> v2;
for (int i = 2; i < 7; i++)
{
v2.push_back(i);
}
vector<int> v3;
v3.resize(min(v1.size(), v2.size()));
set_difference(v1.begin(), v1.end(), v2.begin(), v2.end(), v3.begin());
for_each(v3.begin(), v3.end(), [](int val){cout << val << " "; });
}
/*
set_intersection算法 求两个set集合的交集
注意:两个集合必须是有序序列
@param beg1 容器1开始迭代器
@param end1 容器1结束迭代器
@param beg2 容器2开始迭代器
@param end2 容器2结束迭代器
@param dest 目标容器开始迭代器
@return 目标容器的最后一个元素的迭代器地址
*/
set_intersection(iterator beg1, iterator end1, iterator beg2, iterator end2, iterator dest)
/*
set_union算法 求两个set集合的并集
注意:两个集合必须是有序序列
@param beg1 容器1开始迭代器
@param end1 容器1结束迭代器
@param beg2 容器2开始迭代器
@param end2 容器2结束迭代器
@param dest 目标容器开始迭代器
@return 目标容器的最后一个元素的迭代器地址
*/
set_union(iterator beg1, iterator end1, iterator beg2, iterator end2, iterator dest)
/*
set_difference算法 求两个set集合的差集
注意:两个集合必须是有序序列
@param beg1 容器1开始迭代器
@param end1 容器1结束迭代器
@param beg2 容器2开始迭代器
@param end2 容器2结束迭代器
@param dest 目标容器开始迭代器
@return 目标容器的最后一个元素的迭代器地址
*/
set_difference(iterator beg1, iterator end1, iterator beg2, iterator end2, iterator dest)
浙公网安备 33010602011771号