map<string, int>p;
auto map1 = p.cbegin();
while(map1 != p.cend())
{cout<<map1->first<<map1->second<<endl;++map1;
}

对map进行插入，元素类型是pair：

p.insert({word, 1});
p.insert(pair<string, int>(word, 1));

insert对不包含重复关键字的容器，插入成功返回pair<迭代器, bool>迭代器指向给定关键字元素，bool指出插入是否成功。

vector<pair<char, int>result(val.begin(), val.end());
sort(result.begin(), result.end(), [](auto &a, auto &b){return a.send > b.second;
}）

vector容器实现与扩充

1. 底层实现

vector在堆中分配了一段连续的内存空间来存放元素。

1. 三个迭代器

（1）first：指向的是vector中对象的起始字节位置

（2）last：指向当前最后一个元素的末尾字节

（3）end：指向整个vector容器所占用内存空间的末尾字节

（1）last - first：表示vector容器中目前已被使用的内存空间

（2）end - first：表示vector容器的容量

（3）end - last：表示vector容器目前空闲的内存空间

2. 扩容过程

如果集合已满，在新增数据的时候，就要分配一块更大的内存，将原来的数据复制过来，释放之前的内存，再插入新增的元素

所以对vector的任何操作，一旦引起空间重新配置，指向原来vector的所有迭代器就都失效了

size() 和 acpacity()

（1）堆中分配内存，元素连续存放，内存空间只会增长不会减少

vector有两个函数，一个是capacity()，在不分配新内存下最多可以保存的元素个数，另一个size()，返回当前已经存储数据的个数

（2）对于vector来说，capacity是永远大于size的

capacity和size相等时，vector就会扩容，capacity变大（翻倍）

vector扩容方式的选择

1. 固定扩容

机制：

每次扩容的时候在原有capacity基础上加上固定的容量。

缺点：

考虑一种极端情况，vector每次添加的元素数量刚好等于每次扩容固定增加的容器+1，就会造成一种情况，每添加一次元素就要扩容一次，而扩容的时间花费十分昂贵，时间复杂度高

优点：

空间利用率比较高。

2. 加倍扩容

机制：

每次扩容的时候原capacity翻倍。

优点：

一次扩容capacity翻倍的方式使得正常情况下添加元素要扩容的次数大大减小（预留空间较多），时间复杂度低。

缺点：

空间利用率低

3. resize() 和 reserve()

resize()：改变当前容器内含有元素的数量，而不是容器的容量

1. 当resize(len)中len > v.capacity()，则数组中的size和capacity均设置为len；

2. 当resize(len)中len <= v.capacity()，则数组中的size设置为len，capacity不变

reserve()：改变当前容器的最大容量(capacity)

1. 如果reserve(len)的值 > 当前的capacity()，那么会重新分配一块能存len个对象的空间，然后把之前的对象通过copy constructor复制过来，销毁之前的内存；

2. 当reserve(len)中len的值<=当前的capacity()，则不对容器做任何改变。

3. vector源码

template<class T, class Alloc = alloc>
class vector {
public:typedef T value_type;typedef value_type* pointer;typedef value_type& reference;typedef size_t size_type;typedef ptrdiff_t difference_type;//嵌套类型定义，也可以是关联类型定义protected:typedef simple_allloc <value_type, Alloc> data_alloc//空间配置器（分配器）iterator start;iterator finish;iterator end_of_storage;//这三个就是vector里的数据，所以一个vector就是包含三个指针12bytevoid insert_aux(iterator position, const T& x);//这个就是vector自动扩充函数void deallocate() {if (start)data_allocator::deallocate(static_assert, end_of_storage);}//析构函数的部分实现函数void fill_initialize(size_type n, const T& value) {start = allocate_end_fill(n, value);finish = start + n;end_of_storage = finish;}//构造函数的具体实现public:iterator begin() { return start; };iterator end() { return finish; };size_type size() const { return size_type(end() - begin()); };size_type capacity() const {return size_type(end_of_storage - begin()) }bool empty() const { return begin() == end(); };reference operator[](size_type n) { return *(begin() + n); };//重载[]说明vector支持随即访问vector()::start(0), finish(0), end_of_storage(0) {};vector(size_type n, const T& value)(fill_initialize(n, value););vector(long n, const T& value)(fill_initialize(n, value););vector(int n, const T& value)(fill_initialize(n, value););explicit vector(size_type n) { fill_initialize(n, T()); };//重载析构函数~vector() {destroy(start, finish);//全局函数，析构对象deallocate(); //成员函数，释放空间 }//功能函数reference front() { return *begin(); };reference back() { return *(end() - 1); };void push_back(const T& x) {if (finish != end_of_storage) {construct(finish, x);++finish;}else insert_aux(end(), x);//先扩充再添加}void pop_back() {destroy(finish);--finish;}iterator erase(iterator position) {if (position + 1 != end())copy(position + 1, finish, position);--finish;destroy(finish);return position;}void resize(size_type new_size, const T& x) {if (new_size() < size())erase(begin() + new_size, end());elseinsert_aux(end(), new_size - size, x);}void resize()(size_type new_size) {resize(new_size, T()); }void clear() { erase(begin(), end()); }protected://配置空间并填满内容iterator allocate_and_fill(size_type n, const T& x) {iterator rsult = data_allocator::allocate(n);uninitialized_fill_n(result, n, x); //全局函数}
};

vector迭代器：由于vector维护的是一个线性区间，所以普通指针具备作为vector迭代器的所有条件，就不需要重载operator+， operator*之类的东西。

//vector迭代器
template <class T, class Alloc = alloc>
class vector {
pbulic:typedef T value_type;typedef value_type* iterator; //vector的迭代器是原生指针//...
};

vector的数据结构：线性空间。为了降低配置空间成本，我们必须让其容量大于其大小。

vector的构造以及内存管理：当我们使用push_back插入元素在尾端的时候，我们首先检查是否还有备用空间也就是说end是否等于end_of_storage，如果有直接插入，如果没有就扩充空间

//vector的构造以及内存管理
template<class T, class Alloc>
void vector<T, Alloc>::insert_aux(iterator position, const T& x) {if (finish != end_of_storage) { //有备用空间construct(finish, *(finish - 1)); //在备用空间处构造一个元素，以vector最后一个元素为初值++finish;T x_copy = x;copy_backward(position, finish - 2, finish - 1);*position = x_copy;}else {const size_type old_size = size();const size_type len = old_size != 0 ? 2 * old_size() : 1;//vector中没有元素就配置一个元素，如果有救配置两倍元素iterator new_start = data_allocator::allocate(len);iterator new_finish = new_start;try {//拷贝插入点之前的元素new_finish = uninitialized_copy(start, position, new_start);construct(new_finish, x);++new_finish;//拷贝插入点之后的元素new_finish = uninitialized_copy(position, finish, new_finish);}catch () {destroy(new_satrt, new_finish);data_allocator::deallocate(new_start, len);throw;}//析构并释放原vectordestroy(begin(), end());deallocate();//调整迭代器指向新的vectorstart = new_start;finish = new_finish;end_of_storage = new_start + len;}
}

整个分为三个部分，配置新空间，转移元素，释放原来的元素与空间，因此一旦引起空间配置指向之前vector的所有迭代器都要失效。

//vector的部分元素操作
void pop_back() {--finish;destroy(finish);
}//erase版本一：范围清楚元素iterator erase(iterator first, iterator last) {iterator i = copy(last, finish, first);destroy(i, finish);finish = finish - (last - first);return first;
}iterator erase(iterator position) {if (position + 1 != finish) {copy(position + 1, finish, position);--finish;destroy(finish);return position;}
}void clear() { erase(begin(), end()) };
template<class T, class Alloc>
void vector<T, Alloc>::insert(iterator position, size_type n, const T& x) {if (n != 0) {if (size_type(end_of_storage - finish) > n) {//备用空间大于插入的元素数量T x_copy = x;//以下计算插入点之后的现有元素个数const size_type elems_after = finish - position;iterator old_finish = finish;if (elems_after > n) {//插入点之后的元素个数大于要插入的元素个数uninitialiazed_copy(finish - n, finish, finish);finish += n; //将vetor的尾端标记后移copy_backward(position, old_finish - n, old_finish);fill(position, old_finish, x_copy); //从插入点之后开始插入新值}else {//插入点之后的元素个数小于要插入的元素个数uninitaliazed_fill_n(finish, n - elems_after, finish);finish += n - elems_after;uninitialiazed_copy(position, old_finish, finish);finish += elems_after;fill(position, old_finish, x_copy);}else {//备用空间小于要插入元素的个数//首先决定新长度，原长度的两倍，或者老长度+新的元素个数const size_type old_size = size();const size_type len = old_size + max(old_size, n);//以下配置的新空间iterator new_start = data_allocator::allocate(len);iterator new_finish = new_start;_STL_TRY{//拷贝插入点之前的元素new_finish = uninitialized_copy(static_assert, position, new_start);//把新增元素（初值皆为n）传入新空间new_finish = uninitialized_fill_n;//拷贝插入点之后的元素new_finish = uninitialized_copy(position, finish, new_finish);//有利于理解上面的insert_aux函数}#ifdef _STL_USE_EXCEPTIONScatch () {//如果有异常发生destroy(new_start, new_finish);data_allocator::deallocate(new_start, len);throw;}
#endif /* _STL_USE_EXCEPTION*///析构并释放原vectordestroy(begin(), end());deallocate();//调整迭代器指向新的vectorstart = new_start;finish = new_finish;end_of_storage = new_start + len;}}}
}

list-链表

list设计

每个元素都是放在一块内存中，它的内存空间可以是不连续的，通过指针来进行数据的访问

在哪里添加删除元素都很高，不需要移动内存，当然也不需要对每个元素都进行构造和析构，所以通常用来做随机插入和删除操作的容器。

list属于双向链表其节点和list本身是分开设计的：

template<class T, class Alloc = alloc>
class list {
protected:typedef listnode <T> listnode;
public:typedef listnode link_type;typedef listiterator<T, T&, T> iterator;
protected:link_type node;
};

学习到了一个分析方法，拿到这样一个类，先看它的数据比如上面的link_type node，然后我们再看它的前缀，link_type，去上面在link_type，找到typedef listnode link_type；按这个方法继续找到上面的type listnode <T> listnode;我们发现list_node 是下面的类，我们一层层的寻找，就能看懂。

template<class T>
struct _listnode {typedef void voidpointer;void_pointer prev;void_pointer next;T data;
};

list是一个环状的双向链表，同时它也满足STL对于“前闭后开”的原则，即在链表尾端可以加上空白节点。

list的迭代器的设计：

迭代器是泛化的指针所以里面重载了->, --, ++, * () ,等运算符，同时迭代器是算法与容器之间的桥梁，算法需要了解容器的方方面面，于是就诞生了5种关联类型，（这5种类型是必备的，可能还需要其他类型）我们知道算法传入的是迭代器或者指针，算法根据传入的迭代器或者指针推断出算法所想要了解的容器里的5种关联类型的相关信息。由于光传入指针，算法推断不出来想要的信息，所以我们需要一个中间商（萃取器）也及时我们所说的iterator traitis类，对于一般的迭代器，它直接提供迭代器里的关联类型值，而对于指针和常量指针，它采用的类模板偏特化，从而提供其所需要的关联类型的值。

//针对一般的迭代器类型，直接取迭代器内定义的关联类型
template<class I>
struct iterator_traits {typedef typename I::iteratorcategory iteratorcategory;typedef typename I::valuetype valuetype;typedef typename I::differencetype differencetype;typedef typename I::pointer pointer;typedef typename I::reference reference;
};//针对指针类型进行特化，指定关联类型的值
template<class T>
struct iteratortraits<T> {typedef randomaccessiteratortag iteratorcategory;typedef T value_type;typedef ptrdifft differencetype;typedef T* pointer;typedef T& reference;
};//针对指针常量类型进行特化，指定关联类型的值
template<class T>
struct iteratortraits<const T> {typedef randomaccessiteratortag iteratorcategory;typedef T valuetype; //valuetype被用于创建变量，为灵活起见，取T而非const T作为value_typetypedef ptedifft differencetype;typedef const T* pointer;typedef const T& reference;
};

vector 和 list 的区别

1. vector底层实现是数组；list是双向链表

2. vector是顺序内存，支持随机访问，list不行

3. vector在中间节点进行插入删除会导致内存拷贝，list不会

4. vector一次性分配好内存，不够时才进行翻倍扩容；list每次插入新节点都会进行内存申请

5. vector随机访问性能好，插入删除性能差；list随机访问性能差，插入删除性能好

deque-双端数组

支持快速随机访问，由于deque需要处理内部跳转，因此速度上没有vector快。

1. deuqe概述

deque是一个是一个双端开口的连续线性空间，其内部为分段连续的空间组成，随时可以增加一段新的空间并链接。

注意：

由于deque的迭代器比vector要复杂，影响了各个运算层面，所以非必要尽量使用vector；为了提供效率，在对deque进行排序操作的时候，我们可以先把deque复制到vector中再进行排序最后再复制回deque

2. deque中控器

deque是由一段一段的连续空间构成。一旦有必要在其头端或者尾端增加新的空间，便配置一段定量连续空间，串接在整个deque的头端或者尾端

好处：

避免“vector的重新配置，复制，释放”的轮回，维护链整体连续的假象，并提供随机访问接口；

坏处：

其迭代器变得很复杂

deque采用一块map作为主控，其中的每个元素都是指针，指向另一片连续线性空间，称之为缓存区，这个区才是存储数据的。

template<class T, class Alloc = alloc, size_t Bufsize = 0>
class deque {public:typedef T value_type;typedef value_type pointer*;typedef size_t size_type;//...public:typedef _deque_iterator<T, T&, T*, Bufzie> iterator;protected:typedef pointer* map_pointer;protected:iterator start;iterator finish;map_pointer map; //指向mapsize_type map_size; //map内可容纳多少指针
};//map其实是一个T**

deque迭代器：

//迭代器
//迭代器的关键⾏为，其中要注意的是⼀旦遇到缓冲区边缘，可能需要跳⼀个缓存区
void set_node(map_pointer new_node) {node = new_node;first = *new_node;last = first + difference_type(buffer_size());
}
//接下来᯿重载运算⼦是_deque_iterator<>成功运作的关键
reference operator*() const { return *cur; }pointer operator->() const { return &(operator*()); }difference_type operator-(const self& x) const {return difference_type(buffer_szie()) * (node - x.node - 1) + (cur - first) + (x.last - x.cur);
}
self& operator++() {++cur;if (cur == last) {set_node(node + 1);cur = first;}return *this;
}
self operator++(int) {self temp = *this;++* this;return temp;
}
self& operator--() {if (cur == first) {set_node(node - 1);cur = last;}--cur;return *this;
}
self operator-(int) {self temp = *this;--* this;return temp;
}
//以下实现随机存取，迭代器可以直接跳跃n个距离
self& operator+=(difference_type n) {difference_type offest = n + (cur - first);if (offest > 0 && offest < difference_type(buffer_size()))cur += n;else {offest > 0 ? offest / fifference_type(buffer_size()) : -difference_type((-offest - 1) / buffer_size()) - 1;set_node(node + node_offest);cur = first + (offest - node_offest * difference_type(buffer_size()));}return *this;
}
self operator+(differnece_type n) {self tmp = *this;return tmp += n;
}
self operator-=() { return *this += -n; }
self operator-(difference_type n) {self temp = *this;return *this -= n;
}
rference operator[](difference_type n) {return *(*this + n);
}
bool operator==(const self& x) const { return cur == x.cur; }
bool operator!=(const self& x) const { return !(*this == x); }
bool operatoe < (const self& x) const {return (node == x.node) ? (cur < x.cur) : (node - x.node);
}

deque拥有两个数据成员

start与finish迭代器，分别由deque：begin()与deque：end()传回

//迭代器的关键⾏为，其中要注意的是⼀旦遇到缓冲区边缘，可能需要跳⼀个缓存区
void set_node(map_pointer new_node) {node = new_node;first = *new_node;last = first + difference_type(buffer_size());
}
//接下来重᯿载运算⼦是_deque_iterator<>成功运作的关键
reference operator*() const { return *cur; }
pointer operator->() const { return &(operator*()); }
difference_type operator—(const self& x) const {return difference_type(buffer_szie()) * (node - x.node - 1) + (cur - first) + (x.last - x.cur);
}
self& operator++() {++cur;if (cur == last) {set_node(node + 1);cur = first;}return *this;
}
self operator++(int) {self temp = *this;++* this;return temp;
}
self& operator--() {if (cur == first) {set_node(node - 1);cur = last;}--cur;return *this;
}
self operator-(int) {self temp = *this;--* this;return temp;
}
//以下实现随机存取，迭代器可以直接跳跃n个距离
self& operator+=(difference_type n) {difference_type offest = n + (cur - first);if (offest > 0 && offest < difference_type(buffer_size()))cur += n;else {offest > 0 ? offest / fifference_type(buffer_size()) : -difference_type((-offest - 1) / buffer_size()) - 1;set_node(node + node_offest);cur = first + (offest - node_offest * difference_type(buffer_size()));}return *this;
}
self operator+(differnece_type n) {self tmp = *this;return tmp += n;
}
self operator-=() { return *this += -n; }
self operator-(difference_type n) {self temp = *this;return *this -= n;
}
rference operator[](difference_type n) {return *(*this + n);
}
bool operator==(const self& x) const { return cur == x.cur; }
bool operator!=(const self& x) const { return !(*this == x); }
bool operatoe < (const self& x) const {return (node == x.node) ? (cur < x.cur) : (node - x.node);
}

deque数据结构：

deque除了维护一个map指针以外，还维护了start与finish迭代器分别指向第一缓冲区的第一个元素，和最后一个缓冲区的最后一个元素的下一个元素，同时它还必须记住当前map的大小。具体结构和源代码见上。

deque的构造与管理

//deque首先自行定义了两个空间配置器
typedef simple_alloc <value_type, Alloc> data_allocator;
typedef simple_alloc <pointer, Alloc> map_allocator;

deque中有一个构造函数用于构造deque结构并赋初值

deque(int n, const value_type& value) : start(), finish(), map(0), map_size(0) {fill_initialize(n, value);//这个函数就是⽤来构建deque结构，并设⽴初值
}
template<class T, class Alloc, size_t BufSize)void deque<T, Alloc, BufSize>::fill_initialize(size_type n, const value_type& value) {creat_map_and_node(n);//安排结构map_pointer cur;_STL_TRY{//为每个缓存区赋值for (cur = start.node; cur < finish.node; ++cur)uninitalized_ fill(*cur, *cur + buffer_size(), value);//设置最后⼀个节点有⼀点不同uninitalized_fill(finish.first, finish.cur, value);}catch () {// ...}
}
template<class T, class Alloc, size_t Bufsize>
void deque<T, alloc, Bufsize>::creat_map_and_node(size_type num_elements) {//需要节点数=元素个数/每个缓存区的可容纳元素个数+1size_type num_nodes = num_elements / Buf_size() + 1;map_size = max(initial_map_size(), num_nodes + 2);//前后预留2个供扩充//创建⼀个⼤⼩为map_size的mapmap = map_allocator::allocate(map_size);//创建两个指针指向map所拥有的全部节点的最中间区段map_pointer nstart = map + (map_size() - num_nodes) / 2;map_poniter nfinish = nstart + num_nodes - 1;map_pointer cur;_STL_TRY{//为每个节点配置缓存区for (cur = nstart; cur < nfinish; ++cur)+ cur = allocate_node();}catch () {// ...}//最后为deque内的start和finish设定内容start.set_node(nstart);finish.set_node(nfinish);start.cur = start.first;finish.cur = finish.first + num_elements % buffer_szie();
}

接下来就是插入操作的实现。第一，首先判断是否有扩充map的需求，若有就扩充，然后就是在插入函数中，首先判断是否在结尾或开头从而判断是否跳跃节点。

// 由于尾端只剩⼀个可⽤元素空间（finish.cur=finish.last-1），
// 所以我们必须᯿新配置⼀个缓存区，在设置新元素的内容，然后更改迭代器的状态
tempalate<class T, class Alloc, size_t BufSize>
void deque<T, alloc, BufSize>::push_back_aux(const value_type& t) {value_type t_copy = t;reserve_map_at_back();*(finish.node + 1) = allocate_node();_STL_TRY{construct(finish.cur, t_copy);finish.set_node(finish.node + 1);finish.cur = finish.first;}- STL_UNWIND{deallocate_node(*(finish.node + 1));}
}
//push_front也是⼀样的逻辑

stack 和 queue

概述：栈与队列被称之为deque的配接器，其底层实现是以deque为底部架构。通过deque执行具体操作。

源码

template<class T, class Sequence = deque <T>>class stack { //_STL_NULLL_TMPL_ARGS展开为<>friend bool operator ==_STL_NULL_TMPL_ARGS(const stack&, const stack&);friend bool operator<_STL_NULL_TMPL_ARGS(const stack&, const stack&);public:typedef typename Sequence::value_type value_type;typedef typename Sequence::size_type size_type;typedef typename Sequence::reference reference;typedef typename Sequence::const_reference const_refernece;
protected:Sequence c;public:bool empty() const { return c.empty(); }size_type size() const { return c.size(); }reference top() {return c.back();}const_rference top() const { return c.back(); }void push(const value_type& x) { c.push_back(x); }void pop_back() { c.pop_back(); }
};template<class T, class Sequence>
bool operator==(const stack<T, Sequence>& x, const stack<T, Sequence>& y) {return x.c == y.c;
}template<class T, class Sequence>
bool operator<(const stack<T, Sequence>& x, const stack<T, Sequence>& y) {return x.c < y.c;
}
};

heap and priority_queue

heap（堆）：

建立在完全二叉树上，分为两种，大根堆，小根堆，其在STL中做priority_queue的助手，即，以任何顺序将元素堆入容器中，然后取出时一定是从优先权最高的元素开始取，完全二叉树具有这样的性质，适合做priority_queue的底层。

priority_queue：

优先队列，也是配接器。其内的元素不是按照被堆入的序列排序，而是自动取元素的权值排列，缺省情况下利用一个max-heap完成，后者是以vector表现的完全二叉树

template<class T, class Sequence=vector <T>, class Compare = less<typename Sequence::value_type>>
class priority_queue {public:typedef typename Sequence::value_type value_type;typedef typename Sequence::size_type size_type;typedef typename Sequence::reference reference;typedef typename Sequence::const_reference const_refernece;protected:Sequence c;//底层容器Compare comp;//容器⽐较⼤⼩标准public:priority_queue() : c() {}explicit priority_queue(const Compare& x) : c(), comp(x) {}//以下⽤到的make_heap(),push_heap(),pop_heap()都是泛型算法//任何⼀个构造函数都可以⽴即在底层产⽣⼀个heaptemplate<class InputIterator>priority_queue(InputIterator first, InputIterator last const Compare& x): c(first, last), comp(x) {make_heap(c.begin(), c.end(), comp);}template<class InputIterator>priority_queue(InputIterator first, InputIterator last const Compare& x): c(first, last) {make_heap(c.begin(), c.end(), comp);}bool empty() const { return c.empty(); }size_type size() const { return c.size(); }const_reference top() const { return c.front(); }void push(const value_type& x) {_STL_TRy{c.push_back(X);push_heap(c.begin(), c.end(), comp);}_STL_UNWIND{ c.clear() };}void pop() {_STL_TRY{pop_heap(c.begin(), c.end(), comp);c.pop_back();}_STL_UNWEIND{ c.clear() };}
};
// priority_queue⽆迭代器
};

