C++进阶STL-2

目录

 

基本理论容器——算法——迭代器

string容器

swap技巧

deque容器基本操作

deque打分案例

set容器

对组练习

map容器

mutimap员工分组

深拷贝和浅拷贝问题

函数对象

一元二元函数对象和一元二元谓词

预定义函数对象

---

基本理论容器——算法——迭代器

容器中可以嵌套容器，容器可以分为序列式容器和关联式容器。

序列式容器：容器的元素的位置是由进入容器时机和地点来决定。

关联式容器：容器已经有规则，进入容器的元素的位置不是由时机和地点决定。

迭代器：可以理解为指针，对指针的操作基本都可以对迭代器操作。实际上，，迭代器是一个类，这个类封装一个指针。

算法：通过有限的步骤去解决问题。

STL容器、算法、迭代器分离案例

//算法：负责统计某个元素的个数
int mycount(int* start,int* end, int val){
    int num = 0;
    while(start != end){
        if(*start == val){
            num++;
        }
        start++;
    }
    return num;
}
int main(){
    int arr[] = {0,7,5,4,9,2,0};
    int* pBegin = arr;
    int* pEnd = &(arr[szeof(arr)/sizeof(int)]);
    int num = mycount(pBegin,pEnd,0);
    cout<<num<<endl;
    return 0;
}

//STL基本语法
void test01(){
    //定义一个容器，并且指定这个容器存放的元素类型是Int;
    vector<int> v;
    v.push_back(10);
    v.push_back(20);
    v.push_back(30);
    v.push_back(40);

    //通过STL提供的for_each算法
    //容器提供的迭代器
    //vector<int>::iterator 迭代器类型
    vector<int>::iterator pBegin = v.begin();
    vector<int>::iterator pEnd = v.end();
    
    //容器中可能存放基础的数据类型，也可能存放自定义的数据类型。
    for_each(pBegin,pEnd,PrintVector);
    
}

//容器也可以存放自定义数据类型
class Person{
public:
    Person(int age, int id):age(age),id(id){}
public:
    int age;
    int id;
}
void test02(){
    
    //创建容器，并且指定容器的元素类型是Person；
    vector<Person> v;
    Person p1(10,20), p2(30,40), p3(50,60);
    v.push_back(p1);
    v.push_back(p2);
    v.push_back(p3);

    //遍历
    for(vector<Person>::iterator it = v.begin(); it!=v.end(); it++){
        cout<<(*it).age<<" "<<(*it).id<<endl;
    }
}
int main(){
    test01();
    test02();
}

string容器

char*与string的对比：string封装了char*，管理这个字符串，是一个char*型的容器。

string封装了很多实用的成员方法：find，copy，delete，replace，insert。

不用考虑内存的释放和越界。

string和char*可以互相转换：string转char*通过string提供的c_str方法。

string操作

#include<iostream>
#include<string>
using namespace std;
//char* 和string转换
void test01(){
    //string类型转换为char*字符串
    string s = "abc";
    const char* str = s.c_str();
    
    //char*类型转换为string类型字符串
    char* str2 = "abcd";
    string s2(str2);
}

//string初始化
void test02(){
    string s;//默认
    string s2 = "abcd";
    string s3(s2);
    string s4(10,'c');
    cout<<s2<<endl;
    cout<<s3<<endl;
    cout<<s4<<endl;
}
//string容器字符串赋值和存取
void test03(){
    //string容器赋值
    string s;
    s = "abcd";

    string s2;
    s2.assign("pppp");

    //string容器存取
    string s3 = "abcdefg";
    for(int i = 0; i < s3.size(); i++){
        cout<<s3[i]<<" ";
    }
    cout<<endl;
    for(int i = 0; i < s3.size(); i++){
        cout<<s3.at(i)<<" ";
    }
    cout<<endl;
}
//[]访问方式越界的时候，不会抛异常直接挂掉。
//at会抛异常。
try{
    //cout<<s3[100]<<endl; 直接挂掉
}
catch(...){
    cout<<"访问越界"<<endl;
}

//string容器拼接操作
void test04(){
    string s1 = "aaa";
    string s2 = "bbb";
    //string s3 = s1 + s2;
    //cout<<s3<<endl;
    //s1+=s2;
    //cout<<s1<<endl;
    
    //成员方法方式
    s1.append(s2);
    cout<<s1<<endl;
}

