十六：IO操作
IO对象无拷贝和赋值，只能引用传递，并且不能是const
函数good() 所有错误位都没置位的情况下返回true;
fail() 一般用作流使用的条件（failbit,badbit）
eof()和bad()只表示特定的错误。
例如：将failbit和badbit复位，但eofbit不变
cin.clear(cin.rdstate() &~cin.failbit & ~cin.badbit);
endl 换行并刷新缓冲区。
要每次输出都刷新缓冲区，用unitbuf cout<<unitbuf;
cout<<nounitbuf; 回到正常的缓冲方式。
x.tie(&o); 将流x关联到流o
ostringstream允许保存字符串，最后输出，他在#include<sstream>中
相对于stirng，他能够使用>>操作东西。
#include<string>
#include<sstream>
usingnamespace std;
int main()
{
ostringstream formatted;
formatted<< " "<<
"Hello" <<endl; //这格式，这样保存，相当于string的+号
cout<< formatted.str();
return 0;
}
十七：容器
----------------支持快速随机访问-----------------
array固定大小。
vector
string
deque
----------不支持随机访问--------------
list
forward_list
----------容器适配器-------------
stack,queue – 基于deque
priority_queue – 基于 vector
array 可以进行拷贝和赋值，内置数组不行。
数组不能初始化给array，花括号也不能赋值给array对象。
array对象的赋值，两边的类型必须完全一样。
swap 交换array时间与元素个数成正比。
swap 交换其他容器，其实只交换两个容器的数据结构，常数时间内就可以完成。
每个容器都支持== 和 != ,但是<=等等不一定。
insert 插入到迭代器指定位置之前(1:迭代器可能指向尾部不存在的元素位置，2：开始位置插入的功能很有用)，forward_list有自己特色的insert(insert_after)
emplace_front/emplace/emplace_back (调用对应的构造函数创建对象)
功能对应
push_front/insert/push_back
front/back（除forward_list） 返回首尾元素的引用。
capacity和reserve只适用vector和string
reserve不改变容器元素的数量，仅影响预先分配多大的空间。
resize只改变元素数量，不改变容量。
十八：泛型算法
1:头文件：numeric algorithm
2:迭代器另算法不依赖于容器，但算法依赖于元素类型的操作。
如：find用元素的==完成比较。
3:算法使用的是迭代器，不能执行容器操作，所以
算法永远不会改变底层容器的大小（不会删除和添加元素）
因为插入迭代器，默认在赋值时调用了容器算法：push_back()，所以他可以改变容器大小。
4:插入迭代器
（1）作为目的位置，可以保证算法有足够的元素空间。
如：fill_n(back_inserter(vec),10,0);
（2）赋值，会调用push_back将元素添加到容器：
如：vector<int> vec;
auto it = back_inserter(vec);
*it = 42;//实际调用了push_back;
5：谓词：一个可调用的表达式，返回能用做条件的值
bool isShorter(const string&s1,const string &s2)
{
returns1.size() < s2.size();
}
sort(vec.begin(),vec.end(),isShorter);
//stable_sort 可以保持等长元素间的字典序。
6：lambda表达式
1）
可调用对象：（1）函数 （2）函数指针（3）重载了函数调用运算符的类 （4）lambda表达式
可以理解为：未命名的内联函数（与函数不同的是，他可以定义在函数内部）
[]()->return type {}
[捕获列表](参数列表)->返回类型{函数体} ///捕获列表和函数体不能省略。
2）
lambda根据函数体默认推断返回类型，如果函数体包含任何单一return语句之外的内容，且未指定返回类型，则默认返回void，要明确返回类型，必须指定返回类型。
lambda不能有默认参数。
find_if 只接受一个一元谓词。
一：）捕获列表弥补了参数数量的问题。
二：）参数数量的问题可以用bind函数解决
捕获列表只用于局部非static变量，lambda可以直接使用局部static变量和它所在函数之外的声明的名字。
lambda数据成员（捕获列表）在lambda对象创建时被初始化。而不是调用时。
3）
捕获可以是值捕获或者引用捕获。
可以让编译器根据lambda体中的代码推断我们要使用那些变量，为了指示编译器推断捕获列表，应在捕获列表中写一个&或=；
可以混合使用，如[=,&os],默认都是值捕获，os采用引用捕获。混合使用时，捕获列表的第一个元素必须是&或=
4）
可变lambda
要改变捕获变量的值，必须在参数列表首加个mutable,因此，可变lambda能省略参数列表。
如：
auto f = [v1]()mutable{++v1;};
5）指定lambda返回类型(必须使用尾置返回类型)
transform(vi.begin(),vi.end(),vi.begin(),[](inti)->int{ if(i<0) return –i;else return i;});//函数体不是一个单独return ，并且不是void返回，所以必须指定返回类型。
7：for_each接受可调用对象
for_each(vec.begin(),vec.end(),[](conststring *s){coust<<s<<;};
8：bind函数适配器
接受一个可调用对象，生成一个新的可调用对象来“适应”原对象的参数列表。
1）
find_if(vec.begin(),vec.end(),[sz](conststring &a){return a.size()>=sz;});
find_if(vec.begin(),vec.end(),bind(check_size,_1,sz));//check_size是一个函数，它比较_1字符串长度和sz的大小
如：auto checkfun = bind(check_size,_1,6);
string s = “hello”;
bool b1 = checkfun(s);
_n定义在placeholders的命名空间中，而placeholders定义在std中,也定义在functional头文件中。
using namespace std::placeholders
2)
bind 可以重新安排参数顺序：
如：
auto g = bind(f,a,b,_2,c,_1);
g(X,Y);相当于调用f(a,b,Y,c,X);
这样其实可以灵活运用参数顺序的不同，重排
sort(vec.begin(),vec.end(),isShorter);//正序
sort(vec.begin(),vec.end(),bind(isShorter,_2,_1));//逆序
反向迭代器也可以实现逆序
sort(vec.rbegin(),vec.rend());
3)bind绑定引用参数
ostream &print(ostream &os,conststring &s,char c){ return os<<s<<c;}
for_each(vec.begin(),vec.end(),[&os,c](conststring &s){.....});
引用捕获的代替：
for_each(vec.begin(),vec.end(),bing(print,ref(os),_1,‘ ’));
cref 生成一个保存const引用的类。
（1）查找：find 需要 ==
find(vec.cbegin(),vec.cend(),val);
find(ia+1,ia+4,val); 子范围查找
（2）求和：accumulate需要 +
accumulate(vec.cbegin(),vec.cend(),0);//0是初始值
（可以累加string,拼接）
（3）判断相等：equal 需要== 假定第二个序列和第一个一样长。char*竟也可以用==比较
equal(vec.cbegin(),vec.cend(),list1.cbegin());
（4）值覆盖：fill_n
fill_n(vec.begin(),vec.size(),0);
（5）拷贝 :目的序列至少与输入序列一样多
int a1[]={1,2,3};
int a2[sizeof(a1)/sizeof(*a1)];
auto ret =copy(begin(a1),end(a1),a2);//ret指向a2尾元素之后的位置
（6）替换：
replace(ilst.begin(),ilst.end(),0,42);//把0替换为42
如果希望原序列不变：
replace_copy(ilst.cbegin(),ilst.cend(),back_inserter(vec),0,42);
（7）排序：sort 需要 <
sort(vec.begin(),vec.end());
对排完序的可以去重一下：unique只能处理排好序的
auto it = unique(vec.begin(), vec.end());//it 指向不重复区域’后一个位置’的迭代器
进而可以删除
vec.erase(it,vec.end());
(8)转化
transform(vi.begin(),vi.end(),vi.begin(),[](inti){return i<0?-i:i;});
//目的位置迭代器和输入开始的迭代器相同。
（9）删除
remove_if(v1.begin(),v1.end(),[](inti){return i%2;});//删除奇数元素
//将偶数元素从v1拷贝到v2,v1不变
remove_copy_if(v1.begin(),v1.end(),back_inserter(v2),[](inti){return i%2});
(10)通用版本的sort需要随机访问迭代器，所以不能用于list和forward_list。
（11）取两个set的交集：set_intersection(s1.begin(),s1.end(),s2.begin(),s2.end(),s3)
十九：迭代器
1：插入迭代器 赋值时，调用容器操作来操作
back_inserter 使用push_back
front_inserter 使用 push_front会将插入元素的顺序颠倒过来。
inserter 使用insert :*t =val,等价于
it = c.insert(it,val);
++it;//递增it，使它指向原来的元素（所以，可以用inserter连续顺序插入）
*it,++it,it++不会做任何操作，都返回it
2：iostream迭代器
1）
istream读取的类型必须定义了>>运算符
istream_iterator<int> int_it(cin);
istream_iterator<int> int_eof;//默认初始化迭代器是：尾后迭代器
vector<int>vec(in_it,int_eof);//从迭代器范围构造vec
++in,in++ 使用元素类型定义的>>，从输入流中读取下一个值。
2）
ostream 需要类型具有<<输出运算符。
创建ostream_iterator时，可以提供（可选）第二个参数，每个输出元素后都会打印此字符串。
*out,++out,out++ 不做任何操作，都返回out
osteam_iterator<int>out_iter(cout,” “);
for(auto e:vec)
*out_iter++= e;//赋值语句实际上将元素写到cout
等同于out_iter = e;
可以调用copy打印vec中元素，比循环简单：
copy(vec.begin(),vec.end(),out_iter);
3:反向迭代器
++it指向前一个元素
rbegin/crbegin rend/crend 指向容器尾元素和首元素前一个位置的指针。
sort逆序排序
我们只能从既支持++又支持—的迭代器来定义反向迭代器，流不支持递减，所以不能从forward_list和流迭代器创建反向迭代器。
通过调用reverse_iterator的base成员把反向迭代器转换为普通迭代器
|rit.base |end()
--------------------------------
| |rbegin
rit
rit和rit.base指向不同元素，rbegin和end也是不同元素
迭代器类别：（根据支持的操作不同）
1）输入迭代器
2）输出迭代器
3）前向迭代器
4）双向迭代器
5）随机访问迭代器
链表特有的操作会改变容器，如merge,splice(元素合并)
二十：关联容器 map set
有序保存：
map/multimap
set/multiset
无序
unordered_map/unordered_multimap
unordered_set/unordered_multiset
1：
关联容器，除了与顺序容器相同的操作外
1）有独有的操作，如count(val) 返回容器中val的个数
2）类型别名
3）无序容器提供一些调整哈希性能的操作。
key_type
mapped_type(只适用于map)
value_type,对于set与key_type相同，set中的关键字也是const的
对于map，为pair<const key_type,mapped_type>,我们不能改变元素的关键字，所以关键字类型是const的。
2：map 插入
对于不包含重复关键字的容器，insert和emplace 返回一个pair.
pair的first是一个迭代器，指向具有给定关键字的元素。
pair的second是一个bool值，指出插入成功还是已经在容器中。
不能对multi版本的map执行下标运算。
set也不能执行下标运算。
因为下标运算符可能插入一个新的元素，所以，只能对非const的map使用下标运算符。
3：
lower_bound（val）返回第一个与查找元素匹配的元素，如果没有，则指向第一个关键字大于val的元素。
upper_bound(val)返回指向最后一个匹配val的之后的元素。
这两个可以作为一个迭代器范围。
equal_range（val）返回一个迭代器pair。
若关键字存在：第一个迭代器指向第一个与关键字匹配的元素，第二个迭代器指向最后一个匹配元素之后的位置。
若关键字不存在：两个迭代器指向关键字可以插入的位置。
for(auto pos =authors.equal_range(val);pos.first != pos.second;++pos.first)
cout<<pos.first->second<<endl;
4：无序容器 unordered_......
不使用比较运算符组织元素，而是使用一个哈希函数hash<key_type>生成哈希值和== 组织元素。
在存储上组织为一组桶。
性能依赖于哈希函数的质量和桶的数量和大小。
标准库为内置类型（包括指针）提供了hash模板。我们可以直接定义关键字是内置类型（包括指针）、string还是智能指针类型的无序容器。
为了使用自定义的类型定义无序容器，我们需要提供代替==运算符和哈希值计算函数。
size_t hasher（const Sales_data&sd）
{
returnhash<string>()(sd.isbn());
}
bool eqOp(const Sales_data&lhs,const Sales_data &rhs)
{
returnlhs.isbn() == rhs.isbn();
}
using SD_multiset = unordered_multiset<Sales_data,decltype(hasher)*,decltype(eqOp)*>;
SD_multiset bookstore(32,hasher,eqOp);
如果我们定义了==运算符，则可以只重载hash函数
unordered_set<Foo,decltype(FooHash)*>fllSet(10,FooHash);
无论有序还是无序容器，具有相同关键字的元素都是相邻存储的。
二十一：动态内存
智能指针（模板）
1：shared_ptr 允许多个指针指向同一对象
例：shared_ptr<int> p =make_shared<int>(32);//make_shared会构造对象
（1）
对于内置类型加不加()有区别，如果是自定义类型，则没什么区别，都是调用的默认构造函数。
int *p1 = new int;//默认初始化，*p1未定义。
int *p2 = new int();//值初始化为0，*p2值为0；
（2）括号包围的初始化器，可以用auto推断要分配的类型
auto p1 = new auto(obj);//括号中仅有单一初始化器是才可以；
（3）可以对数组元素进行值初始化，但是auto不能推断数组。
int *p1 = new int[10];//10个未初始化int
int *p1 = new int[10]();//10个值初始化为0的int
对于数组，不能在括号中给出初始化器，即，不能用auto做推断。
（4）delete执行两个动作：1：销毁对象 2：释放内存
const 对象不能被改变，但是可以被销毁（delete）
const int *p1 = new const int(10);
delete p1;
(5)接受指针参数的智能指针是explicit的，所以，不能将内置指针隐式转化为智能指针，必须使用直接初始化。
shared_ptr p1 = new int(10);//错误，函数返回也类似
shared_ptr p2(new int(10));//正确
（6）不要混用普通指针和智能指针，因为原则上，如果我们把内存的管理责任交个智能指针，那么就不应该用内置指针来访问了。因为可能已经释放了，用内置指针访问会出错。
（7）不能使用get初始化另一个智能指针，或为智能指针赋值。
使用get返回指针的代码，不能delete此指针。因为用get返回的指针初始化的智能指针与原来的是独立的，互相不知道对方的引用计数。
（8）使用异常处理程序能够在异常发生后另程序流程继续。确保资源被正确释放的方法是使用智能指针。
（9）可以在初始化shared_ptr时，指定删除器。
shared_ptr<T> p(q,fundelete);(当智能指针管理的资源不是new分配的内存时，很管用。比如连接资源)；
2:unique_ptr 独占使用所指对象
（1） unique_ptr是独占，所以，不支持拷贝和赋值
unique_ptr<string> p1(new string(“nihao”));
unique_ptr<string> p2 = p1;//错误
unique_ptr<string> p2(p1);//错误
（2） release或reset将指针所有权从一个unique_ptr转移给另一个unique_ptr
（3） 不能拷贝unique_ptr有一个例外，我们可以拷贝将要销毁的unique_ptr,如函数要返回时。（编译器执行特殊的拷贝，移动赋值）
（4） 与重载关联容器（无序）类似，可以在尖括号类型后提供删除器。
unique_ptr<connection,decltype(endfun)*>p(&c,endfun);
3:weak_ptr 若引用，不增加引用计数，指向shared_ptr对象
不能使用weak_ptr直接访问对象，必须调用lock。lock返回一个指向共享对象的shared_ptr.
4:动态数组（并不是数组类型）
（1）new分配并初始化一个对象数组。
未得到数组类型指针，而是数组元素类型的指针。
（2）可以对数组中元素进行值初始化，方法是在大小后跟一对空括号。
delete []p，释放动态数组，元素按照逆序销毁。
（3）标准库提供了一个管理new分配数组的unique_ptr版本。必须在对象类型后加上空方括号。
unique_ptr<int[]>up(new int[10]);
up.release();//自动用delete[]销毁
因为up指向一个数组，而不是单个对象，所以不能用点或者箭头运算符，但是可以使用下标运算符。up[i] = i;
(4)shared_ptr不支持管理动态数组，若希望管理，必须提供自己的删除器。
shared_ptr<int> sp(newint[10],[](int p){delete []p;});
sp.reset();//他会调用delete[]
shared_ptr 没有定义下标运算符，并且不支持指针的算术运算，我们这样做：
*(sp.get()+i) = i;
5:若想让内存分配与对象构造分离，需要使用allocator替代new
new对于没有默认构造函数的类有限制。
智能指针，也只是一个指针，我们要注意分配空间（new,make_shared等）