map && set

共同点：

都是C++的关联容器，只是通过它提供的接口对里面的元素进行访问，底层实现都是红黑树。

不同点：

set：用来判断某一个元素是不是在一个组里面。

map：映射，相当于字典，把一个值映射到另一个值，可以创建字典。

优点：

查找某一个数的时间为Olog(n)；遍历时采用iterator，效果不错。

缺点：

每次插入值的时候，都需要调用红黑树，效率有一定影响。

3. 细节

1. 为什么要成倍的扩容而不是一次增加一个固定大小的容器？

采用成倍方式扩容，可以保证常数的时间复杂度，而增加指定大小的容器只能达到O(n)的时间复杂度。

2. 为什么以两倍的方式扩容而不是三倍四倍，或者其他方式呢？

考虑可能产生的堆空间浪费，所以增长倍数不能太大，一般是1.5或2；GCC是2；VS是1.5，k = 2每次扩展的新尺寸必然刚好大于之前分配的总和，之前分配的内存空间不可能被使用，这样对于缓冲并不友好，采用1.5倍的增长方式可以更好实现对内存的重复利用。

C++没有规定扩容因子K，这是由标准库的实现者决定的。

map与unordered_map

map中的元素是一些key-value对，关键字起索引作用，值表示和索引相关的数据。