//string查找和替换比较
void test05(){
    string s = "acbdefg";
    //查找
    string target = "bd";
    int pos = s.find(target);
    char* target2 = "ef";
    int pos2 = s.find(target2);
    
    cout<<pos<<" "<<pos2<<endl;

    //字符串替换
    string s1 = "abcd";
    s.replace(0,2,s1);
    cout<<s<<endl;
}

//string比较 子串插入和删除
void test06(){
    //比较
    string s1 = "abc";
    string s2 = "abd";
    int ret = s1.compare(s2);
    if(ret == 1){
        cout<<"s1 > s2"<<endl;
    }

    //子串
    string s3 = "abcdefg";
    string s4 = s3.substr(0,2);
    cout<<"s4"<<s4<<endl;

    //插入和删除
    string s5 = "abcd";
    s5.insert(0,"pppp");
    string s6 = "qqqq";
    s5.insert(s5.size(),s6);
    
    cout<<s5<<endl;
    s5.erase(0,4);
    cout<<s5<<endl;
}

swap技巧

#include<iostream>
#include<vector>
using namespace std;

void print(vector<int>& v){
    for(vector<int>::iterator it = v.begin(); it != v.end(); it++){
        cout<<*it<<" ";
    }
}
int main(){
    vector<int> v1,v2;
    for(int i = 0; i < 5; i++){
        v1.push_back(i);
    }
    for(int i=6; i < 10; i++){
        v2.push_back(i);
    }
    print(v1);
    print(v2);
    v1.swap(v2);
    cout<<"v1和v2交换之后："<<endl;
    print(v1);
    print(v2);

    //swap小技巧
	vector<int> v;
	v.resize(100);

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

	v.clear();
	v.push_back(2);
	v.push_back(3);

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

	vector<int>(v).swap(v);

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

	system("pause");
	return EXIT_SUCCESS;
}

deque容器基本操作

#niclude<iostream>
#include<deque>
using namespace std;

//deque容器初始化
void test01(){
    deque<int> d1;//默认构造函数
    deque<int> d2(10,5);//带参数构造函数
    deque<int> d3(d2..begin(),d2.end());
    deque<int> d4(d3);//拷贝构造
}

//deque赋值操作
void test02(){
    deque<int> d1(10,3);
    deque<int> d;
    d.assign(10,5);//d.assign(d1.begin(),d1.end());
    d = d1;
}

//大小操作
void test03(){
    deque<int> d1(10,3);
    cout<<d1.size()<<endl;
    if(d1.empty()){
        cout<<"空"<<endl;
    }
    else{
        cout<<"不空"<<endl;
    }
    //d1.resize(5);
    //cout<<d1.size()<<endl;
    d.resize(15);
}

