c++基础学习补充

swap(vec);

使用场景：

vector v;
for(int i = 0;i<10000;i++){
    v.push_back(i);
}
cout<(v).swap(v);			//v.capacity() = 3 了

减少vector在动态扩展容量时的扩展次数

reserve(int len);	//容器预留len个元素长度，预留位置不初始化，元素不可访问,即不能一用完reserve就给其赋值 ，会报错

使用场景：

#include
#include
using namespace std;

void test() {
	vector v;
	
	int num = 0;			//统计 容器开辟空间的次数 
	int* p = NULL;		
	for (int i = 0; i < 10000; i++) {
		v.push_back(i);

		if (&v[0] != p) {
			p = &v[0];
			num++;
		}
	}
	cout << num << endl;
	
}

int main() {
	test();
	return 0;
}

如果加了 v.reserve(10000);

加 v.reserve(5000);

双端数组

• deque看似连续内存空间实则是由中控器维护地址，所以在头尾均可以插入删除，但是访问时没有vector快，因为根据中控器找地址会慢一点

和 vector 原理一样

#include
#include
using namespace std;

void show(const deque p) {
	for (deque::const_iterator it = p.begin(); it != p.end(); it++) {	//如果是const 则迭代器也要该 const_iterator
		//*it = 1000;		//error 不可以修改
		cout << *it << " ";
	}
}

void test() {
	deque d;
	for (int i = 0; i < 10; i++) {
		d.push_back(i);
		d.push_front(i + 10);
	}

	show(d);
	
}

int main() {
	test();
	cout << endl;
	return 0;
}

deque 不像vector ，deque 没有容量 capacity 概念

对于支持随机访问的迭代器，均可以使用sort()进行排序，默认从小到大

不允许有遍历行为

不允许有遍历行为

list（链表）

是 双向循环链表 图片没有表示循环

// insert , erase 里面传入的是迭代器

#include
using namespace std;


void Print(const list& p) {
	for (list::const_iterator it = p.begin(); it != p.end(); it++) {
		cout << *it << " ";
	}
	cout << endl;
}

void test() {
	list ak;

	ak.push_back(1);
	ak.push_back(2);
	ak.push_back(3);
	ak.push_back(4);
	Print(ak);				//1 2 3 4

	ak.push_front(10);
	ak.push_front(20);
	ak.push_front(30);
	ak.push_front(40);
	Print(ak);				//40 30 20 10 1 2 3 4

	ak.pop_back();
	Print(ak);				//40 30 20 10 1 2 3 

	ak.pop_front();
	Print(ak);				//30 20 10 1 2 3 

	list::iterator it = --ak.end();		//传入的是 迭代器，当然迭代器位置可以自己调整
	ak.insert(--it, 999);
	Print(ak);				//30 20 10 1 999 2 3

	ak.erase(--(--ak.end()));
	Print(ak);				//30 20 10 1 999 3

	ak.push_back(10);
	ak.push_back(10);
	Print(ak);				//30 20 10 1 999 3 10 10

	ak.remove(10);
	Print(ak);				//30 20 1 999 3

	ak.sort();
	Print(ak);				//1 3 20 30 999
}

int main() {
	test();
	return 0;
}

由于 list 是链表，内存不连续，所以无法通过 [] / .at() 进行随机访问

// list 的迭代器 
list ak;
list::iterator it = ak.begin();
ak++;
ak--;
--ak;
++ak;
//以上 均可以
//而
ak += 1;
ak = ak + 1;
// 因为不支持随机访问 故任意加减数字都不行，加减1 也不行

//反转

#include
#include
using namespace std;

class Person {
public:
	Person(string name) {
		this->name = name;
	}
	string name;
};

ostream& operator<<(ostream& out ,const Person& p) {
	out << p.name;
	return out;
}

void Print(const list& p) {
	for (list::const_iterator it = p.begin(); it != p.end(); it++) {
		cout << *it << " ";
	}
	cout << endl;
}

void test() {
	list p;

	Person p1("Tom");
	Person p2("Tony");
	Person p3("Kimi");

	p.push_back(p1);
	p.push_back(p2);
	p.push_back(p3);

	Print(p);

	p.reverse();
	Print(p);

}
int main() {
	test();

	return 0;
}

//排序

#include
#include
using namespace std;

