C++语言之函数对象与算法

在 C++ 中，函数对象（Function Object）也叫仿函数（Functor），是一个类，这个类重载了()运算符。从概念上讲，它的行为类似于一个函数，可以像调用函数一样来调用这个类的对象。
 

例如，下面是一个简单的函数对象类：
        class Add {
        public:
            int operator()(int a, int b) {
                return a + b;
            }
        };

        int main()

        {

                //函数对象(仿函数)

                Add add;

                return 0;

        }

这个Add类就是一个函数对象。它重载了()运算符，使得该类的对象可以像函数一样被调用。


作用:为算法提供策略

谓词

返回值为bool类型的普通函数或仿函数都叫谓词


有一个参数叫一元谓词

有两个参数叫二元谓词

#include <iostream>

using namespace std;

//谓词

bool method01()

{        }

//谓词

class MyClass{

public:

        bool operator()()

        {        }

};

//一元谓词

bool method02(int x)

{

}

//二元谓词

bool method03(int x,int y)

{

}

int main()

{

        return 0;

}

小括号调用问题

#include <iostream>

using namespace std;

class MyClass

{

 public:

        MyClass()

        {

                cout<<"无参构造"<<endl;

        }

        MyClass(int x)

        {

                cout<<"有参构造"<<endl;

        }

        bool operator()()

        {

                cout<<"自定义谓词"<<endl;

                return true;

        }

};

int main()

{

        //函数对象(仿函数)

        //MyClass c();        //创建对象后有()不知道调用什么

        //MyClass c;        //此时调用无参构造

        //MyClass c(10);        //此时调用有参构造

        //MyClass * c = new MyClass;        //此时调用无参构造

        MyClass * c = new MyClass(10);        //此时调用有参构造

        bool b = (*c)()        //用已经创建的对象后有()是调用重载的()运算符


        return 0;

}

内建函数对象

C++提供的函数对象              

 算法类函数对象

template<class T> T plus<T>//加法仿函数

template<class T> T minus<T>//减法仿函数

template<class T> T multiplies<T>//乘法仿函数

template<class T> T divides<T>//除法仿函数

template<class T> T modulus<T>//取模(取余)仿函数

template<class T> T negate<T>//取反仿函数

注意:6个算数类函数对象,除了negate是一元运算,其他都是二元运算

#include<iostream>

using namespace std;

int main()

{

        //template<class T> T plus<T>//加法仿函数

        plus<int> pl;

        int x = pl(10,21);

        cout<<x<<endl;

        //template<class T> T minus<T>//减法仿函数

        minus<int> min;

        int y = min(10,21);

        cout<<y<<endl;

        //....

        //template<class T> T negate<T>//取反仿函数,不能对bool取反

        negate<int> neg;

        int z = neg(-10);

        cout<<z<<endl;

        
        return 0;

}

关系运算类函数对象

template<class T>bool equal_to<T>        //等于

template<class T>bool not_equal_to<T>        //不等于

template<class T>bool greater<T>        //大于

template<class T>bool greater_equal<T>        //大于等于

template<class T>bool less<T>        //小于

template<class T>bool less_equal<T>        //小于等于

#include <iostream>

#include <string>

#include <stdlib.h>

#incldue <string.h>

using namespace std;

int main()

{

       // template<class T>bool equal_to<T>//等于

        equal_to<int> eq;

        bool b1 = eq(1,1);

        cout<<b1<<endl;

        char* str01 = (char*) calloc(6,1);

        strcpy(str01,"hello");

        char* str02 = (char*)calloc(6,1);

        strcpy(str02,"hello");

        

        string s01 = sstr01;

        string s02 = str02;

        equal_to<string> eq;

        bool b3 = eq(s01,s02);

        cout<<b3<<endl;

        

        return 0;

}

逻辑运算类运算函数

template<class T>bool logical_and<T> //逻辑与

template<class T>bool logical_or<T>//逻辑或

template<class T>bool logical_not<T>//逻辑非


注意:这三个逻辑运算类运算函数,not为一元谓词,其余为二元谓词

#include<iostream>

using namespace std;

int main()

{

        //template<class T>bool logical_and<T> //逻辑与

        logical_and<bool> a;

        bool b1 = a(true,true);

        cout<<b1<<endl;

        
        return 0;

}

适配器

在 C++ 中，适配器（Adapter）是一种设计模式的实现，它将一个类的接口转换成另一个接口，以满足用户的需求。适配器就像是一个转换器，使得原本不兼容的接口能够协同工作。

从广义上来说，C++ 中有函数适配器、容器适配器等不同类型。