//deque的插入和删除
void test04(){
    //第一种遍历方式
	for (int i = 0; i < d.size();i++){
		cout << d[i] << " ";
	}
	cout << endl;

	//第二种遍历方式
	for (int i = 0; i < d.size(); i++){
		cout << d.at(i) << " ";
	}
	cout << endl;

	//第三种方式
	for (deque<int>::iterator it = d.begin(); it != d.end(); it++){
		cout << *it << " ";
	}
	cout << endl;
    //删除元素
	/*
		while (d.size() > 0){
		cout << d.back() << "被删除!" << endl;
		d.pop_back();
	}
	cout << "大小:" << d.size() << endl;
	*/

    //头删除
	while (!d.empty()){
		cout << d.front() << "被删除!" << endl;
		d.pop_front();
	}
//deque容器插入
void test06(){
	
	deque<int> d;
	d.insert(d.begin(),100); //头插法
	d.insert(d.end(), 200); //尾差法

	for (deque<int>::iterator it = d.begin(); it != d.end(); it++){
		cout << *it << " ";
	}
	cout << endl;
}

int main(){


	//test03();
	//test04();
	test06();

	system("pause");
	return EXIT_SUCCESS;
}

deque打分案例

#include<iostream>
#include<vector>
#include<dueue>
#include<algorithm>
#include<string>
using namespace std;
//评委打分案例（sort算法排序）
//创建5个选手（姓名，得分），10个评委对5个选手进行打分
//得分规则：去除最高分，去除最低分，取出平均分
//按得分对5名选手进行排名

//选手类
class Player{
public:
    Player(){}
    Player(string name,int score):mName(name),mScore(score){}
public:
    string mName;
    int mScore;
}

//创建选手
void Create_Player(vector<Player>& v){
    string nameSeed = "ABCDE";
    for(int i = 0; i < 5; i++){
        Player p;
        p.mName = "选手";
        p.mName+=nameSeed[i];
        p.mScore = 0;

        v.push_back(p);
    }
}

void PrintScore(int val){
    cout<<val<<" ";
}

//打分
void Set_Score(vector<Player>& v){
    for(vector<Player>::iterator it = v.begin();it!=v.end();it++){
        //当前学生进行打分
        deque<int> dScore;
        for(int i=0;i<10;i++){
            int score = rand()%41+60;
            dScore.push_back(score);
        }
        //对分数排序，默认从小到大
        sort(dScore.begin(),dScore.end());
        //for_each(dScore.begin(),dScore.end(),PrintScore);
        //cout<<endl;
        
        //去除最高分，去除最低分
        dScore.pop_front();
        dScore.pop_back();
    
        //求平均分
        int totalScore = 0;
        for(deque<int>::iterator dit = dScore.begin();dit!=dScore.end();dit++){
            totalScore+=(*dit);
        }
        int aveScore = totalScore/dScore.size();
        //保存分数
        (*it).mScore = aveScore;
    }
}

set容器

#include<iostream>
#include<functional>//预定义函数对象
#include<set>
#include<stdlib.h>
#include<time.h>
using namespace std;

//初始化
void test01(){
    set<int> myset;//默认构造
    set<int> myset2(myset)//拷贝构造
}

void printSet(set<int>& myset){
    for(set<int>::iterator it = myset.begin();it!=myset.end();it++){
        cout<<*it<<" ";
    }
    cout<<endl;
}

//set容器插入和删除
void test02(){
    set<int> myset;//默认升序
    myset.insert(4);
    myset.insert(2);
    myset.insert(1);
    myset.insert(5);
    myset.insert(2);

    printSet(myset);

    //删除
    myset.erase(myset.begin());//删除第一个元素
    myset.erase(2);//根据元素值删除
    printSet(myset);
    myset.erase(myset.begin();myset.end());//myset.clear();
    cout<<"size:"<<myset.size()<<endl;
}

template<class T>
class mycompare03{
public:
    bool operator()(T v1,T v2){
        return v1>v2;
    }
};

//set容器查找
void test03(){
    //函数对象
    //mycompare03 mycom;
    //mycom(10);//函数对象，仿函数
    set<int,mycompare03<int>> myset;//默认从小到大排序
    myset.insert(4);
    myset.insert(2);
    myset.insert(1);
    myset.insert(5);

    for(set<int,greater<int>>::iterator it = myset.begin();it!=myset.end();it++){
        cout<<*it<<" "; 
    }
    cout<<endl;
}

class Teacher{
public:
    bool operator()(Teacher t1,Teacher t2){
        return t1.id>t2.id;
    }
};
void test04(){
    set<Teacher,myconpare04> myset;
    Teacher t1(1,2),t2(3,4),t3(5,6);

    myset.insert(t1);
    myset.insert(t2);
    myset.insert(t3);

    for(set<Teacher,mycompare04>::iterator it=myset.begin();it!=myset.end();it++){
        cout<<it->id<<" "<<it->age<<endl;
    }
    cout<<endl;
}

void test05(){

	set<int> myset;
	myset.insert(10);
	myset.insert(5);
	myset.insert(1);
	myset.insert(8);

	set<int>::iterator pos = myset.lower_bound(5);  //返回大于等于5 迭代器
	if (pos == myset.end()){
		cout << "没有找到!" << endl;
	}
	else{
		cout << "找到：" << *pos << endl;
	}

	pos = myset.upper_bound(5);
	if (pos == myset.end()){
		cout << "没有找到!" << endl;
	}
	else{
		cout << "找到：" << *pos << endl;
	}

	pair<set<int>::iterator, set<int>::iterator> pos2 =  myset.equal_range(5);
	if (pos2.first == myset.end()){
		cout << "meiyouzhaodao!" << endl;
	}
	else{
		cout << "zhaodao!" << *(pos2.first) << endl;
	}

	if (pos2.second == myset.end()){
		cout << "meiyouzhaodao!" << endl;
	}
	else{
		cout << "zhaodao!" << *(pos2.second) << endl;
	}

}

对组练习

#include<iostream>
#include<string>
using namespace std;

int main(){
    //第一种方式 创建一个pair
    pair<int,string> mypair(10,"aaa");
    cout<<mypair.first<<endl;
    cout<<mypair.second<<endl;

    //第二种 创建pair
    pair<string,string> mypair2 = make_pair("aaa","bbb");
    //auto mypair2 = make_pair("aaa","bbb");
    cout<<mypair2.first<<" "<<mypair2.second<<endl;

    //第三种
    pair<int,string> mypair3 = mypair;//拷贝构造

    system("pause");
    return EXIT_SUCCESS;
}

map容器

#include<iostream>
#include<map>
#include<string>
using namespace std;

//map容器初始化
void test01(){
    //map容器的模板参数，需要指定key类型 value类型
    map<int,string> mymap;//默认构造
    map<int,string> mymap2(mymap);//拷贝构造
}

//map插入操作
void test02(){
    map<int,int> mymap;
    //第一种插入方式
    mymap.insert(pair<int,int>(1,5));
    //第二种
    pair<map<int,int>::iterator,bool> ret = mymap.insert(make_pair(2,10));
    if(ret.second){
        cout<<"插入成功"<<endl;
    }
    else{
        cout<<"插入失败"<<endl;
    }
    //第三种
    mymap.insert(map<int,int>::value_type(3,15));
    //第四种
    //mymap[4] = 20;

    //四种插入方式区别：
    //如果Key存在，会修改容器指定key元素的值
    
    for(map<int,int>::iterator it=mymap.begin();it!=mymap.end();it++){
        cout<<"key:"<<it->first<<"value:"<<it->second<<endl;
    }
    cout<<endl;

    //如果访问的key不存在，会创建这个数据插入进去
    
    ret = mymap.insert(map<int,int>::value_type(2,10));
    if(ret.second){
        cout<<"插入成功"<<endl;
    }
    else{
        cout<<"插入失败"<<endl;
    }
}

void print(map<int,int>& mymap){
    for (map<int, int>::iterator it = mymap.begin(); it != mymap.end();it++){
		cout << it->first << " " << it->second << " ";
    }
    cout<<endl;
}

//删除和查找
void test03(){
    map<int, int> mymap;
	mymap.insert(make_pair(1, 2));
	mymap.insert(make_pair(2, 3));
	mymap.insert(make_pair(3, 4));

    //查找
    map<int,int>::iterator pos = mymap.find(3);
    if(pos == mymap.end()){
        cout<<"没有找到"<<endl;
    }
    else{
        cout<<"查找到"<<pos->first<<"value:"<<pos->>second<<endl;
    }
    
    cout << "---------------" << endl;
	pos =  mymap.lower_bound(2);
	if (pos == mymap.end()){
		cout << "没有找到!" << endl;
	}
	else{
		cout << "查找到:" << pos->first << " value:" << pos->second << endl;
	}

	pos = mymap.upper_bound(2);
	if (pos == mymap.end()){
		cout << "没有找到!" << endl;
	}
	else{
		cout << "查找到:" << pos->first << " value:" << pos->second << endl;
	}

	pair<map<int, int>::iterator, map<int, int>::iterator> pos2 = mymap.equal_range(2);
	if (pos2.first == mymap.end()){  //第一个迭代器
		cout << "没有找到!" << endl;
	}
	else{
		cout << "查找到:" << pos2.first->first << " value:" << pos2.first->second << endl;
	}

	if (pos2.second == mymap.end()){ //第二个迭代器
		cout << "没有找到!" << endl;
	}
	else{
		cout << "查找到:" << pos2.second->first << " value:" << pos2.second->second << endl;
	}
}

mutimap员工分组

#include<iostream>
#include<vector>
#include<map>
#include<string>
using namespace std;
#define SALE_DEPARTMENT  1 //销售部
#define DEVELOP_DEPARTMENT 2 //开发部
#define FINACIAL_DEPARTMENT 3 //财务部
class Yuangong{
public:
    string name;
    int age;
    string tele;
    double salary;
};

//创建员工5名
void Create_Yuangong(vector<Yuangong>& v){
    string namesed = "ABCDE";
    for(int i=0;i<5;i++){
        Yuangong yg;
        yg.name = "员工";
        yg.name += nameseed[i];

        yg.age = rand()%30;
        yg.salary = rand()%10000+10000;
        yg.tele = "86-88888888";

        v.push_back(yg);
    }
}

//对员工指派部门
void Set_YG_Group(vector<Yuangong>& v,mutimap<int,Yuangong>& group){
    for(vector<Yuangong>::iterator it = v.begin(); it!=v.end();it++){
        cout<<"当前员工信息:"<<endl;
        cout<<"名字:"<<it->name<<"年龄："<<it->age<<"工资："<<it->salary<<"电话："<<it->tele;<<endl;
        int departmentID = -1;
		while (true){
			
			cout << "请输入部门(1 销售部 2 开发部 3 财务部) : " << endl;
			scanf("%d", &departmentID);

			if (departmentID == SALE_DEPARTMENT){
				group.insert(make_pair(SALE_DEPARTMENT,*it));
				break;
			}
			else if (departmentID == DEVELOP_DEPARTMENT){
				group.insert(make_pair(DEVELOP_DEPARTMENT, *it));
				break;
			}
			else if (departmentID == FINACIAL_DEPARTMENT){
				group.insert(make_pair(FINACIAL_DEPARTMENT, *it));
				break;
			}
			else{
				cout << "输入错误,请重新输入:" << endl;
			}
		}
    }
}
//打印各部门员工信息
void Show_YG_Info(mutimap<int,Yuangong>& group){
    int departmentID = -1;
    while(true){
        cout<<"请输入要查看的部门（1 销售部 2 开发部 3 财务部）："<<endl;
        scanf("%d",&departmentID);

        //验证输入有效性
        if(departmentID<1||departmentID>3){
            continue;
        }

        mutimap<int,Yuangong>::iterator pos = group.find(departmentId);
        int ygcount = group.count(departmentID);
        int num = 0;
        while(pos != group.end()&&num<ygcount){
			cout << "姓名: " << pos->second.name << " 年龄:" << pos->second.age <<  " 工资" << pos->second.salary << " 电话" << pos->second.tele <<  endl;
			num++;
			pos++;
		}
    }
} 

int main(){

	//multimap 案例
	//公司今天招聘了 5 个员工，5 名员工进入公司之后，需要指派员工在那个部门工作
	//人员信息有: 姓名 年龄 电话 工资等组成
	//通过 Multimap 进行信息的插入 保存 显示
	//分部门显示员工信息 显示全部员工信息

	vector<Yuangong> v;  //放员工信息 未分组之前
	multimap<int, Yuangong> Ygroup;  //存放分组后的员工信息
	Create_Yuangong(v); //创建员工
	Set_YG_Group(v, Ygroup); //员工分组
	Show_YG_Info(Ygroup); //按分组显示员工信息

	system("pause");
	return EXIT_SUCCESS;
}

深拷贝和浅拷贝问题

#include<iostream>
#include<vector>
using namespace std;

class Teacher{
public:
    Teacher(char* name,int age){
        int len = strlen(name)+1;
        this->name = new char[len];
        strcpy(this->name,name);

        this->age = age;
    }
    //拷贝构造
    Teacher(const Teacher& t){
        int len = strlen(t.name)+1;
        this->name = new char[len];
        strcpy(this->name,t.name);

        this->age = t.age;
    }

    //重载
    Teacher& operator=(Teacher& t){
        int len = strlen(t.name)+1;
        if(this->name!=NULL){
            delete[] this->name;
        }
        this->name = new char[len];
        strcpy(this->name,t.name);

        this->age = t.age;
        return *this;
    }
    ~Teacher(){
        if(this->name!=NULL){
            delete[] this->name;
        }
        this->age = 0;
    }
    
    char* name;
    int age;
};
void test01(){
    Teacher t1("aaa",20);
    vector<Teacher> v;
    v.push_back(t1);
}
int main(){
    test01();
    system("pause");
    return EXIT_SUCCESS;
}

函数对象

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

void print(){
    cout<<"hello world"<<endl;
}
class myprint{
public:
    void operator()(){
        cout<<"hello world"<<endl;
    }
};

//函数对象和普通函数对比
void test01(){
    print();
    myprint myp;
    myp();
}

void print02(int index){
    cout<<"hello world:"<<endl;
}

class myprint02{
public:
    void operator()(int index){
        cout<<"hello world:"<<index<<endl;
    }
};

void test02(){
    print02(10);
    myprint02 myp02;
    myp02(10);
}

//函数对象超出了普通函数的概念，可以保存函数调用状态
//统计函数调用次数
int q_count = 0;
void print03(){
    q_count++;
}

struct myprint03{
    myprint03():count(0){}
    void operator(){
        count++;
    }
    int count;
}

void test03(){

	print03();
	print03();

	cout << g_count << endl;

	myprint03 myp03;
	myp03();
	myp03();
	myp03();

	cout << myp03.count << endl;

}

//函数对象做参数 做返回值
class myprint04{
public:
	myprint04() :count(0){}
	void operator()(int v){
		count++;
		cout << v << " ";
	}
	int count;
};
void test04(){
	
	vector<int> v;
	for (int i = 0; i < 10;i++){
		v.push_back(i);
	}

	myprint04 myp04;
	myprint04 myp05 = for_each(v.begin(), v.end(), myp04); //函数对象做参数
	cout << "count:" << myp04.count << endl; cout << endl;
	cout << "count:" << myp05.count << endl; cout << endl;
}

一元二元函数对象和一元二元谓词

#include<iostream>
#include<vector>
#include<algorithm>
using namespace std;


//如果你写的函数对象接受一个参数，那么就叫 一元函数对象
//如果你写的函数对象接受两个参数，那么叫 二元函数对象

//如果你写的函数对象或者普通函数接受一个参数，并且返回值是Bool，叫一元谓词
//如果你写的函数对象或者普通函数接受二个参数，并且返回值是Bool，叫二元谓词



//一元函数对象 应用举例 : for_each
class print{
public:
	void operator()(int v){
		cout << v << " ";
	}
};

void print2(int v){
	cout << v << " ";
}
void test01(){
	
	vector<int> v;
	for (int i = 0; i < 10;i++){
		v.push_back(i);
	}

	//print p;
	//for_each(v.begin(), v.end(), print());  //函数对象
	for_each(v.begin(), v.end(), print2); //普通函数
	cout << endl;
}


//一元谓词 应用举例：find_if
class mycompare{
public:
	bool operator()(int v){
		if (v > 7){
			return true;
		}
		else{
			return false;
		}
	}
};
void test02(){
	
	vector<int> v;
	for (int i = 0; i < 10; i++){
		v.push_back(i);
	}


	/*
		
		template<class _InIt,
		class _Pr> inline
		_InIt find_if(_InIt _First, _InIt _Last, _Pr _Pred)
		{	// find first satisfying _Pred
		_DEBUG_RANGE(_First, _Last);
		_DEBUG_POINTER(_Pred);
		return (_Rechecked(_First,
		_Find_if(_Unchecked(_First), _Unchecked(_Last), _Pred)));
		}


		template<class _InIt,
		class _Pr> inline
		_InIt _Find_if(_InIt _First, _InIt _Last, _Pr _Pred)
		{	// find first satisfying _Pred
		for (; _First != _Last; ++_First)
		if (_Pred(*_First))
		break;
		return (_First);
		}

	
	*/

	vector<int>::iterator pos = find_if(v.begin(), v.end(), mycompare()); //匿名函数对象
	if(pos == v.end()){
		cout << "没找到" << endl;
	}
	else{
		cout << "找到:" << *pos << endl;
	}

}

//二元函数对象 应用举例 : transform
class myplus{
public:
	int operator()(int v1,int v2){
		return v1 + v2;
	}

};
void test03(){
	
	vector<int> v1,v2,v3;
	for (int i = 0; i < 10; i++){
		v1.push_back(i);
		v2.push_back(i + 1);
	}


	/*
		
		template<class _InIt1,
		class _InIt2,
		class _OutIt,
		class _Fn2> inline
		_OutIt transform(_InIt1 _First1, _InIt1 _Last1,
		_InIt2 _First2, _OutIt _Dest, _Fn2 _Func)
		{	// transform [_First1, _Last1) and [_First2, ...) with _Func
		_DEBUG_RANGE(_First1, _Last1);
		_DEBUG_POINTER(_Dest);
		_DEBUG_POINTER(_Func);
		if (_First1 != _Last1)
		return (_Transform2(_Unchecked(_First1), _Unchecked(_Last1),
		_First2, _Dest, _Func,
		_Is_checked(_Dest)));
		return (_Dest);
		}


		template<class _InIt1,
		class _InIt2,
		class _OutIt,
		class _Fn2> inline
		_OutIt _Transform(_InIt1 _First1, _InIt1 _Last1,
		_InIt2 _First2, _OutIt _Dest, _Fn2 _Func)
		{	// transform [_First1, _Last1) and [_First2, ...) with _Func
		for (; _First1 != _Last1; ++_First1, ++_First2, ++_Dest)
		*_Dest = _Func(*_First1, *_First2);
		return (_Dest);
		}
	
	*/

	v3.resize(v1.size());

	for_each(v1.begin(), v1.end(), print2); //普通函数
	cout << endl;
	for_each(v2.begin(), v2.end(), print2); //普通函数
	cout << endl;
	for_each(v3.begin(), v3.end(), print2); //普通函数
	cout << endl;

	
	transform(v1.begin(), v1.end(), v2.begin(), v3.begin(), myplus()); //匿名函数对象

	cout << "------------------------------" << endl;

	for_each(v1.begin(), v1.end(), print2); //普通函数
	cout << endl;
	for_each(v2.begin(), v2.end(), print2); //普通函数
	cout << endl;
	for_each(v3.begin(), v3.end(), print2); //普通函数
	cout << endl;

}
//二元谓词 应用举例 : sort

class mycompare04{
public:
	bool operator()(int v1,int v2){
		return v1 > v2; //从大到小
	}
};
void test04(){

	vector<int> v;
	v.push_back(5);
	v.push_back(2);
	v.push_back(7);
	v.push_back(9);


	/*
	
	template<class _RanIt,
	class _Pr> inline
	void sort(_RanIt _First, _RanIt _Last, _Pr _Pred)
	{	// order [_First, _Last), using _Pred
	_DEBUG_RANGE(_First, _Last);
	_DEBUG_POINTER(_Pred);
	_Sort(_Unchecked(_First), _Unchecked(_Last), _Last - _First, _Pred);
	}


	*/
	for_each(v.begin(), v.end(), print2); //普通函数
	cout << endl;
	sort(v.begin(), v.end(), mycompare04());
	for_each(v.begin(), v.end(), print2); //普通函数
	cout << endl;
	
}


int main(){


	//test01();
	//test02();
	//test03();
	test04();

	system("pause");
	return EXIT_SUCCESS;
}

预定义函数对象

#include<iostream>
#include<functional>
#include<string>
#include<vector>
#include<algorithm>
using namespace std;
/*
	
	template<class T> T plus<T>//加法仿函数
	template<class T> T minute<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>//取反仿函数
*/
void test01(){
    plus<int> myplus;
    int ret = myplus(10,20);
    cout<<ret<<endl;
    plus<string> myplus2;
    string s1 = "aaa";
    string s2 = "bbb";
    string ret2 = myplus2(s1,s2);
    cout<<ret2<<endl;
    cout<<plus<int>()(10,20)<<endl;
}

//transform
void print(int v){
    cout<<v<<" "; 
}
void test02(){
    vector<int> v1,v2,v3;
    for(int i=0;i<10;i++){
        v1.push_back(i);
        v2.push_back(i+1);
    }
    v3.resize(v1.size());
    //plus<int> myplus;
    for_each(v3.begin(),v3.end(),print);
    cout<<endl;
    transform(v1.begin(),v1.end(),v2.begin(),v3.begin(),plus<int>());

    for_each(v3.begin(),v3.end(),print);
    cout<<endl;
}