void Print(const list& p) {
	for (list::const_iterator it = p.begin(); it != p.end(); it++) {
		cout << *it << " ";
	}
	cout << endl;
}

bool Compare(int a, int b) {		//排序从大到小 所用函数
	return a > b;
}

void test02() {
	list p;

	p.push_back(10);
	p.push_back(8);
	p.push_back(40);
	p.push_back(1);

	//所有不支持随机访问迭代器的容器，不可以用标准算法
	//不支持随机访问的容器，内部会提供对应的一些算法
	//sort(p.begin(), p.end());			//error

	p.sort();			//默认 从小到大
	Print(p);
    
    p.sort(Compare);	//从 大到小
	Print(p);
}
int main() {
	test02();

	return 0;
}

//自定义数据类型排序
class Person {
public:
	Person(string name,int age,double height) {
		this->name = name;
		this->age = age;
		this->height = height;
	}
	string name;
	int age;
	double height;
};
ostream& operator<<(ostream& out ,const Person& p) {
	out << "  name =" << p.name << " age = " << p.age << " height = " << p.height << endl;;
	return out;
}

bool ComparePerson(Person& p1, Person& p2) {
	if (p1.age == p2.age)
		return p1.height > p2.height;
	return p1.age < p2.age;
}
void Print(const list& p) {
	for (list::const_iterator it = p.begin(); it != p.end(); it++) {
		cout << *it ;
	}
	cout << endl;
}
void test() {
	list p;

	Person p1("Tomi",1,180.2);
	Person p2("Tony",2,177.4);
	Person p3("Kimi",3,190.9);
	Person p4("xxxx", 3, 200.2);
	Person p5("bbbb", 1, 160.2);

	p.push_back(p1);
	p.push_back(p2);
	p.push_back(p3);
	p.push_back(p4);
	p.push_back(p5);


	Print(p);

	p.reverse();
	Print(p);

	p.sort(ComparePerson);
	Print(p);

}
int main() {
	test();

	return 0;
}

所有元素都会在插入时自动排序

本质：属于关联式容器，底层结构是二叉树实现

• set ： 不允许容器中有重复的元素
• multiset：允许容器中有重复的元素

set s1;

//插入数据，只有insert方式
s1.insert(10);
s1.insert(20);

#include
#include
using namespace std;

void Print(const set& s) {
	for (set::const_iterator it = s.begin(); it != s.end(); it++) {
		cout << *it << " ";
	}
}
void Print(const multiset& s) {
	for (multiset::const_iterator it = s.begin(); it != s.end(); it++) {
		cout << *it << " ";
	}
}

void test() {
	set s;
	s.insert(9);
	s.insert(2);
	s.insert(7);
	s.insert(1);
	s.insert(10);
	s.insert(10);			//插了重复的值，但只会显示一个

	Print(s);
}

void test02() {
	multiset s;
	s.insert(9);
	s.insert(2);
	s.insert(7);
	s.insert(1);
	s.insert(10);
	s.insert(10);			//可以插入重复值

	Print(s);
}

int main() {
	test02();
	return 0;
}

是按照排序后的顺序进行删除

对于count 在set 里只会返回0，1，而在multiset 则会返回其他值，因为 set里不允许插入重复数据

//set

void test() {
	set s;
	
	//接收 insert 的返回值，查看是否插入成功
	//insert 在这里返回值是：pair::iterator,bool> ，pair是对组类型 有两个值
	pair::iterator, bool> ret = s.insert(9);

	//返回值有两个 想查看第二个,即bool类型值
	if (ret.second) {
		cout << "insert success" << endl;
	}
	else
	{
		cout << "insert fail" << endl;
	}	
	Print(s);				//成功
	
	//再插入 9
	ret = s.insert(9);
	if (ret.second) {
		cout << "insert success" << endl;
	}
	else
	{
		cout << "insert fail" << endl;
	}
	Print(s);				//失败

}

// multiset

void test02() {
	multiset s;
	
	//接收 insert 的返回值，查看是否插入成功
	//insert 在这里返回值是：multiset::iterator
	multiset::iterator ret = s.insert(9);

	//返回值只有1个
	if (*ret) {
		cout << "insert success ,inserted is  " << *ret << endl;
	}
	else
	{
		cout << "insert fail " << *ret << endl;
	}
	Print(s);							//output 9

	//再插入 9
	ret = s.insert(9);
	if (*ret) {
		cout << "insert success ,inserted is " << *ret << endl;
	}
	else
	{
		cout << "insert fail " << *ret << endl;
	}
	Print(s);							//output 9 9
		
	//两次插入均成功
}