函数对象适配器

以对象作为适配器


使用:

        bind2nd将绑定的数据放置第二个参数位置

        bind1st将绑定的数据放置在第一个参数位置

步骤:

        1,创建一个类

        2,使该类继承于binary_function

        3,泛型萃取

                第一泛型为重载的()运算符中第一个形参的数据类型

                第二泛型为重载的()运算符中第二个形参的数据类型

                第三泛型为重载的()运算符中返回值的数据类型

        4,在该类中重载()运算符,尾部加const

        5,创建该类对象

        6,使用算法,在算法适配器中使用bind1st或bind2nd绑定该对象与传入的值

//1,2,3

class Adapter:public binary_function<int,int,void>

{

//4

public:

         void operator()(int x,int y)const

        {

                

        }       

};

//5

Adapter a;

for_each(v.bedin(),v.end(),bind1st(a,10));

函数指针适配器

以全局函数作为适配器


使用:

        bind2nd将绑定的数据放置在第二个参数位置

        bind1st将绑定的数据放置在第一个参数位置
        ptr_fun(函数名)

步骤:

        1,定义一个全局变量,该函数两个参数

        2,使用算法,在算法适配器中使用bind1st或bind2nd绑定该函数与传入的值

#include<iostream>

#include<set>

#include<algorithm>

void my_method(int x,int y)

{

        cout<<x<<endl;

        cout<<y<<end;

}

int main()