底层实现

map底层是基于红黑树实现的，因此内部元素排列是有序的。

而unordered_map底层则是基于哈希表实现的，因此元素排列是杂乱无序的。

map

优点：

有序性，这是map结构的最大优点，其元素的有序性在很多应用中都会简化很多的操作。

map的查找、删除、增加等一系列操作时间复杂度稳定，都为O(logn)。

缺点：

查找、删除、增加等操作平均时间复杂度较慢，与n相关。

unordered_map

优点：
查找、删除。添加的速度快，时间复杂度为常数级O(1）。

缺点：

因为unordered_map内部基于哈希表，以(key, value)对的形式存储，因此空间占用率高。

unordered_map的查找、删除、添加的时间复杂度不稳定，平均为O(1)，取决于哈希函数。极端情况下可能为O(n)。

《Effective STL》

1. 慎重选择容器类型

1. 需要在容器任意位置插入元素，就选择序列容器(vector string deque list)
2. 不关心容器中的元素是否是排序的，哈希容器可行
3. 你选择的容器是C++标准的一部分，就排除了哈希容器，slist(单链表)和rope(“重型”的string)
4. 随机访问迭代器：vector，deque，string，rope，双向迭代器：避免使用slist与哈希容器的一个实现
5. 当发生元素的插入和删除，避免移动原来的容器的元素移动很重要，那么避免使用连续内存的容器
6. 需要兼容C，就用vector
7. 元素的查找速度为关键：哈希容器，排序的vector，标准关联容器(按速度排序)
8. 介意引用计数，就要避免string与rope
9. 回滚能力(错了能改)：就要基于节点的容器。if对多个元素的插入操作需要事务语义就list；使用连续内存的容器也可以获得事务语义
10. 基于节点的容器不会使迭代器、指针、引用变为无效
11. 在string上使用swap会使迭代器、指针或引用变为无效
12. 如果序列容器的迭代器是随机访问，只要没有删除操作发发生，且插入操作只在末尾，则指向数据的引用和指针不会失效 -deque

2. 不要试图编写独立于容器的代码

试图编写对序列容器和关联容器都适用的代码。

3. 确保容器中的对象拷贝正确且高效

1. 存入容器的是你的对象的拷贝
2. 剥离问题：向基类对象的容器添加派生类对象会导致，派生类对象所特有的信息被抹去。智能指针是解决这个问题的好办法。

4. 调用empty而不是检查size()是否为0

empty()对所有的标准容器都是常数时间操作，而size()对于list耗费的是线性时间。

5. 区间成员函数优先于之对应的单元素成员函数

好处：效率高易于理解，更能表达意图

区间创建、删除、赋值(assign)、插入可以用到区间成员函数

6. 当心C++编译器的烦人的分析机制-尽可能的解释为函数声明

/*三种同样形式的声明*/
int f(double d);
int f(double (d));
int f(double);/*g是⼀个函数，该函数的参数是⼀个指向不带任何参数的函数的指针*/
int g(double (* pf) ());
int g(double pf ());
int g(double ());list <int>data(istreamiterator<int>(datafile),istreamiterator<int>());
// 由上⾯分析可知，这是⼀个函数声明，跟我们想要做的事，⼤相径庭
// 第⼀个参数的名称是datafile ,其括号可省略，类型是istream_iterator<int>
// 第⼆个参数是⼀个函数指针，返回⼀个istream_iterator<int>

class Weight{...};
Weight w();

这是我们开始学习类的时候容易犯下的错误，我们想声明一个Weight函数，先进行默认初始化，编译器缺却我们了一个函数声明。 该函数不带任何参数，并返回一个Weight。

解决方法1：给函数参数加上括号

list<int>data((istreamiterator<int>(datafile), istreamiterator<int>());

解决方法2：避免是使用匿名的istream_iterator迭代器对象，而是给这些迭代器一个名称更好。

ifstream datafile("ints.dat");
istream_iterator<int> dataBegin(datafile);
istream_iteraotr<int> dataEnd;
list<int>data(dataBegin, dataEnd);

7.容器包含指针

如果在容器中包含了通过new操作创建的对象的指针，切记在容器对象调用析构函数之前将指针delete掉

解决方法：

最简单的方法用智能指针代替指针容器，这里的智能指针通常是被引用计数的指针

void dosomething() {typedef boost::shardptr <Weight> SPW; //令SPW=shardptr<Weight>vector <SPW> vwp;for (int i = 0; i < SOMEMAGICNUMBER; ++i) {vwp.push_back(SPW(new Weight))//这⾥不会发⽣内存泄露，即使前⾯抛出异常。...}
}

8. 切勿创建包含auto_ptr的容器

无论是被拷贝还是被复制，源对象都将失去对其资源的所有权。

而STL容器又是需要元素具有拷贝可赋值的属性的。

9. 当你复制一个auto_ptr时

它所指的对象的所有权被移交到复制的对象，而他自身被设置为NULL

10. 慎重选择删除元素的方法

10.1 要删除容器中有特定值的所有对象

如果容器是vector、string或deque，则使用erase-remove

如果是list 则使用list::remove

如果容器是一个关联容器，则使用它的erase成员函数

10.2 要在循环内部做某些（除了删除对象的操作之外）操作

如果容器是一个标准序列容器，则写一个循环来遍历容器中的元素，记住每次调用erase时，要用它的返回值更新迭代器。

如果是关联容器，写一个循环来遍历容器中的元素，记住当把迭代器传给erase时，要对他进行后缀递增。

for(specalcontainer<int>::iterator i=c.begin();i!=c.end()) {if(badvalue(*i)){logFile<<"..."<<*i<<endl;i=c.erase(i);//对于vector，string，deque删除的⼀个元素不仅会导致这个元素的迭代器失效，同时会导致所有 的迭代器失效，所以必须更新迭代器。} else {++i;}
}

要删除容器中满足判别式的所有对象

1. 如果容器是vector、string或deque，则使用erase-remove_if
2. 如果是list，则使用list::remove_if
3. 如果是关联容器，则使用removecopyif和swap（把我们需要的值复制到新容器，然后交换容器），或者写一个循环来编译容器中的元素，记住当把迭代器传给erase时，要对他进行后缀递增

container<int>c;...
for(container<int>::iterator i=c.begin();i!=c.end();) {if(badvalue(*i)) c.erase(i++);//当该元素被删除的时候，该元素所有的迭代器都会失效，所以我们使⽤i++else ++i;
}

11. 了解分配子的约定与概念

分配子最初是作为内存模型的抽象，后来为了有利于开发作为对象形式的内存管理器，STL内存分配子负责分配和释放内存

1. 首先分配子能够为它所定义的内存模型中的指针和引用提供类型的定义

分别为allocator<T>::pointer与allocator<T>::reference，用户定义的分配子也应该提供这些类型定义，创建这种具有引用行为特点的对象是使用代理对象的一个例子，而代理对象会导致很多问题。

2. 库实现者可以忽略类型定义而直接使用指针和引用

允许每个库实现者假定每个分配子的指针类型等同于T*,引用为T&

3. STL实现者可以假定所有属于同一类型的分配子都是等价的

4. 大多数标准容器从来没有单独使用过对应的分配子

例如list，当我们添加一个节点的时候我们并不是需要T的内存，而是需要包含T的listNode的内存

所以说list从未需要allocator做任何内存分配，该list的分配子不能够提供list所需的分配内存的功能

所以它会利用分配子提供的一个模板，根据list中T来决定listNode的分配子类型为：Alloactor::rebind::other。这样就得到listNode的分配子，就可以为list分配内存

new与allocator在分配内存的时候，他们的接口不同

void operator new(sizet bytes);
pointer allocator<T>::allocator(sizetyoe numberjiects);
// pointer是个类型定义总是T
// 两者都带参数说名要分配多少内存，但是new 是指明⼀定的字节
// ⽽allocator ，它指明的内存中要容纳多少个T对象
// new返回的是⼀个void，⽽allocator<T>::allocate返回的是⼀个T
// 但是返回的指针并未指向T对象
// 因为T为被构造
// STL会期望allocator<T>::allocate的调⽤者最终在返回的内存中创建⼀个或者多个T对象

12.编写自定义分配子需要什么？

你的分配子是个模板，T代表为它分配对象的类型

提供模板类型定义，分别为allocator::pointer与allocator::reference

通常，分配子不应该有非静态对象

new返回的是一个void，而allocator::allocate返回的是一个T，但是返回的指针并未指向T对象，因为T为被构造，STL会期望allocator::allocate的调用者最终在返回的内存中创建一个或者多个T对象

一定要提供rebind模板

13. 理解分配子的用法

把STL容器中的内容放在共享内存中

把STL容器中的内容放到不同的堆中

14. 切勿对STL容器的线程安全性有不切实际的依赖

STL自身对多线程的支持非常有限

在需要修改STL容器或者调用STL算法时需要自己加锁

为了实现异常安全，最好不要手动加锁解锁，多使用RAII

15. 当你在动态分配数组的时候，请使用vector和string

16. 使用reserve来避免不必要的重新分配

STL容器会自动增长以便容纳下其中的数据，只要没有超出他们的限制

vector与string的增长实现过程：

分配一块大小为旧内存两倍的新内存，把容器中所有的元素复制到新内存中，析构旧内存的对象，释放旧内存。

reserve函数能够把你重新分配内存的次数减到最小，从而避免重新分配和指针、迭代器、引用失效带来的开销，所有应该尽早的使用reserve，最好是容器在被刚刚构造出来的时候就使用

4个易混函数(只有vector与string提供所有这四个函数)

1. size()：告诉你容器中有多少个元素
2. capacity()：告诉你该容器利用已分配的内存能够容纳多少个元素，这是容器能够容纳元素的总数
3. resize(Cotainer::size_type n)：强迫容器改变到包含n个元素的状态，如果size返回的数<n，则容器尾部的元素就会被析构，如果>n，则默认构造新的元素添加到容器的末尾，如果n要比当前的容器容量大，那么就会在添加元素之前，重新分配内存
4. reserve(Container::size_type n)，强迫容器改变容量变为至少n，前提是不比当前的容量小，这会导致重新分配。

有两种方式避免不必要的内存分配

1. 你提前已经知道要用多少的元素，此时就可以使用reserve。
2. 先预留足够大的空间，然后再去除多余的容量(如何去除，参照swap技巧)

17. string实现的多样性

1. string的值可能会被引用计数
2. string对象的大小可能是char*的大小的1~7倍
3. 创建一个新的字符串可能会发生0,1,2次的动态分配内存
4. string也可能共享其容量，大小信息
5. string可能支持针对单个对象的分配子
6. 不同的实现对字符内存的最小分配单位有不同的策略

18. 了解如何把vector和string数据传给旧的API

if(!v.empty())
do something(&v[0],v.size());
or dosomething(v.c_str());

如何用自C API的元素初始化一个vector

sizet fillArray(doublepArray,size_t arraySize);
vector< double >vd(maxnumbers);
vd.resize(fillArray(&v[0],vd.size()));
sizet fillString(charpArray,size_t arraySize);
vector< char >vc(maxnumbers);
size_t charWritten=fillString(&v[0],vd.size(0))
string s(vc.begin(),v.end()+charWrittrn)

19. 使用“swap技巧”删除多余的容量

vector<C> cs.swap(cs);
string s;
string (s).swap(s);

swap还可以删除一个容器

vector< C>().swap(cs);
string s;
string().swap(s);

20. swap的时候发生了什么

在swap的时候，不仅两个容器的元素被交换了，他们的迭代器指针和引用依然有效(string除外)，只是他们的元素已经在另一个容器里。

21. 避免使用vect<bool>，用deque<bool>和bitset代替它

对于vector来说：

第一，它不是一个STL容器。

第二，它不容纳bool。除此以外，就没有什么要反对的。

22. 理解等价与相等

相等基于operator==，一旦x==y则返回真，则x与y相等

等价关系是在已经排好序的区间中对象值的相对顺序，每一个值都不在另一个值的前面。

!=(x<y)&&!=(y<x)。每个标注关联容器的比较函数是用户自定义的判别式，每个标准关联容器都是通过key_comp成员函数使序列判别式可被外部使用

23. 熟悉非标准散列容器

1. hashmap
2. hashset
3. hashmultimap
4. hashmultiset

24. 为包含指针的关联容器指定比较类型，而不是比较函数，最好是准备一个模板

struct Dfl {template<typename ptrtype>bool operator()(ptrtype pT1, ptrtype pT2) const {return pT1 < pT2;}
}

25. 切勿直接修改set或multiset中的键

set/multiset的值不是const，map/multimap的键是const

如何修改元素：

1. 找到想要修改的元素
2. 为将要修改的元素做一份拷贝。在map/multimap的情况下，不要把该拷贝的第一部分声明为const
3. 修改拷贝
4. 把该元素从容器中删除，一般用erase
5. 把新值插入容器

26.考虑用排序的vector替代关联容器

当程序使用数据结构的方法是：设置阶段、查找阶段、重组阶段，使用排序的vector容器可能比使用关联容器的效率要更好一点(当在使用数据结构的时候，查找操作不与删除添加操作混在一起的时候考虑vector)

好处：消耗更少的内存，运行更快一些

注意：

当你使用vector来模仿map<const k, v>时，存储在vector中的是pair<k,v>，而不是pair<const k, v>；需要自己写3个自定义比较函数（用于排序的比较函数，用于查找的比较函数）

typedef pair<string, int> Data;
class Datacompare {
public:bool operator()(const Data &lhs, const Data &rhs) const {return keyless(lhs.first, rhs.first)}//⽤于排序的⽐较函数bool operator()(const Data &lhs, const Data::first_type &k) const {return keyless(lhs.first, k)}//⽤于查找的⽐较函数bool operator()(const Data::first_type &k, const Data &rhs) const {return keyless(k, rhs.first)}//⽤于查找的⽐较函数private:bool keyless(const Data::firsttype &k1, const Data::firsttype &k2) const {return k1 < k2;}//为了保证operator（）的⼀致性
}

27. 更新一个已有的映射表元素

如果要更新一个已有的映射表元素，则应该选择operator[]，如果是添加元素，那么最好还是选择insert。

28.  iterator

iterator优先于constiterator,reserveiterator,constreserveiterator。

29.使用distance和advance将容器的const_iterator转换为iterator

typedef deque<int> IntDeque;
typedef IntDeque::iterator Iter;
typedef IntDeque::const_iterator ConstIter;
IntDeque d;
ConstIter ci;
...
Iter i(d.begin());
advance(i, distance<ConstIter>(i, ci));

30. 正确理解由reserve_iteratorr的base（）成员函数所产生的iterator的用法

1. 对于插入操作，ri和ri.base()是等价的

2. 对于删除操作，ri和ri.base()是不等价的

3. v.erase((++ri).base())；

31. istreambuf_iterator

对于逐个字符的输入请考虑使用istreambuf_iterator

1. ifstream inputFile("sdsdsa.txt");
2. string filedata((istreambufiterator<char>(inputFile),istreambufiterator<char>());

32. 如果使用的算法需要指定一个目标空间

如果所使用的算法需要指定一个目标空间，确保目标区间足够大或确保它会随着算法的运行而增大。

要在算法执行过程中增大目标区间，请使用插入型迭代器：backinserter，frontinserteer，ostream_iterator【插入器，它接收一个容器，生产一个迭代器，能实现向给定容器添加元素】

33. 了解各种与排序相关的选择

1. 如果需要对vector，string，deque或者数组中的元素进行一次完全排序，那么可以使用sort和stable_sort
2. 如果有一个vector，string，deque或者数组，并且只需要对等价性最前面的n个元素进行排序，那就可以使用partial_sort
3. 如果有一个vector，string，deque或者数组，并且只需要找到第n个位置上的元素，或者，并且只需要找到性价比最前面的n个元素，并不需要排序，那么nth_element就行
4. 如果需要将一个标准容器中的元素按照是否满足某个特定的区间分开，那么就选择partition、stable_partition
5. 如果你的数据在list中，那么你可以选择内置的sort和stablesort算法。同时如果你需要获得partitionsort或nth_element算法的效果可以采用一些间接的方法
6. 对于排序算法的选择应该基于功能选择，而不是性能

34. 如果要删除元素，需要在remove后面使用erase

1. remove并没有删除容器中的元素：因为remove它不是成员函数（list除外），所以它不知道要删除哪个容器的元素。它会把不被删除的元素排在前面，要删除的元素排在后面，所以它返回的一个指针指向最后一个不被删除的元素的后面的那个元素
2. 我们就要使用在remove后面使用erase函数。v.erase(remove(v.begin(), v,end(),element)),w.end()
3. 还有两类函数也是这种情况：remove_if,unique;
4. 但是list函数把remove与erase结合在一起生产的list::remove比原先的remove-erase的效率高。unique和remove_if同理

35.对包含指针的容器使用remove这一类算法一定要小心

原因：由于remove是将那些要被删除的指针被那些不需要被删除的指针覆盖了，所有没有指针指向那些被删除指针所指向的内存和资源，所有资源就泄漏了

做法：使用智能指针或者在使用remove-erase之前手动删除指针并置空

36. 了解那些算法要求使用排序的区间作为参数

template<typename InputIterator
typename OutputIterator
typename predicate>
OutputIterator copy_if(InputIterator begin, InputIterator end, OutputIterator
destbegin, predicate p) {while (begin != end) {if (p(*begin))destbegin++ = begin;++begin;}return destbegin;}

37. 使用accumulate或者for_each进行区间统计

1. accumulate(innerproducet、adjacentdifference、partial_sum)位于<numeric>中
2. for_each（区间，函数对象）
3. accumulate（begin，end，初始值）；accumulate（初始值，统计函数）

38. 遵循按值传递的原则来设计函数子类

如果做能够允许函数对象可以很大，或者保留多态，又可以与STL所采用的按值传递函数指针的习惯保持一致：将数据和虚函数从函数子类中分离出来，放到一个新的类中；然后在函数子类中包含一个指针，指向这一个新类的对象。

template<typename T>
class Bs : public:unary_function<T, void> {
private:Weight w;int x;
...
virtual ~Bs();
virtual void operator()(const T &val) const;
friend class B<T>
}template<typename T>
class B : public:unary_function<T, void> {
private:BS <T> *p;
public:virtual void operator()(const T &val) const {p->operator()(val);}
}

41. 确保判别式是“纯函数”

对于用作判别式的函数对象，使用时它会被拷贝存起来，然后再使用这个拷贝。这一特性要求判别式函数必须为纯函数。

42. 使你的函数子类可配接

为什么：

1. 可配接的函数对象能够与其他STL组件默契的协同工作
2. 能够让你的函数子类拥有必要的类型定义
3. 四个标准的函数配接器（not1，not2，bind1st，bind2nd）要求这些类型定义

为什么not1等要这些定义：能够辅助他们完成一些功能

如何使函数可配接：让函数子从特定的基类继承：unaryfunction与binaryfunction

注意：unaryfunction<operator所带参数类型，返回类型>binaryfunction<operator 1, operator 2,返回类型>

43. 理解ptrfun && memfun && memfunref

在函数和函数对象被调用的时候，总是使用非成员函数形式发f()，而当你使用成员函数的形式时x.f(), p->f();将不通过编译，所以使用上面的那些就能调整成员函数，使其能够以成员函数的形式调用函数和函数对象。

每次将成员函数传给STL组件的时候，就要使用他们。

44. 确保less<T>与operator<的语义相同

一般情况下我们使用less<T>都是默认通过operator<来排序。

如果你想要实现不同的比较，最好是重新写一个类，而不是修改less

45. 算法的调用优先于手写的循环

1. 效率高
2. 手写的循环容易出错
3. 算法的代码更简单明了，易于维护

46. 容器的成员函数优先于同名函数

1. 成员函数往往速度快
2. 成员函数通常与容器结合更紧密，是算法所不能比的。

47. 正确区分以下关键字：

count、find、binarysearch、lowerbound、upperbound、equalrange

48. 使用函数对象作为STL算法的参数

49.避免产生“直写行”的代码

50. 包含正确的头文件

1. 几乎所有的STL容器都被声明在与之同名的头文件中
2. 除了四个STL算法外，其他所有算法都被声明在<algorithm>中；accumulate(innerproducet、adjacentdifference、partial_sum)位于<numeric>中
3. 特殊类型的迭代器（istreamiterator,istreambufiterator）被声明在<iterator>
4. 标注的函数子（less< T >）和函数配接器< not1,bind2nd >b被声明在头⽂件< funtional >中

51. 学会分析于STL相关的编译器的诊断信息

52. 熟悉于STL相关的web站点

1. SGI STL
2. STLport
3. Boost

《Effective C++》

条款16：成对使用new和delete。

new创建，delete删除

new[]创建，[]delete删除

条款30：了解inline的里里外外

• inline函数，对函数的每一个调用都用函数本体替代，调用不承受额外开销，编译器对其执行语境相关最优化。增加目标码大小，额外的换页行为，降低缓存击中率，效率损失。
• 对虚函数进行inline无意义，虚函数是运行时确定，inline是在编译期替换。
• 编译器一般不对“通过函数指针进行调用”提供inline，是否inline取决于调用的方式

条款34：区分接口继承和实现继承

public继承由函数接口继承+函数实现继承组成

纯虚函数两个特性：1. 它们必须被任何继承了它们的具象class重新声明；2. 在抽象class中通常没有定义

声明一个纯虚函数的目的是为了让派生类只继承函数接口。

只提供接口，派生类根据自身去实现。

声明非纯虚函数的目的是让派生类继承函数的接口和缺省实现。

必须支持一个虚函数，如果不想重新写一个(override)，可以使基类提供的缺省版本。

声明非虚函数的目的是令派生类继承函数接口和一份强制性实现。

任何派生类都不应该尝试修改此函数，non-virtual函数代表不变性>特异性，不应该在派生类被重新定义。

条款35：考虑virtual函数以外的选择

1. non-virtual interface， 以public non-virtual成员函数包裹较低访问性(private/protected)的虚函数。
2. virtual函数替换成“函数指针成员变量”。
3. tr1::function成员替换virtual。

条款36：绝不重新定义继承而来的非虚函数

public继承说明，每个派生类对象都是基类对象，非虚函数(静态绑定)一定会继承基类的接口和实现。

重新定义则设计出现矛盾。派生类重新定义使得出现特化，这样就不一定适用于基类，那么就不应该public。

条款37：绝不重新定义继承而来的缺省参数值

因为缺省参数值是静态绑定，虚函数是动态绑定。

静态类型是程序中被声明时采用的类型，动态类型是目前所指对象的类型。

条款39：明智而谨慎的使用private继承

如果派生类需要访问基类保护的成员，或需要重新定义继承而来的虚函数，采用private继承。

条款40：明智而谨慎的使用多重继承

多继承中实现派生类中只有一份数据，虚继承。

虚继承会增加大小，速度，初始化等成本。

最好不要使用虚继承或虚基类中不放置数据。

条款44：将与参数无关的代码抽离template

template生成多个class和多个函数，所以任何template代码都不应该与某个造成膨胀的template参数产生依赖关系。

因非类型模板参数(non-type template parameters)而造成代码膨胀，往往可消除，做法是以函数参数或class成员变量替换template参数。

因类型参数(type parameters)而造成的代码膨胀，往往可降低，做法是让带有相同二进制表述的具现类型共享实现代码。

条款45：运用成员函数模板接受所有兼容类型

如果你声明member template用于“泛化copy构造”或“泛化assignment操作”，还是需要声明正常的copy构造函数和copy assignment操作符。

条款46：需要类型转换时请以模板定义非成员函数

当我们编写一个class template，而它所提供之“与此template相关的”函数支持“所有参数之隐式类型转换”时，请将那些参数定义为“class template内部的friend函数”。

条款47：请使用traits classes表现类型信息

Traits classes使得“类型相关信息”在编译期可用。

它们以templates和“template特化”完成实现。整合重载技术后，traits classes有可能在编译期对类型执行if...else测试

条款48：认识template元编程

template metaprogramming（TMP,模板元编程）可将工作由运行期移往编译期，因而得以实现早期错误侦测和更好的执行效率。

TMP可被用来生成“基于政策选择组合”(based on combinations of policy choices)的客户定制代码

也可用来避免生成对某些特殊类型并不合适的代码。

泛型编程

C++模板全特化和偏特化

模板分为类模板和函数模板，特化分为特例化（全特化）和部分特例化（偏特化）。

对模板特例化是因为对特定类型，可以利用某些特定知识提高效率，而不是使用通用模板。

对函数模板：

1. 模板和特例化版本应该声明在同一头文件，所有同名模板的声明应放在前面，接着是特例化版本。
2. 一个模板被称为全特化的条件：1.必须有一个主模板类 2. 模板类型被全部明确化。

模板函数：

template<<typename T1, typename T2>
void funT1 a, T2 b)
{cout<<"模板函数"<<endl; }template<>
void fun<int , char >(int a, char b)
{cout<<"全特化"<<endl;
}

模板函数，只有全特化，偏特化的功能可以通过函数的重载完成。

对类模板：

template<typename T1, typename T2>
class Test
{
public:Test(T1 i,T2 j):a(i),b(j){cout<<"模板类"<<endl;}private:T1 a;T2 b;
};template<>
class Test<int , char> {
public:Test(int i, char j):a(i),b(j){cout<<"全特化"<<endl;}
private:int a;char b;
};template <typename T2>
class Test<char, T2> {
public:Test(char i, T2 j):a(i),b(j){cout<<"偏特化"<<endl;}
private:char a;T2 b; }

对主版本模板类、全特化类、偏特化类的调用优先级从高到低排序：全特化类>偏特化类>主版本模板类。

C++11新特性

1. 类型推导

1. auto

auto可以让编译器在编译器就推导出变量的类型

1. auto的使用必须马上初始化，否则无法推导出类型
2. auto在一行定义多个变量时，各个变量的推导不能产生二义性，否则编译失败
3. auto不能用作函数参数
4. 在类中auto不能用作非静态成员变量
5. auto不能定义数组，可以定义指针
6. auto无法推导出模板参数
7. 在不声明为引用或者指针时，auto会忽略等号右边的引用类型和cv限定
8. 在声明为引用或指针时，auto会保留等号右边的引用和cv属性

2. decltype

decltype则用于推导表达式类型，这里只用于编译器分析表达式的类型，表达式实际不会计算

decltype不会像auto一样忽略引用和cv属性，decltype会保留表达式的引用和cv属性

对于decltype(exp)有：

1. exp是表达式，decltype(exp)和exo类型相同
2. exp是函数调用，decltype(exp)和函数返回值类型相同
3. 其他情况，若exp是左值，decltype(exp)是exp类型的左值引用

auto和decltype的配合使用

template<typename T, typename U>
auto add(T t, U u) -> decltype(t + u) {return t + u;
}

2. 右值引用

左值右值：

左值：可以放在等号左边，可以取地址并有名字

右值：不可以放在i等号左边，不能去地址，没有名字

字符串字面值“abcd”也是左值，不是右值

++i、--i是左值，i++、i--是右值

1. 将亡值

将亡值是指C++新增的和右值引用相关的表达式

将亡值可以理解为即将要销毁的值，通过“盗取”其他变量内存空间方式获取的值，在确保其他变量不再被使用或者即将被销毁时，可以避免内存空间的释放和分配，延长变量值的生命周期，常用来完成移动构造或者移动赋值的特殊任务

2. 左值引用

左值引用就是对左值进行引用的类型，是对象的一个别名

并不拥有所绑定对象的堆存，所以必须立即初始化。对于左值引用，等号右边的值必须可以取地址，如果不能取地址，则会编译失败，或者可以使用const引用形式

3. 右值引用

表达式等号右边的值需要是右值，可以使用std::move函数强制把左值转换为右值。

4. 移动语义

可理解为转移所有权，对于移动语义，类似于转让或者资源窃取的意思，对于那块资源，转为自己所拥有，别人不再拥有也不会再使用。

通过移动构造函数使用移动语义，也就是std::move；移动语义仅针对于那些实现了移动构造函数的类的对象，对于那些基本类型int、float等没有任何优化作用，还是会拷贝，因为它们实现没有对应的移动构造函数

浅拷贝：

a和b的指针指向了同一块内存，就是浅拷贝，只是数据的简单赋值；

深拷贝：

深拷贝就是再拷贝对象时，如果被拷贝对象内部还有指针引用指向其他资源，自己需要重新开辟一块新内存存储资源

5. 完美转发

写一个接受任意实参的函数模板，并转发到其他函数，目标函数会收到与转发函数完全相同的实参，通过std::forward()实现

nullptr

nullptr是用来代替NULL，一般C++会把NULL、0视为同一种东西，这取决于编译器如何定义NULL，有的定义为（(void*)0），有的定义为0

C++不允许直接将void*隐式的转换为其他类型，在进行C++重载时会发生混乱

例如：

void foo(char *);
void foo(int );

如果NULL被定义为（(void*)0），那么当编译char *ch = NULL时，NULL被定义为0

当foo(NULL)时，此时NULL为0，会去调用foo(int)，从而发生混乱

为解决这个问题，从而需要使用NULL时，用nullptr代替：

C++11引入nullptr关键字来区分空指针和0。nulllptr的类型为nullptr_t，能够转换为任何指针或成员指针的类型，也可以进行相等或不等的比较。

范围for循环

基于范围的迭代写法，for（变量：对象）表达式

对string对象的每个字符做一些操作：

string str("some thing");
for(char c:str) cout << c << endl; //对字符串str中的每个字符进行cout操作。

对vector进行遍历：

std::vector<int>arr(5, 100);for(std::vector<int>::iterator i = arr.begin(); i != arr.end(); ++i) {std::cout << *i << std::endl;}//范围for:for(auto &i : arr) {std::cout << i << std::endl; }

列表初始化

C++定义了几种初始化方式，例如对一个int变量x初始化为0：

int x = 0; //method1
int x = {0}; // method2
int x{0}; // method3
int x(0); // method4