void test03() {
	//方法 1
	pair p("Tom", 2);
	cout << p.first << "\t" << p.second << endl;

	//方法 2 
	pair p2 = make_pair("Tom", 2);
	cout << p.first << "\t" << p.second << endl;
}

利用 仿函数 改变排序规则

基本数据类型同理：

#include
using namespace std;

class Person {
public:
	Person(int age, int grade) {
		this->age = age;
		this->grade = grade;
	}
	
	int age;
	int grade;
};


class MyCompare {
public:
	bool operator()(Person p1, Person p2) const{		//注意这里 要加const
		if (p1.age == p2.age) {
			return p1.grade > p2.grade;
		}
		return p1.age > p2.age;
	}
};


void Print(const set& p) {
	for (set::iterator it = p.begin(); it != p.end(); it++) {
		cout<< "age = " << (*it).age << "  grade = " << (*it).grade << endl;
	}
	cout << endl;
}

void test() {
	//需要在插入前指定 排序规则，这里我指定的规则在MyCompare类中, 重载了（）即仿函数
	set p;

	p.insert(Person(5, 2));
	p.insert(Person(1, 2));
	p.insert(Person(1, 3));
	p.insert(Person(2, 2));
	p.insert(Person(4, 2));

	Print(p);
}

int main() {
	test();

	return 0;
}

1. map 中所有元素都是 pair;

2. pair中第一个元素为 key （键值）起到索引作用，第二个元素为 value（实值）;

3. 所有元素都会根据元素的键值自动排序;

map/ multimap 属于关联式容器，底层结构是用二叉树实现

优点：
可以根据key值快速找到value值;

map \ multimap 区别
map 不允许容器中有重复 key 值元素
multimap 允许容器中有重复 key 值元素

#include
#include
using namespace std;

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

};

void test() {
	map m;

	m.insert(pair(1, Person("yhx", 1)));
	m.insert(pair(2, Person("hq", 1)));

	for (map::iterator it = m.begin(); it != m.end(); it++) {
		cout <<"name = "<< it->second.name << " age = " << it->second.age << endl;
	}

}

int main() {
	test();
	return 0;
}

//可以利用【】 进行访问 
map m;
m.insert(pair(1,2));
m.insert(make_pair(2,3));

// m:  (1,2), (2,3)
cout<< m[2] << endl;	//output 3	,通过键值 访问

void test1() {
	map m;
	m.insert(pair(1, 100));
	m.insert(pair(2, 200));
	m.insert(pair(3, 300));

	map::iterator pos = m.find(3);		//true
	if (pos != m.end()) {
		cout << "info first is " << pos->first << "   info second is " << pos->second << endl;
	}
	else {
		cout << "fail " << endl;
	}


	pos = m.find(4);								//false
	if (pos != m.end()) {
		cout << "info first is " << pos->first << "   info second is " << pos->second << endl;
	}
	else {
		cout << "fail "<< endl;
	}


	m.insert(pair(1, 100));				//无效的插入
	cout << "count is " << m.count(1) << endl;
}

这里思考了 multimap 可以允许有重复 key值 这时find（）怎么处理

void test2() {
	multimap m;
	m.insert(pair(1, 100));
	m.insert(pair(2, 200));
	m.insert(pair(3, 300));
	m.insert(pair(3, 400));

	for (map::iterator it = m.find(3); it != m.end(); it++) {
		cout << it->first << "  " << it->second << endl;
	}

	m.insert(pair(1, 100));				//有效的插入
	cout << "count is " << m.count(1) << endl;		//output 2
}	

依旧是利用 仿函数 修改排序规则

#include
#include
using namespace std;

class Compare {
public:
	bool operator()( int a, int b) const{
        //降序
		return a > b;
	}
};