{

        set<int> 5;

        s.insert(1);

        s.insert(2);

        s.insert(3);

        s.insert(4);

        for_each(s.begin(),s.end(),bind2nd(ptr_fun(my_method),100)};

        return 0;

成员函数适配器

以成员函数作为适配器


使用:

        bind2nd将绑定的数据放置到第二个参数位置

        bind1st将绑定的数据放置到第一个参数的位置

        

        mem_fun_ref(&类名::函数名):注意其包含的函数只能有一个参数

步骤:

        1,创建一个类

        2,在该类中编写成员函数

        3,使用算法,在算法适配器中使用mem_fun_ref包括该函数

注意:

        集合中存储的对象所在的类与成员函数所在的类为同一个类

        该函数必须是无参的

        集合中获取的数据就是该类中的this

#include <iostream>

#include <list>

#include <algorithm>

using namespace std;

class Data

{

 public:

        int x;

        Data(int x):x(x){        }

        void my_method()

        {

                cout<<this->x<<endl;       

        }      

};

int main()

{

        list<Data> l;

        l.push_back(Data(1));

        l.push_back(Data(2));

        l.push_back(Data(3));

        l.push_back(Data(4));

        for_each(l.begin(),l.end(),mem_fun_ref(&Data::my_method));

        

        return 0;

}

取反适配器

not1        一元函数对象取反

not2        二元函数对象取反

#include <iostream>

#include <vector>

#include <algorithm>

using namespace std;

void show(int x)

{

        cout<<x<<",";

}

bool compare(int x,int y)

{

        return x<y;

}

class Myclass:public binary_function<int,int,bool>

{

public:

        bool operator()(int x,int y)const

        {

                return x>y;

        }        

};

int main()

{

        vector<int> nums;

        nums.push_back(2);
        nums.push_back(1);
        nums.push_back(3);
        nums.push_back(6);
        nums.push_back(9);

  

        for_each(nums.begin(),nums.end(),ptr_fun(show));

        cout << endl;
        //查找 vector 中第一个大于 5 的值
        // vector<int>::iterator it =
        find_if(nums.begin(),nums.end(),bind2nd(ptr_fun(dy5),5));
        // auto it =
        find_if(nums.begin(),nums.end(),bind2nd(MyClass(),5));
        auto it =
        find_if(nums.begin(),nums.end(),not1(bind2nd(MyClass(),5)));
        cout << *it << endl;
        //排序算法
        sort(nums.begin(),nums.end(),not2(less<int>()));
        for_each(nums.begin(),nums.end(),ptr_fun(show));
        cout << endl;
        return 0;

}

算法


遍历

for_each

/*
遍历算法 遍历容器元素
@param beg 开始迭代器
@param end 结束迭代器
@param _callback 函数回调或者函数对象
@return 函数对象
*/
for_each(iterator beg, iterator end, _callback);
//基本使用
#include <iostream>
#include <deque>
#incldue <algorithm>
using namespace std;
void myMethod(int x)
{
        cout<<x<<",";
}
int main()
{
        deque<int> d;
        d.push_back(1);
        d.push_back(2);
        d.push_back(3);
        d.push_back(4);
        d.push_back(5);
        for_each(d.begin(),d.end(),myMthod);
        return 0;
}
案例2:lamba表达式
注意:c++11及以上版本才可使用
作用:简化函数
语法:
        [](形参列表)
        {
              函数体
        }
#include <iostream>
#include <deque>
#include <algorithm>
using namespace std;

void myMethod(int x)
{
        cout<<x<<",";
}
int mian()
{
        deque<int> d;
        d.push_back(1);
        d.push_back(2);
        d.push_back(3);
        d.push_back(4);
        d.push_back(5);
        
        for_each(d.begin(),d.end(),[](int x)
        {
                cout<<x<<",";
        });
        return 0;
}
// 案例 3: 遍历存储自定义类型的集合
class Data{
private:
        int x;
        int y;
public:
        Data(int x,int y):x(x),y(y){}
        void showData()
        {
                cout << "x = " << x << "\ty = " << y << endl;
        }
};
void fun02()
{
        deque<Data> d;
        d.push_back(Data(1,11));
        d.push_back(Data(2,22));
        d.push_back(Data(3,33));
        for_each(d.begin(),d.end(),[](Data& data){
                data.showData();
        });
}

transform

作用:搬运

语法:

        /*

        transform 算法 将指定容器区间元素搬运到另一容器中
         注意 :transform 不会给目标容器分配内存，所以需要我们提前分配好内存
        @param beg1 源容器开始迭代器
        @param end1 源容器结束迭代器
        @param beg2 目标容器开始迭代器
        @param _cakkback 回调函数或者函数对象
        @return 返回目标容器迭代器
        */
        transform(iterator beg1, iterator end1, iterator beg2, _callbakc);
        /*
         transform 算法 将指定容器区间元素搬运到另一容器中
        注意:transform 不会给目标容器分配内存，所以需要我们提前分配好内存
        @param beg1 源容器 1 开始迭代器
        @param end1 源容器 1 结束迭代器
        @param beg2 源容器 2 开始迭代器
        @param result 结果
        @param _cakkback 回调函数或者函数对象
        @return 返回目标容器迭代器
        */
        transform(iterator beg1, iterator end1, iterator beg2,iterator result, _callbakc);

#include <iostream>

#include <vector>
#include <list>
#include <algorithm>
using namespace std;
void fun01()
{
        //定义一个容器存储员工的工资
        vector<double> mm;
        mm.push_back(2100);
        mm.push_back(21000);
        mm.push_back(6100);
        mm.push_back(4000);
        mm.push_back(16000);
        //本月工资涨 200
        list<double> ml;
        ml.resize(mm.size());
transform(mm.begin(),mm.end(),ml.begin(),[](double x)
{
        return x+200;
});
for_each(ml.begin(),ml.end(),[](double m){
        cout << m << endl;
});
}
int main(int argc, char const *argv[])
{
        vector<double> mm;
        mm.push_back(2100);
        mm.push_back(21000);
        mm.push_back(6100);
        mm.push_back(4000);
        mm.push_back(16000);
        vector<double> mm02;
        mm02.push_back(210);
        mm02.push_back(2100);
        mm02.push_back(610);
        mm02.push_back(400);
        mm02.push_back(1600);
        vector<double> mm03;
        mm03.resize(mm.size());
        transform(mm.begin(),mm.end(),mm02.begin(),mm03.begin(),[](double x,double y){
        return x+y;
});
for_each(mm03.begin(),mm03.end(),[](double m){
        cout << m << endl;
});
        return 0;
}

 查找算法

find

作用:查找
/*
find 算法 查找元素
@param beg 容器开始迭代器
@param end 容器结束迭代器
@param value 查找的元素
@return 返回查找到元素对应的迭代器
*/
find(iterator beg, iterator end, value)
void test01 ()
{
        vector < int > vs ;
        vs . push_back ( 12 );
        vs . push_back ( 15 );
        vs . push_back ( 11 );
        vs . push_back ( 13 );
        vs . push_back ( 14 );
vector < int > :: iterator it = find ( vs . begin (), vs . end (), 13 );
if ( it != vs . end ())
{
        cout << " 找到了 " << endl ;
}
else {
        cout << " 不存在 " << endl ;
}
}

 find_if

作用:条件查找

/*
@param beg 容器开始迭代器
@param end 容器结束迭代器
@param callback 回调函数或者谓词 ( 返回 bool 类型的函数对象 )
@return 返回查找到元素对应的迭代器
*/
find_if(iterator beg, iterator end, _callback)
bool myIf ( int x )
{
        return x > 13 ;
}
void test02 ()
{
        vector < int > vs ;
        vs . push_back ( 12 );
        vs . push_back ( 15 );
        vs . push_back ( 11 );
        vs . push_back ( 13 );
        vs . push_back ( 14 );
        vector < int > :: iterator it = find_if ( vs . begin (), vs . end (), myIf );
        cout << * it << endl ;
}

 adjacent_find

作用:查找相邻重复元素

语法:

/**
*adjacent_find 算法 查找相邻重复元素
*@param beg 容器开始迭代器
*@param end 容器结束迭代器
*@param _callback 回调函数或者谓词 ( 返回 bool 类型的函数对象 )
*@return 返回相邻元素的第一个位置的迭代器
**/
adjacent_find(iterator beg, iterator end, _callback);
10 20 30 30 40
示例:
void test03 ()
{
        vector < int > vs ;
        vs . push_back ( 12 );
        vs . push_back ( 15 );
        vs . push_back ( 11 );
        vs . push_back ( 11 );
        vs . push_back ( 13 );
        vector < int > :: iterator it = adjacent_find ( vs . begin (), vs . end ());
        cout << * it << endl ;
}

 binary_search

作用:二分查找

语法:        

/*
注意 : 在无序序列中不可用
@param beg 容器开始迭代器
@param end 容器结束迭代器
@param value 查找的元素
@return bool 查找返回 true 否则 false
*/
bool binary_search(iterator beg, iterator end, value);
void test04 ()
{
        vector < int > vs ;
        vs . push_back ( 1 );
        vs . push_back ( 3 );
        vs . push_back ( 5 );
        vs . push_back ( 7 );
        vs . push_back ( 9 );
        bool b = binary_search ( vs . begin (), vs . end (), 7 );
        if ( b ){
                cout << " 存在 " << endl ;
        } else {
                cout << " 不存在 " << endl ;
        }
}

 count

作用:统计

语法:        

/*
@param beg 容器开始迭代器
@param end 容器结束迭代器
@param value 回调函数或者谓词 ( 返回 bool 类型的函数对象 )
@return int 返回元素个数
*/
count(iterator beg, iterator end, value);
#include <set>
void test05 ()
{
        multiset < int > s ;
        s . insert ( 1 );
        s . insert ( 2 );
        s . insert ( 2 );
        s . insert ( 2 );
        s . insert ( 5 );
        int num = count ( s . begin (), s . end (), 2 );
        cout << num << endl ;
}

 count_if

作用:条件统计

语法:

/*
@param beg 容器开始迭代器
@param end 容器结束迭代器
@param callback 回调函数或者谓词 ( 返回 bool 类型的函数对象 )
@return int 返回元素个数
*/
count_if(iterator beg, iterator end, _callback)
void test06 ()
{
        multiset < int > s ;
        s . insert ( 1 );
        s . insert ( 2 );
        s . insert ( 2 );
        s . insert ( 3 );
        s . insert ( 5 );
        //统计容器中大于 2 的数
        int num = count_if ( s . begin (), s . end (), bind2nd ( greater < int > (), 2 ));
        cout << num << endl ;
        //统计容器中小于 2 的数
        int num02 = count_if ( s . begin (), s . end (), bind2nd ( less < int > (), 2 ));
        cout << num02 << 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)
void test01 ()
{
vector < int > v1 ;
        v1 . push_back ( 1 );
        v1 . push_back ( 3 );
        v1 . push_back ( 5 );
vector < int > v2 ;
        v2 . push_back ( 2 );
        v2 . push_back ( 4 );
        v2 . push_back ( 6 );
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 x ){
cout << x << " " ;
});
        cout << endl ;
}

 sort