void test() {
	multimap m;		//加上 排序的类
	m.insert(pair(4, 100));
	m.insert(pair(5, 200));
	m.insert(pair(7, 3300));
	m.insert(pair(3, 400));
	m.insert(pair(1, 1400));
	m.insert(pair(2, 4000));
	m.insert(pair(6, 4300));

	for (map::iterator it = m.begin(); it != m.end(); it++) {		//从大到小
		cout << it->first << "  " << it->second << endl;
	}
}	


int main() {
	test();
	return 0;
}

如果一个类将()运算符重载为成员函数，这个类就称为函数对象类，这个类的对象就是函数对象。

函数对象是一个对象，但是使用的形式看起来像函数调用，实际上也执行了函数调用，因而得名。

#include
#include
using namespace std;

class MyAdd {
public:
	int operator()(int v1,int v2) {
		return v1 + v2;
	}
};

void test() {
	MyAdd myadd;
	cout << myadd(10, 20) << endl;	//像函数一样被调用，实则是个类
}
//-----------------------------------------

class MyPrint {
public:
	MyPrint() {
		count = 0;
	}
	int count;						//能保存自己的状态
	void operator()(string test) {
		cout << test << endl;
		count++;
	}
};

void test1() {
	MyPrint myprint;
	myprint("hello");
	myprint("hello");
	myprint("hello");
	cout << myprint.count << endl;
}
//-----------------------------------------

void show(MyPrint& p,string test) {	//可以当函数参数传入
	p(test);
}

void test2() {
	MyPrint myprint;
	show(myprint,"Hello c++");
}

int main() {
	test();
	test1();
	test2();
	return 0;
}

概念：

• ==返回值为bool类型的仿函数==称为谓词

• 如果operator（）接收一个参数，那么叫一元谓词

• 如果operator（）接收两个参数，那么叫二元谓词

  函数参数 提示中 Pred 就是谓词

#include
using namespace std;

class Big {
public:
	bool operator()(int val) {
		return val > 5;
	}
};

void test() {
	vector p;
	for (int i = 0; i < 10; i++) {
		p.push_back(i);
	}


	sort(p.begin(), p.end());
	cout << "未找前：" << endl;
	for (vector::iterator it = p.begin(); it != p.end(); it++) {
		cout << *it << " ";
	}

	cout << "\n找后：" << endl;
	//这里find()_if 需要传入 起始位，终点位 和 函数对象 
	//Big() 是 匿名函数对象
	vector::iterator pos = find_if(p.begin(), p.end(), Big());		
	while (pos != p.end())
	{
		cout << *pos <<  " ";
		pos++;
	}

}

int main() {
	test();

	return 0;
}

class Sort{
public:
	bool operator()(int v1, int v2) {
		return v1 > v2;
	}
};

void test2() {
	vector p;
	p.push_back(40);
	p.push_back(20);
	p.push_back(10);
	p.push_back(70);
	p.push_back(50);
	p.push_back(60);

	cout << "Before sort" << endl;
	for (vector::iterator it = p.begin(); it != p.end(); it++) {
		cout << *it << "  ";
	}

	cout << endl;

	cout << "After sort" << endl;
	sort(p.begin(), p.end(), Sort());
	for (vector::iterator it = p.begin(); it != p.end(); it++) {
		cout << *it << "  ";
	}
}

STL 内自带的一些函数对象

#inlude		//头文件

• 分类：
  算数仿函数

• 关系仿函数

• 逻辑仿函数

#include
#include
using namespace std;

void test() {
	negate n;
	cout << n(20) << endl;
}

void  test2() {
	plus n;		//虽然是加法 但只用传一个参，仿函数参数都是一个参
	cout << n(1.2, 3.4) << endl;
}

int main() {
	test();
	test2();
	return 0;
}

#include
#include
#include
using namespace std;

class MyGreat {
public:
	bool operator()(int v1, int v2) {
		return v1 > v2;
	}
};

void test() {
	vector p;

	p.push_back(1);
	p.push_back(3);
	p.push_back(6);
	p.push_back(2);
	p.push_back(4);

	for (vector::iterator it = p.begin(); it != p.end(); it++) {
		cout << *it << " ";
	}
	cout << endl;

	//sort(p.begin(), p.end(), MyGreat());		//匿名 仿函数 MyGreat()
	sort(p.begin(), p.end(), greater());	//等于上面的代码，只是greater是STL写好了的仿函数

	for (vector::iterator it = p.begin(); it != p.end(); it++) {
		cout << *it << " ";
	}
}

int main() {
	test();

	return 0;
}

#include
#include
#include
#include
using namespace std;


void test() {
	vector v;
	v.push_back(true);
	v.push_back(false);
	v.push_back(true);
	v.push_back(false);
	v.push_back(true);

	for (vector::iterator it = v.begin(); it != v.end(); it++) {
		cout << *it << " ";
	}
	cout << endl;

	vector v2;
	v2.resize(v.size());

	//使用 逻辑非 将容器v搬运到v2中
	transform(v.begin(), v.end(), v2.begin(), logical_not());

	for (vector::iterator it = v2.begin(); it != v2.end(); it++) {
		cout << *it << " ";
	}
}

int main() {
	test();

	return 0;
}

#include
#include
#include
#include
using namespace std;

class MyOrder {
public:
	void operator()(int val) {
		cout << val << " ";
	}
};

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

void test() {
	vector<int> v;
	for (int i = 0; i < 10; i++) {
		v.push_back(i + 1);
	 }
	for_each(v.begin(), v.end(), Print);	//普通函数放函数名
	cout << endl;

	for_each(v.begin(), v.end(), MyOrder());		//仿函数放匿名对象

}

int main() {
	test();
	return 0;
}

//源码：
template
Function for_each(InputIterator first, InputIterator last, Function fn)
{
  while (first!=last) {
    fn (*first);
    ++first;
  }
  return fn;      // or, since C++11: return move(fn);
}

#include
#include
#include
#include
using namespace std;

void Print(int val) {
	cout << val << endl;
}

class Transform {
public:
	int operator()(int val) {
		return val + 100;		//还可以进行运算
	}
};

class Prints {
public:
	void operator()(int val) {
		cout << val << " ";
	}
};

void test() {
	vector v;
	for (int i = 0; i < 10; i++) {
		v.push_back(i+1);
	}

	vector v2;
	v2.resize(10);
	transform(v.begin(), v.end(), v2.begin(),Transform());

	for_each(v2.begin(), v2.end(), Prints());
}

int main() {
	test();
	return 0;
}

返回迭代器

//find 查找基本数据类型 返回是迭代器
#include
#include
#include
#include
using namespace std;

void Print(int val) {
	cout << val << endl;
}


void test() {
	vector v;
	for (int i = 0; i < 10; i++) {
		v.push_back(i+1);
	}
    //我选择打印地址
	vector::iterator pos = find(v.begin(), v.end(), 5);
	cout << &( * pos ) << endl;
	pos = find(v.begin(), v.end(), 6);
	cout << &(*pos) << endl;

}

int main() {
	test();
	return 0;
}

地址是连续的（int 是4个字节） 证明了 vector 是连续存储 故能随机访问

//find 底层源码
template 
_NODISCARD constexpr _InIt _Find_unchecked1(_InIt _First, const _InIt _Last, const _Ty& _Val, false_type) {
    // find first matching _Val
    for (; _First != _Last; ++_First) {
        if (*_First == _Val) {		//注意：这里对自定义数据类型要判断是否相等 要重载== 运算符
            break;
        }
    }

    return _First;
}

//查找自定义数据类型


#include
#include
#include
#include
#include
using namespace std;

void Print(int val) {
	cout << val << endl;
}

class Person {
public:
	Person(string name) {
		this->name = name;
	}
	string getName() {
		return name;
	}
	bool operator==(const Person& p) {
		if (p.name == this->name) {
			return true;
		}
		else
		{
			return false;
		}
	}
private:
	string name;
};


void test() {
	vector v;
	for (int i = 0; i < 10; i++) {
		v.push_back(i+1);
	}
	vector::iterator pos = find(v.begin(), v.end(), 5);
	cout << &( * pos ) << endl;
	pos = find(v.begin(), v.end(), 6);
	cout << &(*pos) << endl;

}

void test2() {
	vector v;
	Person p1("Tom1");
	Person p2("Tom2");
	Person p3("Tom3");
	Person p4("Tom4");

	v.push_back(p1);
	v.push_back(p2);
	v.push_back(p3);
	v.push_back(p4);

	vector::iterator pos = find(v.begin(), v.end(), Person("Tom3"));
	if (pos == v.end()) {
		cout << "fail" << endl;
	}
	else
	{
		cout << (*pos).getName() << endl;
	}
}