作用:排序

语法:

/*
@param beg 容器 1 开始迭代器
@param end 容器 1 结束迭代器
@param _callback 回调函数或者谓词 ( 返回 bool 类型的函数对象 )
*/
sort(iterator beg, iterator end, _callback)
void test02 ()
{
vector < int > vs ;
vs . push_back ( 10 );
vs . push_back ( 13 );
vs . push_back ( 9 );
vs . push_back ( 4 );
vs . push_back ( 18 );
for_each ( vs . begin (), vs . end (),[]( int x ){
        cout << x << " " ;
});
        cout << endl ;
// 默认从小到大
sort ( vs . begin (), vs . end ());
for_each ( vs . begin (), vs . end (),[]( int x ){
        cout << x << " " ;
});
cout << endl ;
sort ( vs . begin (), vs . end (),[]( int x , int y ){
        return x > y ;
});
for_each ( vs . begin (), vs . end (),[]( int x ){
        cout << x << " " ;
});
        cout << endl ;
}

 random_shuffle

作用:打乱

语法:

/*
@param beg 容器开始迭代器
@param end 容器结束迭代器
*/
random_shuffle(iterator beg, iterator end)
void test04 ()
{
vector < int > vs ;
vs . push_back ( 1 );
vs . push_back ( 2 );
vs . push_back ( 3 );
vs . push_back ( 4 );
vs . push_back ( 5 );
random_shuffle ( vs . begin (), vs . end ());
for_each ( vs . begin (), vs . end (),[]( int x ){
cout << x << " " ;
});
cout << endl ;
}

 reverse

作用:翻转

语法:

/*
@param beg 容器开始迭代器
@param end 容器结束迭代器
*/
reverse(iterator beg, iterator end)
void test05 ()
{
vector < int > vs ;
vs . push_back ( 31 );
vs . push_back ( 2 );
vs . push_back ( 23 );
vs . push_back ( 14 );
vs . push_back ( 5 );
sort ( vs . begin (), vs . end ());
for_each ( vs . begin (), vs . end (),[]( int x ){
        cout << x << " " ;
});
cout << endl ;
reverse ( vs . begin (), vs . end ());
for_each ( vs . begin (), vs . end (),[]( int x ){
        cout << x << " " ;
});
        cout << endl ;
}

 拷贝与替换

copy

作用:拷贝

语法:

/*
@param beg 容器开始迭代器
@param end 容器结束迭代器
@param dest 目标起始迭代器
*/
copy(iterator beg, iterator end, iterator dest)
void test01()
{
vector<int> vs;
vs.push_back(31);
vs.push_back(2);
vs.push_back(23);
vs.push_back(14);
vs.push_back(5);
vector<int> newVs;
newVs.resize(vs.size());
copy(vs.begin(),vs.end(),newVs.begin());
for_each(newVs.begin(),newVs.end(),[](int x){
        cout << x << endl;
});
}

 replace

作用:替换

语法:

/*
@param beg 容器开始迭代器
@param end 容器结束迭代器
@param oldvalue 旧元素
@param oldvalue 新元素
*/
replace(iterator beg, iterator end, oldvalue, newvalue)
void test02 ()
{
vector < int > vs ;
vs . push_back ( 31 );
vs . push_back ( 2 );
vs . push_back ( 23 );
vs . push_back ( 14 );
vs . push_back ( 5 );
replace ( vs . begin (), vs . end (), 2 , 20 );
for_each ( vs . begin (), vs . end (),[]( int x ){
        cout << x << endl ;
});
}

 replace_if

作用:条件替换

/*
@param beg 容器开始迭代器
@param end 容器结束迭代器
@param callback 函数回调或者谓词 ( 返回 Bool 类型的函数对象 )
@param oldvalue 新元素
*/
replace_if(iterator beg, iterator end, _callback, newvalue)
void test03 ()
{
vector < int > vs ;
vs . push_back ( 31 );
vs . push_back ( 2 );
vs . push_back ( 23 );
vs . push_back ( 14 );
vs . push_back ( 5 );
replace_if ( vs . begin (), vs . end (),[]( int x ){
        return x < 20 ;
}, 20 );
for_each ( vs . begin (), vs . end (),[]( int x ){
        cout << x << endl ;
});
}

 swap

作用:交换

语法:      

/*
@param c1 容器 1
@param c2 容器 2
*/
swap(container c1, container c2)
void test04 ()
{
vector < int > v01 ;
v01 . push_back ( 1 );
v01 . push_back ( 2 );
v01 . push_back ( 3 );
v01 . push_back ( 4 );
v01 . push_back ( 5 );
vector < int > v02 ;
v02 . push_back ( 6 );
v02 . push_back ( 7 );
v02 . push_back ( 8 );
        cout << " 交换前 :" << endl ;
for_each ( v01 . begin (), v01 . end (),[]( int x ){
        cout << x << " " ;
});
        cout << endl ;
for_each ( v02 . begin (), v02 . end (),[]( int x ){
        cout << x << " " ;
});
        cout << endl ;
swap ( v01 , v02 );
cout << " 交换后 :" << endl ;
for_each ( v01 . begin (), v01 . end (),[]( int x ){
        cout << x << " " ;
});
        cout << endl ;
for_each ( v02 . begin (), v02 . end (),[]( int x ){
        cout << x << " " ;
});
cout << endl ;
}

 常用算数生成算法

accumulate

作用:计算容器内元素累计总和

语法:

/*
@param beg 容器开始迭代器
@param end 容器结束迭代器
@param value 累加值
@return int 总和
*/
accumulate(iterator beg, iterator end, value)
void test01 ()
{
vector < int > v01 ;
v01 . push_back ( 1 );
v01 . push_back ( 2 );
v01 . push_back ( 3 );
v01 . push_back ( 4 );
v01 . push_back ( 5 );
int sum = 0 ;
sum = accumulate ( v01 . begin (), v01 . end (), 0 );
cout << sum << endl ;
}

fill

作用 : 指定的值赋给指定范围内的所有元素
语法:
/*
@param beg 容器开始迭代器
@param end 容器结束迭代器
@param value t 填充元素
*/
fill(iterator beg, iterator end, value)

 void test02()

{
vector<int> v01;
v01.push_back(1);
v01.push_back(2);
v01.push_back(3);
v01.push_back(4);
v01.push_back(5);
fill(v01.begin(),v01.end(),10);
for_each(v01.begin(),v01.end(),[](int x){
cout << x << " ";
});
cout << endl;
}

 set_intersection

作用:获取交集

语法:

/*
注意 : 两个集合必须是有序序列
@param beg1 容器 1 开始迭代器
@param end1 容器 1 结束迭代器
@param beg2 容器 2 开始迭代器
@param end2 容器 2 结束迭代器
@param dest 目标容器开始迭代器
@return 目标容器的最后一个元素的迭代器地址
*/
set_intersection(iterator beg1, iterator end1, iterator beg2, iteratorend2, iterator dest)
void test03()
{
vector<int> v01;
v01.push_back(1);
v01.push_back(2);
v01.push_back(3);
v01.push_back(4);
v01.push_back(5);
vector<int> v02;
v02.push_back(1);
v02.push_back(4);
v02.push_back(7);
vector<int> v03;
//back_inserter: 获取一个插入迭代器
set_intersection(v01.begin(),v01.end(),v02.begin(),v02.end(),back_inserter(v03));
for_each(v03.begin(),v03.end(),[](int x){
        cout << x << " ";
});
cout << endl;
}

 set_union

作用:获取并集

语法:

/*
注意 : 两个集合必须是有序序列
@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)
void test04()
{
vector<int> v01;
v01.push_back(1);
v01.push_back(2);
v01.push_back(3);
v01.push_back(4);
v01.push_back(5);
vector<int> v02;
v02.push_back(1);
v02.push_back(4);
v02.push_back(7);
vector<int> v03;
//back_inserter: 获取一个插入迭代器
set_union(v01.begin(),v01.end(),v02.begin(),v02.end(),back_inserter(v0
3));
for_each(v03.begin(),v03.end(),[](int x){
        cout << x << " ";
});
cout << endl;
}

 set_difference

作用:取差集

差集 :A 与 B 的差集 , 就是 A 中有 B 中没有的元素集合 , 反之 B 与 A 取差集 , 就是 B 中有 A 中没有的元素集合
语法:
/*
注意 : 两个集合必须是有序序列
@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)

void test05 ()
{
vector < int > v01 ;
v01 . push_back ( 1 );
v01 . push_back ( 3 );
v01 . push_back ( 5 );
v01 . push_back ( 7 );
v01 . push_back ( 9 );
vector < int > v02 ;
v02 . push_back ( 9 );
v02 . push_back ( 11 );
v02 . push_back ( 13 );
vector < int > v03 ;
//back_inserter: 获取一个插入迭代器
set_difference ( v01 . begin (), v01 . end (), v02 . begin (), v02 . end (), back_inserter ( v03 ));
for_each ( v03 . begin (), v03 . end (),[]( int x ){
cout << x << " " ;
});
cout << endl ;
}

本文来自互联网用户投稿，该文观点仅代表作者本人，不代表本站立场。本站仅提供信息存储空间服务，不拥有所有权，不承担相关法律责任。如若转载，请注明出处：/a/921591.html

如若内容造成侵权/违法违规/事实不符，请联系我们进行投诉反馈qq邮箱809451989@qq.com，一经查实，立即删除！

相关文章

ROS入门学习ONE

ROS入门学习ONE

ros入门玩法1&#xff1a;控制小龟龟 终端1输入 sudo apt install ros-noetic-rqt-steering 新建终端2&#xff08;快捷键CtrlAltT)&#xff0c;打开控制台 roscore //启动ros系统 回到原终端 rosrun rosrun rqt_robot_steering rqt_robot_steering 新建终端3&#xff0c;…
阅读更多...
shell脚本(二)

shell脚本(二)

声明&#xff01; 学习视频来自B站up主 泷羽sec 有兴趣的师傅可以关注一下&#xff0c;如涉及侵权马上删除文章&#xff0c;笔记只是方便各位师傅的学习和探讨&#xff0c;文章所提到的网站以及内容&#xff0c;只做学习交流&#xff0c;其他均与本人以及泷羽sec团队无关&#…
阅读更多...
简单理解下基于 Redisson 库的分布式锁机制

简单理解下基于 Redisson 库的分布式锁机制

目录 简单理解下基于 Redisson 库的分布式锁机制代码流程&#xff1a;方法的调用&#xff1a;具体锁的实现&#xff1a;riderBalance 方法&#xff1a;tryLock 方法&#xff08;重载&#xff09;&#xff1a;tryLock 方法&#xff08;核心实现&#xff09;&#xff1a; 简单理解…
阅读更多...
小鹏汽车智慧材料数据库系统项目总成数据同步

小鹏汽车智慧材料数据库系统项目总成数据同步

1、定时任务处理 2、提供了接口 小鹏方面提供的推送的数据表结构&#xff1a; 这几个表总数为100多万&#xff0c;经过条件筛选过滤后大概2万多条数据 小鹏的人给的示例图&#xff1a; 界面&#xff1a; SQL: -- 查询车型 select bmm.md_material_id, bmm.material_num, bm…
阅读更多...
LeetCode 3244.新增道路查询后的最短距离 II：贪心（跃迁合并）-9行py（O(n)）

LeetCode 3244.新增道路查询后的最短距离 II：贪心（跃迁合并）-9行py（O(n)）

【LetMeFly】3244.新增道路查询后的最短距离 II&#xff1a;贪心&#xff08;跃迁合并&#xff09;-9行py&#xff08;O(n)&#xff09; 力扣题目链接&#xff1a;https://leetcode.cn/problems/shortest-distance-after-road-addition-queries-ii/ 给你一个整数 n 和一个二维…
阅读更多...
华为无线AC+AP组网实际应用小结

华为无线AC+AP组网实际应用小结

之前公司都是使用的H3C的交换机、防火墙以及无线AC和AP的&#xff0c;最近优化下无线网络&#xff0c;说新的设备用华为的&#xff0c;然后我是直到要部署的当天才知道用华为设备的&#xff0c;就很无语了&#xff0c;一点准备没有&#xff0c;以下为这次的实际操作记录吧&…
阅读更多...
Fakelocation Server服务器/专业版 Windows11

Fakelocation Server服务器/专业版 Windows11

前言:需要Windows11系统 Fakelocation开源文件系统需求 Windows11 | Fakelocation | 任务一 打开 PowerShell&#xff08;以管理员身份&#xff09;命令安装 Chocolatey Set-ExecutionPolicy Bypass -Scope Process -Force; [System.Net.ServicePointManager]::SecurityProto…
阅读更多...
C语言基础学习：抽象数据类型（ADT）

C语言基础学习：抽象数据类型（ADT）

基础概念 抽象数据类型&#xff08;ADT&#xff09;是一种数据类型&#xff0c;它定义了一组数据以及可以在这组数据上执行的操作&#xff0c;但隐藏了数据的具体存储方式和实现细节。在C语言中&#xff0c;抽象数据类型&#xff08;ADT&#xff09;是一种非常重要的概念&…
阅读更多...
基于深度学习CNN算法的花卉分类识别系统01--带数据集-pyqt5UI界面-全套源码

基于深度学习CNN算法的花卉分类识别系统01--带数据集-pyqt5UI界面-全套源码

文章目录 基于深度学习算法的花卉分类识别系统一、项目摘要二、项目运行效果三、项目文件介绍四、项目环境配置1、项目环境库2、环境配置视频教程 五、项目系统架构六、项目构建流程1、数据集2、算法网络Mobilenet3、网络模型训练4、训练好的模型预测5、UI界面设计-pyqt56、项目…
阅读更多...
Bokeh实现大规模数据可视化的最佳实践

Bokeh实现大规模数据可视化的最佳实践

目录 引言 一、Bokeh简介 二、安装Bokeh 三、数据准备 四、性能优化 五、创建图表 六、添加交互功能 七、应用案例 八、高级技巧 九、总结 引言 在数据科学领域，数据可视化是一个至关重要的环节。通过可视化，我们可以直观地理解数据的特征和趋势，为数据分析和决策…
阅读更多...
Easyexcel（4-模板文件）

Easyexcel（4-模板文件）

相关文章链接 Easyexcel&#xff08;1-注解使用&#xff09;Easyexcel&#xff08;2-文件读取&#xff09;Easyexcel&#xff08;3-文件导出&#xff09;Easyexcel&#xff08;4-模板文件&#xff09; 文件导出 获取 resources 目录下的文件&#xff0c;使用 withTemplate 获…
阅读更多...
【山大909算法题】2014-T1

【山大909算法题】2014-T1

文章目录 1.原题2.算法思想3.关键代码4.完整代码5.运行结果 1.原题 为带表头的单链表类Chain编写一个成员函数Reverse&#xff0c;该函数对链表进行逆序操作&#xff08;将链表中的结点按与原序相反的顺序连接&#xff09;&#xff0c;要求逆序操作就地进行&#xff0c;不分配…
阅读更多...
[Redis#2] 定义 | 使用场景 | 安装教程 | 快！

[Redis#2] 定义 | 使用场景 | 安装教程 | 快！

目录 1. 定义 In-memory data structures 在内存中存储数据 2. 优点&#xff01;快 Programmability 可编程性 Extensibility 扩展性 Persistence 持久化 Clustering 分布式集群 High availability 高可用性 ⭕快速访问的实现 3. 使用场景 1.Real-time data store …
阅读更多...
学习编程，学习中间件，学习源码的思路

学习编程，学习中间件，学习源码的思路

01 看的多&#xff0c;内化不足 最近想复习一下编程相关的知识&#xff0c;在复习前我翻开了之前的一些笔记&#xff0c;这些笔记基本都是从书本、视频、博客等摘取记录的&#xff0c;看着这些笔记心里总结&#xff1a;看的多&#xff0c;内化不足。 02 整理大纲 为了解决这个…
阅读更多...
hhdb数据库介绍(10-2)

hhdb数据库介绍(10-2)

集群管理 计算节点集群 集群管理主要为用户提供对计算节点集群的部署、添加、启停监控、删除等管理操作。 集群管理记录 集群管理页面显示已部署或已添加的计算节点集群信息。可以通过左上角搜索框模糊搜索计算节点集群名称进行快速查找。同时也可以通过右侧展开展开/隐藏更…
阅读更多...
AG32既可以做MCU，也可以仅当CPLD使用

AG32既可以做MCU，也可以仅当CPLD使用

Question: AHB总线上的所有外设都需要像ADC一样&#xff0c;通过cpld处理之后才能使用? Reply: 不用。 除了ADC外&#xff0c;其他都是 mcu可以直接配置使用的。 Question: DMA和CMP也不用? Reply: DMA不用。 ADC/DAC/CMP 用。 CMP 其实配置好后&#xff0c;可以直…
阅读更多...
贪心算法（1）

贪心算法（1）

目录 柠檬水找零 题解&#xff1a; 代码&#xff1a; 将数组和减半的最少操作次数&#xff08;大根堆&#xff09; 题解&#xff1a; 代码&#xff1a; 最大数&#xff08;注意 sort 中 cmp 的写法&#xff09; 题解&#xff1a; 代码&#xff1a; 摆动序列&#xff0…
阅读更多...
网络爬虫——综合实战项目：多平台房源信息采集与分析系统

网络爬虫——综合实战项目：多平台房源信息采集与分析系统

1. 项目背景与目标 1.1 项目背景 随着房产市场的快速发展&#xff0c;各大平台上充斥着大量房源信息。为了帮助用户快速掌握市场动态&#xff0c;需要通过爬虫技术自动采集多平台数据&#xff0c;清洗后进行存储和分析&#xff0c;为用户提供有价值的洞察。开发者通过这一实战…
阅读更多...
数据结构-7.Java. 对象的比较

数据结构-7.Java. 对象的比较

本篇博客给大家带来的是java对象的比较的知识点, 其中包括 用户自定义类型比较, PriorityQueue的比较方式, 三种比较方法...... 文章专栏: Java-数据结构 若有问题 评论区见 欢迎大家点赞 评论 收藏 分享 如果你不知道分享给谁,那就分享给薯条. 你们的支持是我不断创作的动力 .…
阅读更多...
NVR录像机汇聚管理EasyNVR多品牌NVR管理工具/设备如何使用Docker运行？

NVR录像机汇聚管理EasyNVR多品牌NVR管理工具/设备如何使用Docker运行？

在当今的安防监控领域&#xff0c;随着视频监控技术的不断发展和应用范围的扩大&#xff0c;如何高效、稳定地管理并分发视频流资源成为了行业内外关注的焦点。EasyNVR作为一款功能强大的多品牌NVR管理工具/设备&#xff0c;凭借其灵活的部署方式和卓越的性能&#xff0c;正在引…
阅读更多...
最新文章

Copyright @ 2022~2023