int main() {
	test2();
	return 0;
}

返回迭代器

#include
#include
#include
#include
#include
using namespace std;

void Print(int val) {
	cout << val << endl;
}

class Person {
public:
	Person(string name) {
		this->name = name;
	}
	string getName() {
		return name;
	}
	bool operator==(const Person& p) {
		if (p.name == this->name) {
			return true;
		}
		else
		{
			return false;
		}
	}
	
private:
	string name;
};

class MyCompare {
public:
	bool operator()(Person& p) {		//一元谓词
		return p.getName() == "Tom3";
	}
};


void test() {
	vector v;
	for (int i = 0; i < 10; i++) {
		v.push_back(i+1);
	}
	vector::iterator pos = find(v.begin(), v.end(), 5);
	cout << &( * pos ) << endl;
	pos = find(v.begin(), v.end(), 6);
	cout << &(*pos) << endl;

}

void test2() {
	vector v;
	Person p1("Tom1");
	Person p2("Tom2");
	Person p3("Tom3");
	Person p4("Tom4");

	v.push_back(p1);
	v.push_back(p2);
	v.push_back(p3);
	v.push_back(p4);

	vector::iterator pos = find(v.begin(), v.end(), Person("Tom3"));
	if (pos == v.end()) {
		cout << "fail" << endl;
	}
	else
	{
		cout << (*pos).getName() << endl;
	}

	vector::iterator pos2 = find_if(v.begin(), v.end(), MyCompare());	//只能接收一元谓词
	if (pos2 == v.end()) {
		cout << "fail" << endl;
	}
	else
	{
		cout << (*pos2).getName() << endl;
	}

}

int main() {
	test2();
	return 0;
}

返回迭代器

返回 bool

在有序序列才能用

//自定义数据类型

#include
#include
#include
#include
#include
using namespace std;

void Print(int val) {
	cout << val << endl;
}

class Person {
public:
	Person(string name) {
		this->name = name;
	}
	string getName() {
		return name;
	}
	bool operator==(const Person& p) {
		if (p.name == this->name) {
			return true;
		}
		else
		{
			return false;
		}
	}
	
private:
	string name;
};

void test() {
	Person p("Jerry");
	Person p2("Tom");
	Person p3("Lucy");

	vector v;
	v.push_back(p);
	v.push_back(p2);
	v.push_back(p3);

	Person pp("Kit");

	int counts = count(v.begin(), v.end(), pp);
	cout << counts << endl;
}



int main() {
	test();
	return 0;
}

//自定义数据类型排序

#include
#include
using namespace std;

class Person {
public:
	Person(string name,int age) {
		this->name = name;
		this->age = age;
	}
	string getName() {
		return name;
	}
	int getAge() {
		return age;
	}
	bool operator==(const Person& p) {
		if (p.name == this->name) {
			return true;
		}
		else
		{
			return false;
		}
	}

private:
	string name;
	int age;
};

void Print(Person& val) {
	cout << val.getName() <<"\t" < p2.getAge();
}

class Func {
public:
	bool operator()(Person& a, Person& b) {
		return a.getAge() > b.getAge();
	}
};


void test() {
	Person p("Jerry",1);
	Person p2("Tom",2);
	Person p3("Lucy",4);
	Person p4("xxx", 3);


	vector v;
	v.push_back(p);
	v.push_back(p2);
	v.push_back(p3);
	v.push_back(p4);

	sort(v.begin(), v.end(),Func());
	for_each(v.begin(), v.end(), Print);


	sort(v.begin(), v.end(), func);
	for_each(v.begin(), v.end(), Print);

}

int main() {
	test();
	return 0;
}

#include
#include
using namespace std;

class Print {
public:
	void operator()(int val) {
		cout << val << " ";
	}
};

void test() {
	
	srand((unsigned int)time(NULL));		//随机数发生器

	vector v;
	for (int i = 0; i < 10; i++) {
		v.push_back(i + 1);
	}
	random_shuffle(v.begin(), v.end());
	for_each(v.begin(), v.end(), Print());
}


int main() {
	test();
	return 0;
}

• 两个容器必须是 有序的，且顺序要一致，升序就要一起升序
• 使用算合并完仍然是有序的

#include
using namespace std;

class Print {
public:
	void operator()(int val) {
		cout << val << " ";
	}
};

class Great5 {
public:
	bool operator()(int val) {
		return val >= 5;
	}
};
void test() {
	vector v;
	for (int i = 0; i < 10; i++) {
		v.push_back(i + 1);
	}
	for_each(v.begin(), v.end(), Print());

	replace_if(v.begin(), v.end(), Great5(),999);	//大于5的数字换成999
	cout << endl;

	for_each(v.begin(), v.end(), Print());
}


int main() {
	test();
	return 0;
}

容器必须是同类型

#include
using namespace std;

void test() {
	vector v;
	for (int i = 0; i < 10; i++) {
		v.push_back(i + 1);
	}

	int total = accumulate(v.begin(), v.end(), 0);	//0 是起始值
	cout << total << endl;
}


int main() {
	test();
	return 0;
}

两个容器必须有序

#include
#include
using namespace std;

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

void test() {
	vector v;
	vector v2;
	
	v.push_back(6);
	v.push_back(7);
	v.push_back(2);
	v.push_back(3);
	v.push_back(5);
	v.push_back(4);

	v2.push_back(1);
	v2.push_back(7);
	v2.push_back(8);
	v2.push_back(9);
	v2.push_back(2);
	v2.push_back(10);
	v2.push_back(11);
	v2.push_back(12);
	v2.push_back(0);

	sort(v.begin(), v.end());
	sort(v2.begin(), v2.end());

	vector vTarget;
	vTarget.resize(min(v.size(), v2.size()));

	vector::iterator itEnd = set_intersection(v.begin(), v.end(), v2.begin(), v2.end(), vTarget.begin());

	for_each(vTarget.begin(), itEnd, MyPrint);  //注意这里 我是以itEnd 结尾的，如果用vTarget.end()结尾，则 会补0输出
}


int main() {
	test();
	return 0;
}

#include
#include
using namespace std;

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

void test() {
	vector v;
	vector v2;
	
	v.push_back(6);
	v.push_back(7);
	v.push_back(2);
	v.push_back(3);
	v.push_back(5);
	v.push_back(4);

	v2.push_back(1);
	v2.push_back(7);
	v2.push_back(8);
	v2.push_back(9);
	v2.push_back(2);
	v2.push_back(10);
	v2.push_back(11);
	v2.push_back(12);
	v2.push_back(0);

	sort(v.begin(), v.end());
	sort(v2.begin(), v2.end());

	vector vTarget;
	vTarget.resize(v.size() + v2.size());

	vector::iterator itEnd = set_union(v.begin(), v.end(), v2.begin(), v2.end(), vTarget.begin());
	vTarget.resize(itEnd - vTarget.begin());		//这样可以计算并集大小

	for_each(vTarget.begin(), vTarget.end(), MyPrint);
}


int main() {
	test();
	return 0;
}

差集

#include
using namespace std;

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

void test() {
	vector v;
	vector v2;
	
	v.push_back(6);
	v.push_back(7);
	v.push_back(2);
	v.push_back(3);
	v.push_back(5);
	v.push_back(4);

	v2.push_back(1);
	v2.push_back(7);
	v2.push_back(8);
	v2.push_back(9);
	v2.push_back(2);
	v2.push_back(10);
	v2.push_back(11);
	v2.push_back(12);
	v2.push_back(0);

	sort(v.begin(), v.end());
	sort(v2.begin(), v2.end());

	vector vTarget;
	vTarget.resize(max(v.size(),v2.size()));

	//v1的差集
	vector::iterator itEnd = set_difference(v.begin(), v.end(), v2.begin(), v2.end(), vTarget.begin());
	for_each(vTarget.begin(), itEnd, MyPrint);		//output 3 4 5 6

	cout << endl;

	//v2的差集
	itEnd = set_difference(v2.begin(), v2.end(), v.begin(), v.end(), vTarget.begin());
	for_each(vTarget.begin(), itEnd, MyPrint);		//output 0 1 8 9 10 11 12
}


int main() {
	test();
	return 0;
}
r (int i = 0; i < 10; i++) {
		v.push_back(i + 1);
	}
	random_shuffle(v.begin(), v.end());
	for_each(v.begin(), v.end(), Print());
}


int main() {
	test();
	return 0;
}