STL容器的线程安全性了解多少？

//这样可以吗？
class Widget{

};
vector<Widget> vw;
Widget bestWidget;
//寻找和bestWidget相等的Widget
vector<Widget>::iterator i = find(vw.begin(), vw.end(), bestWidget);

//改进这样写: 这样改变容器类型变得容易多了
class Widget{

};
typedef vector<Widget> WidgetContainer;
typedef WidgetContainer::iterator WCIterator;
WidgetContainer cw;
Widget bestWidget;

WCIterator i = find(cw.begin(), cw.end(), bestWidget);

class Customer{

};
class CustomerList{
    private:
        typedef list<Customer> CustomerContainer;
        typedef CustomerContainer::iterator CCIterator;
        CustomerContainer customers;
    
    public:
        //通过这个接口限制list特殊信息的可见性
};
//一个CustomerList是一个list吗？只用list设计可以吗
//需要快速确定客户列表顶部的20%，使用 nth_element算法，但是该算法需要随机访问迭代器，只适用于 array、vector、deque 这 3 个容器，
// 不能兼容list，这是list可能需要用vector或deque来实现了，此时你要更改的化，需要检查每个CustomerList的成员函数和每个友元，但如果你做好了封装，将影响很小

 \* @brief 

 \* nth_element

 //排序规则采用默认的升序排序

void nth_element (RandomAccessIterator first,

                 RandomAccessIterator nth,

                 RandomAccessIterator last);

//排序规则为自定义的 comp 排序规则

void nth_element (RandomAccessIterator first,

                 RandomAccessIterator nth,

                 RandomAccessIterator last,

                 Compare comp);

其中，各个参数的含义如下：

first 和 last：都是随机访问迭代器，[first, last) 用于指定该函数的作用范围（即要处理哪些数据）；

nth：也是随机访问迭代器，其功能是令函数查找“第 nth 大”的元素，并将其移动到 nth 指向的位置；

comp：用于自定义排序规则。

int a[10]={1,5,6,3,9,2,8,7,4,10};
nth_element(a,a+5,a+10);//查找数组第6小的元素 
cout<<"第6小的数是："<<a[5];//第6小的数放在了相应的第6个位置了 

#include<iostream>
#include<vector>
#include<algorithm>//必要头文件 
using namespace std;
struct node{
 int x,y;
// 构造函数 
 node(int x,int y){
  this->x=x;
  this->y=y;
 }
};
bool cmp(node n1,node n2){
 return n1.x<n2.x;
}
int main(){
 vector<node> v;
 node n1(1,3);
 node n2(5,2);
 node n3(3,6);
 node n4(2,6);
 node n5(4,4);
 v.push_back(n1);
 v.push_back(n2);
 v.push_back(n3);
 v.push_back(n4);
 v.push_back(n5);
 nth_element(v.begin(),v.begin()+1,v.end(),cmp);
 cout<<"按x排序，第2小点的数是："<<endl;
 cout<<"x:"<<v[1].x<<' '<<"y:"<<v[1].y;
} 

class Widget{
    public:
        Widget(const Widget&);//拷贝构造函数
        Widget& operator=(const Widget&);//拷贝赋值操作符
};

//切记，由于继承的存在，拷贝会导致分割
//如果你以基类对象建立一个容器，而你试图插入派生类对象，那么当对象（通过基类的拷贝构造函数）拷入容器的时候对象的派生部分会被删除
//分割问题暗示把一个派生类对象插入基类对象的容器几乎总是错的
class SpWidiget:public Widget{

};
vector<Widget> vw;
SpWidiget sw;
vw.push_back(sw);//sw被当作基类对象拷入vw, 当拷贝时它的特殊部分丢失了

//建立指针的容器而不是对象的容器，即建立一个 Widget* 的容器，不是建立一个 Widget的容器
//1，指针拷贝快 2，当指针拷贝时没有分割； 3， 智能指针更是好的选择
vector<Widget*> vw;
vector<shared_ptr<Widget>> vw;

//1，数组
Widget w[maxNumWidgets];//建立一个大小为maxNumWidgets的Widgets数组，默认构造每个元素
//2,需要的时候才增长的vector
vector<Widget> vw;//建立一个0个Widget对象的vector，需要的时候可以扩展
//建立一个足够包含namxNumWidgets个Widget的空vector，但没有构造Widget
vector<Widget> vw;
vw.reserve(maxNumWidgets);

//任意容器c
if(c.size() == 0)
//等价于
if(c.empty())

//list的splice处理
list<int> list1;
list<int> list2;
//把list2中从第一次出现5到最后一次出现10的所有节点移到list1的结尾
list1.splice(list1.end(), list2, 
    find(list2.begin(), list2.end(),5),//1
    find(list2.rbegin(),list2.rend(),10).base());//2

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

int main() {
 list<int> list1 = { 1, 2, 3, 4, 5 };
 list<int> list2 = { 11, 12, 13, 14, 15 };

 list<int>::iterator iter = list1.begin();
 iter++;

 //把list2全部剪贴到list1的iter位置
 list1.splice(iter, list2);
 cout << "list1: ";
 for (auto& num : list1) {
  cout << num << " ";
 }
 cout << endl;

 cout << "list2: ";
 for (auto& num : list2) {
  cout << num << " ";
 }
 cout << endl;

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

 list<int> list3 = { 1, 2, 3, 4, 5 };
 list<int> list4 = { 11, 12, 13, 14, 15 };
 list<int>::iterator iter1 = list4.begin();
 iter1++;

 //把list4中iter1位置处的值剪贴到list3的list3.begin()位置
 list3.splice(list3.begin(), list4, iter1);
 cout << "list3: ";
 for (auto& num : list3) {
  cout << num << " ";
 }
 cout << endl;
 cout << "list4: ";
 for (auto& num : list4) {
  cout << num << " ";
 }
 cout << endl;

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

 list<int> list5 = { 1, 2, 3, 4, 5 };
 list<int> list6 = { 11, 12, 13, 14, 15 };
 list<int>::iterator iter2 = list6.begin();
 list<int>::iterator iter3 = iter2;
 iter3++; iter3++; iter3++;

 //把list6中从iter2到iter3的元素剪贴到list5中的list5.begin()处
 list5.splice(list5.begin(), list6, iter2, iter3);
 cout << "list5: ";
 for (auto& num : list5) {
  cout << num << " ";
 }
 cout << endl;
 cout << "list6: ";
 for (auto& num : list6) {
  cout << num << " ";
 }
 cout << endl;

 return 0;
}

v1.assign(v2.begin() + v2.size()/2, v2.end());
//assign 对所有标准序列容器（vector, string, deque和list）都有效，完全替代一个容器的内容

vector<Widget> v1,v2;
v1.clear();
for (vector<Widget>::const_iterator ci = v2.begin() + v2.size() /2; ci != v2.end(); ++ci)
    v1.push_back(*ci);

v1.clear();
copy(v2.begin() + v2.size()/2, v2.end(), back_inserter(v1));
//copy中也存在一个循环

v1.insert(v1.end(), v2.begin() + v2.size() /2, v2.end());

int data[numValues];
vector<int> v;
v.insert(v.begin(), data, data + numValues);//把data中的int插入v的前部

//显示循环
vector<int>::iterator insertLoc(v.begin());
for(inr i = 0; i < numValues; ++i)
{
    insertLoc = v.insert(insertLoc, data[i]);//每次调用insert会使insertLoc无效
    ++insertLoc;
}

//copy:  插入迭代器 inserter，back_inserter或front_inserter
copy(data, data + numValues, inserter(v, v.begin()));

//1, 区间构造：所有标准容器都提供这种形式的构造函数
container::container(InputIterator begin, InputIterator end);

//2, 区间插入： 所有标准序列容器都提供这种形式的insert
void container::insert(iterator position,//区间插入位置
                InputIterator begin, //插入区间的起点
                InputIterator end);//插入区间的重点

//关联容器使用它们的比较函数来决定元素要放在哪里，所以省略了 position 参数
void container::insert(InputIterator begin, InputIterator end);
//睁大眼睛：当你看到一个循环用 push_front，push_back，insert 一算法 copy的参数是front_inserter或者back_inserter
//你就可以用一个insert的区间函数代替了

//3，区间删除： 每个标准容器都提供一个区间形式的erase，但是序列和关联容器的返回类型不同
//序列容器
iteraor container::erase(iterator begin, iterator end);
//关联容器
void container:erase(iterator begin, iterator end);

//4,区间赋值：所有标准序列容器都提供了区间形式的assign
void container::assign(InputIterator begin, InputIterator end);

/基本说起
//声明一个函数f带有一个double而且返回一个int
int f(double d);
//同上，d的参数左右的括号是多余的，被忽略
int f(double (d)); //有点新鲜
//同上，省略了参数名字
int f(double);

//带函数的说起
//声明一个函数g, 带有一个参数, 那个参数指向一个没有参数, 返回double的函数的指针
int g(double (*pf)());
//同上，pf使用非指针语法
int g(double pf());
//同上, 参数名可以忽略，去掉了pf这个名字
int g(double ());

//注意：参数名左右的括号可以被忽略，但是单独的括号指出存在一个参数列表：声明了存在指向函数的指针的参数

class Widget{

};

Widget w();//他在干什么？
//并没有声明一个 w 的Widget构造函数，而是声明了一个叫做w的没有参数且返回 Widget的函数

std::istringstream str("1 3 5 7 8 9 10");
std::list<int> data(std::istream_iterator<int>(dataFile), std::istream_iterator<int>())
{
   //原本想法是传一对 istream_iterator的list的区间构造函数，把int从文件拷贝到 list中

   //可以编译，但是运行时，什么都不做，因为这并不是声明一个list函数，其实做的是 ？？？
   std::list<int> result;
   //方式一
   result.assign(dataFile, std::istream_iterator<int>());
   
   //方式二
   //copy(dataFile, std::istream_iterator<int>(), inserter(result, result.begin()));  

   for(auto i: result)
   {
        std::cout<<"i: "<<i<<std::endl;
   }

   return result;
}

int main()
{   
    std::istream_iterator<int> (*eos)();
    data(str,eos);//OK的
}

//因此在写一遍
std::list<int> data((std::istream_iterator<int>(dataFile)), std::istream_iterator<int>()); 
/**
 * @brief 
 * 声明一个函数data, 返回类型是 list<int>
 * 1, 第一个参数是 dataFile，类型是 std::istream_iterator<int>, dataFile左右的括号是多余的并且被忽略
 * 2, 第二个参数名字名字，他的类型是 指向一个没有参数而且返回 std::istream_iterator<int>的函数的指针
 * 
 * 几乎任何东西都可以分析成函数声明
 * 
 * @return int 
 */

class C{  
public:  
    C(int x){  
        std::cout << x << std::endl;  
    }  
    C(){  
        std::cout << 10 << std::endl;  
    }  
  
};

//情况2： 两个包装容器，对任意类型得值进行了一层包装
template <typename T> class Bag //包装容器袋子
{
public:
    typedef T value_type;
    T val; //内容
    Bag(T value):val(value){};

};
template <typename T> class Box //包装容器箱子
{
public:
    typedef T value_type;
    T val; //内容
    Box(T value):val(value){};
};
//实现一个函数，从两个容器中取出里面得值，并作为返回值
template <typename C> typename C::value_type unpack(C container)
{
    return container.val;
}

//情况3： 内存泄露
void doSomething()
{
    std::vector<Widget*> vwp;
    for(int i=0; i <10; ++i)
    {
        vwp.push_back(new Widget);//Widget在这里泄露
    }
    //当vwp出了生存阈后，vwp得每个元素都被销毁，但是并不改变从没有把 delete 作用于 new得到得对象这件事情
    //delete是你自己负责得事情，而不是 vector，这是一个特性，于是需要自己定义 delete

    for(std::vector<Widget*>::iterator i = vwp.begin(); i != vwp.end();++i)
    {
        delete *i;
    }
    //但是以上代码也不是异常安全得，如果在指针填充了vwp和你要删除它们之间抛出了一个异常，也会再次资源泄露

    //如何解决以上两个问题呢？
    //1，内存泄露
    //2，异常安全  
}

//情况3-1: 把 delete 转入一个函数对象，STL这样玩
template<typename T>
struct DeleteObject: public std::unary_function<const T*,void>//这样一个继承
{
    void operator()(const T* ptr) const{
        std::cout<<"de: "<<std::endl;
        delete ptr;
    }
};

struct less_than_7 : std::unary_function<int, bool>
{
    bool operator()(int i) const { return i < 7; }
};

 //有了下面得情况 3-1 你可以这样
void DE()
{   
    std::vector<Widget*> vwp;
    std::for_each(vwp.begin(), vwp.end(), DeleteObject<Widget>());
    //这里指定了要删除得对象是Widget* 指针，是冗余得，并且会导致很难追踪到得bug 
}

 //string 缺少析构函数，没有析构函数得类不能公有继承
 //如果你这样写
 class SpString:public std::string{

 };
 //然后你再这样
 void DESP()
 {
    std::deque<SpString*> dssp;
    for_each(dssp.begin(), dssp.end(), DeleteObject<std::string>());
    //行为没有定义，通过没有析构函数得基类指针来删除派生类对象
    //dssp被声明为容纳Spstring*指针，但 for_each循环告诉作者DeleteObject将删除 string*指针，没析构怎么删除
 }

 struct DeleteObject2
 {
    template<typename T>
    void operator()(const T* ptr) const
    {   
        std::cout<<"DeleteObject2: "<<std::endl;
        delete ptr;
    }
 };
 //这样是一个良好得设计
 void DEE()
 {
    std::deque<SpString*> dssp;
    for_each(dssp.begin(), dssp.end(), DeleteObject2());
    //但是如果再 SPString被 new但在调用 for_each之前抛出一个异常，也会发生泄露
    //智能指针来了
 }

 void DEPTR()
 {
    typedef boost::shared_ptr<Widget> SPW;
    std::vector<SPW> vwp;
    for(int i=0; i <10; ++i)
    {
        vwp.push_back(SPW(new Widget));//Widget在这里泄露
    }
 }

int main()
{   
    //条款6
    std::istream_iterator<int> (*eos)();
    data(str,eos);

    //条款7
    //情况1
    std::vector<C> vec;  
    C c1,c2(11);  
    vec.push_back(c1);  
    vec.push_back(c2);  
    std::vector<C>::value_type n1;  
    std::vector<C>::value_type n2(13);  
    vec.push_back(n1);  
    vec.push_back(n2);  
    std::cout << vec.size() << std::endl; 

    //情况2
    Box<int> box(5);
    auto a = unpack(box) ;
    std::cout<<"情况2： "<<a<<std::endl;

    //情况3-1
      std::vector<int> v;
    for (int i = 0; i < 10; ++i) v.push_back(i);
 
    std::cout << std::count_if(v.begin(), v.end(), std::not1(less_than_7()));
 
    //C++11 solution:
    // Cast to std::function<bool (int)> somehow - even with a lambda
    std::cout << std::count_if(v.begin(), v.end(),
        std::not1(std::function<bool (int)>([](int i){ return i < 7; }))
    )<<std::endl;

    DE();

}

 std::auto_ptr<Widget> pw1(new Widget);//pw1指向一个Widget
 std::auto_ptr<Widget> pw2(pw1);//pw2指向pw1的Widget，pw1被设为NULL(Widget的所有权从 pw1转移到pw2)
 pw1 = pw2; //pw1现在再次指向Widget，pw2被设为NULL

 bool widgetAPCompare(const auto_ptr<Widget>& lhs, const auto_ptr<Widget>& rhs)
 {
    return *lhs < *rhs;//假设Widget重载了 operator<
 }
 std::vector<std::auto_ptr<Widget> > widgets;
 sort(widgets.begin(), widgets.end(), widgetAPCompare);//排序这个vector
 //看似合理，但结果却是错的：因为在排序过程中widgets中的一个或多个auto_ptr可能已经被设为NULL

 template<class RandomAccessIterator, class Compare>
 void sort(RandomAccessIterator first, RandomAccessIterator last, Compare comp)
 {
    typedef typename iterator_traits<RandomAccessIterator>::value_type ElementType;
    //涉及iterator_traits<RandomAccessIterator>::value_type时，必须在它前面写上typename，因为它是一个依赖于模板参数类型的名字，在这里是RandomAccessIterator
    RandomAccessIterator i;//让i指向主元
    ElementType pivotValue(*i);//把主元拷贝到一个局部临时变量，做剩下的排序工作，就是拷贝的问题
    /**
     * @brief 
     * 在这里，auto_ptr<Widget> 这个拷贝默默地把被拷贝的auto_ptr设为NULL, 另外当 pivotValue出了生存期，它会自动删除指向的Widget。
     * 这是 sort 调用返回，vecotor的内容以及改变，而且至少一个 Widget 已经被删除了
     */
 }

//1,连续内存容器 vector, deque, string 
//最好的方法是 erase-remove
std::vector<int> c={100,192,1963,12,1963,11,23,12};
c.erase(std::remove(c.begin(), c.end(), 1963), c.end());

//2, list
//list的成员函数 remove更高效
std::list<int> cc = {100,192,1963,12,1963,11,23,12};
cc.remove(1963);

//3, 标准关联容器 set multiset map 或 multimap
//没有 remove 的成员函数，使用 erase
std::set<int> ccc = {100,192,1963,12,1963,11,23,12};
ccc.erase(1963);

//4, 将 去除特定值改成 消除下面判断返回真的每个对象
bool badValue(int x)
{
    return x < 6;
}

//4-1: 序列容器 vector, string deque list
//只要把 remove替换为 remove_if
std::deque<int> ca = {2,3,4,1,2,6,7,8,4,3,7,5,6};
ca.erase(std::remove_if(ca.begin(), ca.end(),badValue), ca.end());//去掉badValue返回真的最佳方法

//4-2： list
std::list<int> caa = {2,3,4,1,2,6,7,8,4,3,7,5,6};
caa.remove_if(badValue);

//4-3: 标准关联容器
//第一种方法：容易编码但是效率低：用 remove_copy_if把我们需要的值拷贝到一个新容器，然后把原容器中的内容和新的交换
std::set<int> caaa = {2,3,4,1,2,6,7,8,4,3,7,5,6};
std::set<int> goodValues;//用于容纳不删除值得临时容器
//从 caaa拷贝不删除得值到 goodValues
std::remove_copy_if(caaa.begin(), caaa.end(), inserter(goodValues,goodValues.end()), badValue);
// //交换caaa和goodValues
caaa.swap(goodValues);
//缺点是它拷贝了所有不删除得元素，开销较大

//第二种方法：直接从原容器删除元素，但是关联容器没有提供类似 remove_if得成员函数，所有必须自己写一个循环来迭代c中得元素
//很快，你写出了如下代码
std::set<int> caaaa = {2,3,4,1,2,6,7,8,4,3,7,5,6};
for(std::set<int>::iterator i = caaaa.begin(); i != caaaa.end(); ++i)
{
    if(badValue(*i))
    {
        caaa.erase(i);//删除c中badValue返回真得每个元素得代码
    }
    //这里有未定义得行为：当容器得一个元素被删除时，指向那个元素得所有迭代器都失效了
    //当 caaa.erase(i) 返回时， i 已经失效
    //在erase返回后，i通过for循环得 ++i 部分自增，是个坏消息！！！
}

//如果避免这种问题：必须保证在调用 erase之前就得到了c中下一个元素得迭代器，因此在 i 上使用后置递增
for(std::set<int>::iterator i = caaaa.begin(); i != caaaa.end(); )//第三部分是空得，i在下面自增
{
    if(badValue(*i))
    {
        caaaa.erase(i++);
        //对于坏得值，把当前得i 传给erase，然后作为副作用增加 i
        //对于好得值，只增加i
        //i++得值是 i得旧值，旧值（没增加得）传给erase, 但在erase开始执行前i已经自增了，正好是我们想要得
    }
    else
    {
        ++i;
    }
}

//5-1 对于关联容器，很容易，加一句话就行
std::ofstream logFile;
set<int> a = {1,2,3,3,4,7,8,9,10};
std::string fn_out = "set.txt";
logFile.open(fn_out.c_str(),std::ios::out);

for(std::set<int>::iterator i = a.begin(); i != a.end(); )//第三部分是空得，i在下面自增
{
    if(badValue(*i))
    {   
        //写日志文件
        logFile << "Erasing "<<*i<<'\n';

        a.erase(i++);
        //对于坏得值，把当前得i 传给erase，然后作为副作用增加 i
        //对于好得值，只增加i
        //i++得值是 i得旧值，旧值（没增加得）传给erase, 但在erase开始执行前i已经自增了，正好是我们想要得
    }
    else
    {
        ++i;
    }
}

//5-2 对于 vector string deque带来麻烦, 因为没有办法让 erase-remove写日志文件
//必须利用 erase 得返回值，一旦删除完成，它就是指向紧接在被删除之后得元素得有效迭代器
std::vector<int> aa = {1,1,1,1,1,7,8,9,10};

for(std::set<int>::iterator i = aa.begin(); i != aa.end(); )//第三部分是空得，i在下面自增
{
    if(badValue(*i))
    {   
        //写日志文件
        logFile << "Erasing "<<*i<<'\n';
        i = aa.erase(i);//通过把 erase得返回值赋给 i来保持 i有效
    }
    else
    {
        ++i;
    }
}

int main()
{
    //1,
    std::vector<int>::iterator iter_return;
    iter_return = std::remove(c.begin(), c.end(), 1963);
    std::cout << "vals after iter_return: " << std::endl;

    for(std::vector<int>::iterator iter =iter_return; iter!=c.end(); iter++)
    {
       std::cout << (*iter) << "\t";//23,12
    }
    std::cout<<"\n";
    std::cout << "after remove()" << std::endl;

    for(std::vector<int>::iterator iter=c.begin(); iter != c.end(); iter++) 
    {
       std::cout << *iter << "\t";//100,192,12,11,23,12,23,12
    }
    std::cout<<"\n";
    c.erase(std::remove(c.begin(), c.end(), 1963), c.end());
    for(auto i:c)
    {
        std::cout<<i<<"\t";
    }
    std::cout<<"\n";

    //2
    cc.remove(1963);
    for(auto i:cc)
    {
        std::cout<<i<<"\t";
    }
    std::cout<<"\n";

    //3
    ccc.erase(1963);
    for(auto i:ccc)
    {
        std::cout<<i<<"\t";
    }
    std::cout<<"\n";

    //4-1
    std::deque<int>::iterator iter_return_;
    iter_return_ = std::remove_if(ca.begin(), ca.end(), badValue);
    std::cout << "vals after iter_return: " << std::endl;

    for(std::deque<int>::iterator iter =iter_return_; iter!=ca.end(); iter++)
    {
       std::cout << (*iter) << "\t";
    }
    std::cout<<"\n";
    std::cout << "after remove()" << std::endl;

    for(std::deque<int>::iterator iter=ca.begin(); iter != ca.end(); iter++) 
    {
       std::cout << *iter << "\t";
    }
    std::cout<<"\n";

    ca.erase(std::remove_if(ca.begin(), ca.end(),badValue), ca.end());
    for(auto i:ca)
    {
        std::cout<<i<<"\t";
    }
    std::cout<<"\n";

    //4-2
    caa.remove_if(badValue);
    for(auto i:caa)
    {
        std::cout<<i<<"\t";
    }
    std::cout<<"\n";

    //4-3-1
    std::remove_copy_if(caaa.begin(), caaa.end(), inserter(goodValues,goodValues.end()), badValue);
    //交换caaa和goodValues
    caaa.swap(goodValues);
    for(auto i:caaa)
    {
        std::cout<<i<<"\t";
    }
    std::cout<<"\n";

    //4-3-2
    // for(std::set<int>::iterator i = caaaa.begin(); i != caaaa.end(); ++i)
    // {
    //     if(badValue(*i))
    //     {
    //         caaaa.erase(i);//Segmentation fault
    //     }
    // }
    // for(auto i:caaaa)
    // {
    //     std::cout<<i<<"\t";
    // }
    std::cout<<"\n";

    //4-3-2----
    for(std::set<int>::iterator i = caaaa.begin(); i != caaaa.end(); )
    {
        if(badValue(*i))
        {
            caaaa.erase(i++);
        }
        else
        {
            ++i;
        }
    }
    for(auto i:caaaa)
    {
        std::cout<<i<<"\t";
    }
    std::cout<<"\n";

    //5-1
    logFile.open(fn_out.c_str(),std::ios::out);

    for(std::set<int>::iterator i = a.begin(); i != a.end(); )//第三部分是空得，i在下面自增
    {
        if(badValue(*i))
        {   
            //写日志文件
            logFile << "Erasing "<<*i<<'\n';

            a.erase(i++);
            //对于坏得值，把当前得i 传给erase，然后作为副作用增加 i
            //对于好得值，只增加i
            //i++得值是 i得旧值，旧值（没增加得）传给erase, 但在erase开始执行前i已经自增了，正好是我们想要得
        }
        else
        {
            ++i;
        }
    }

    //5-2
    for(std::vector<int>::iterator i = aa.begin(); i != aa.end(); )//第三部分是空得，i在下面自增
    {
        if(badValue(*i))
        {   
            //写日志文件
            logFile << "Erasing 5- 2 "<<*i<<'\n';
            i = aa.erase(i);//通过把 erase得返回值赋给 i来保持 i有效
        }
        else
        {
            ++i;
        }
    }


}

auto p  = new string[100]
for (int i=0; i<5; ++i)
{
    p[i] = "babba...";

   // 只需要5个string，而new把100个对象全部构造好了（每个string已经被初始化为空字符串，也就是""）
   // 也就是前面将p[0-4]赋值为空字符串的操作，变得毫无意义
}

template<class T >
inline T*_allocate(ptrdiff_t num,T*){
    std::cout<<"_allocate"<<endl;
    return static_cast<T*>(::operator new(num*sizeof(T)));
}
template <class T>
inline void _deallocate(T* buff){
    std::cout<<"_deallocate"<<endl;
    ::operator delete(buff);
}

template <class T ,class U>
inline void _construct(T* p,const U& value){
    new(p)T(value);
}
template<class T>
inline void _destory(T* p){
    p->~T();
}
template<typename T>
class MyAlloctor{
    public:
        typedef T        value_type;
        typedef T*       pointer;
        typedef T&       reference;
        typedef const T* const_pointer;
        typedef const T& const_reference;
        typedef size_t     size_type;
        typedef ptrdiff_t  difference_type;
        template<typename _Tp1>struct rebind{ typedef MyAlloctor<_Tp1> other; };

    MyAlloctor()=default;
    ~MyAlloctor()=default;
    pointer address(reference x){
        return static_cast<pointer>(&x);
    }
    const_pointer address(const_reference x){
        return static_cast<const_pointer>(&x);
    }

    pointer allocate(size_type _n,const void* hit=0 ){
        return _allocate(_n,(pointer)0);
    }

    void deallocate(pointer p,size_type _n){
        _deallocate(p);
    }

    size_type max_size()const throw(){
        return static_cast<size_type>(INT_MAX/sizeof(T));
    }

    void construct(pointer p,const_reference value){
        _construct(p,value);
    }

    void destroy(pointer p){
        _destory(p);
    }

};

//https://www.cnblogs.com/SimonKly/p/7819122.html
//#include "CAnimal.h"
#include <memory>
#include <iostream>

using namespace std;

class Animal
{
public:
#if 1        //即使为0，没有默认构造也是可以，
    Animal() : num(0)
    {
        cout << "Animal constructor default" << endl;
    }
#endif
    Animal(int _num) : num(_num)
    {
        cout << "Animal constructor param" << endl;
    }

    ~Animal()
    {
        cout << "Animal destructor" << endl;
    }

    void show()
    {
        cout << this->num << endl;
    }

private:
    int num;
};

int main()
{
    allocator<Animal> alloc;        //1.
    Animal *a = alloc.allocate(5);    //2.

    //3.
    alloc.construct(a, 1);
    alloc.construct(a + 1);
    alloc.construct(a + 2, 3);
    alloc.construct(a + 3);
    alloc.construct(a + 4, 5);

    //4.
    a->show();
    (a + 1)->show();
    (a + 2)->show();
    (a + 3)->show();
    (a + 4)->show();

    //5.
    for (int i = 0; i < 5; i++)
    {
        alloc.destroy(a + i);
    }
    //对象销毁之后还可以继续构建，因为构建和内存的分配是分离的
    //6.
    alloc.deallocate(a, 5);

    cin.get();
    return 0;
}

class Widget{

};

//一个用户定义的分配器
template<class T >
inline T*_allocate(ptrdiff_t num,T*){
    std::cout<<"_allocate"<<endl;
    return static_cast<T*>(::operator new(num*sizeof(T)));
}
template <class T>
inline void _deallocate(T* buff){
    std::cout<<"_deallocate"<<endl;
    ::operator delete(buff);
}

template <class T ,class U>
inline void _construct(T* p,const U& value){
    new(p)T(value);
}
template<class T>
inline void _destory(T* p){
    p->~T();
}
template<typename T>
class SpAllocator{
    public:
        typedef T        value_type;
        typedef T*       pointer;
        typedef T&       reference;
        typedef const T* const_pointer;
        typedef const T& const_reference;
        typedef size_t     size_type;
        typedef ptrdiff_t  difference_type;
        template<typename _Tp1>struct rebind{ typedef SpAllocator<_Tp1> other; };

    SpAllocator()=default;
    ~SpAllocator()=default;
    pointer address(reference x){
        return static_cast<pointer>(&x);
    }
    const_pointer address(const_reference x){
        return static_cast<const_pointer>(&x);
    }

    pointer allocate(size_type _n,const void* hit=0 ){
        return _allocate(_n,(pointer)0);
    }

    void deallocate(pointer p,size_type _n){
        _deallocate(p);
    }

    size_type max_size()const throw(){
        return static_cast<size_type>(INT_MAX/sizeof(T));
    }

    void construct(pointer p,const_reference value){
        _construct(p,value);
    }

    void destroy(pointer p){
        _destory(p);
    }

};

std::list<Widget,SAW> L1;
std::list<Widget,SAW> L2;
L1.splice(L1.begin(),L2);//把L2的节点移到L1前端

//这里list2结合到list1中，并没有拷贝什么，只是调整了一些指针
//当L1被销毁时，L1的分配器必须回收最初由L2的分配器分配的节点
//因此，只有相同的分配器，一个分配器对象分配的内存才可以安全地被另一个分配器对象回收

void* operator new(size_t bytes);//指定分配内存的字节数 例如 sizeof(int) == 4, 容纳一个int内存，传 4
pointer allocator<T>::allocate(size_type numObjectos);//pointer总是 T* 的typedef， 指定是内存里能容纳多少个T 对象 传1 

//list本身由节点组成，每个节点容纳一个T对象和到list中后一个和前一个节点的指针
template<typename T, typename Allocator = allocator<T>>
class list{
    private:
        Allocator alloc;//用于T类型对象的分配器

        struct ListNode
        {
            T data;
            ListNode *prev;
            ListNode *next;
        };
        //你能发现什么问题？
        /**
         * @brief 
         * 
         * 当添加一个新节点到 list时，需要从分配器为他获取内存，我们要的不是 T 的内存，要的是包含了一个 T的 ListNode
         * 的内存，那使 我们的 Allocator对象没有用了，因为它不为 ListNode分配内存，他为 T分配内存
         * 因此，list从未让它的 Allocator做任何分配了，分配器不能提供 list需要的
         * 
         * list需要的是什么呢？
         * 
         * 是从它的分配器类型那里获得用于 ListNode的对于分配器的方法，怎么去实现呢？看下面代码
         * 
         */
};

//标准分配器像这样声明
template<typename T>
class allocator{
    public:
        template<typename U>
        struct rebind
        {
            typedef allocator<U> other;
        };    
};

//因此，在 list<T>的实现代码里，需要确定我们持有的 T的分配器所对应的 ListNode的分配器类型，T的分配器类型是模板参数ALlocator
//ListNodes的对应的分配器类型是：
Allocator::rebind<ListNode>::other

/**
 * @brief 
 * 如何解释以上定义？
 * 
 *  每个分配器模板A（例如，std::allocator，SpecialAllocator，等）都被认为有一个叫做rebind的
    内嵌结构体模板。rebind带有一个类型参数，U，并且只定义一个typedef，other。 other是A<U>的一个简单名
    字。结果，list<T>可以通过Allocator::rebind<ListNode>::other从它用于T对象的分配器（叫做Allocator）获取对
    应的ListNode对象分配器。
 * 
 * 
 */

//起初，你设计了管理共享内存的堆
template<class T>
inline T* mallocShared(size_t bytesNeeded,T*){
    std::set_new_handler(0);
    T *tmp = (T*)(::operator new((size_t)(bytesNeeded * sizeof(T))));
    if (tmp == 0)
    {
        std::cout<<" out of memory"<<std::endl;
        exit(1);
    }
 std::cout<<"mallocShared "<<std::endl;
    return tmp;
 
}

template<class T>
inline void freeShared(T *ptr){
  std::cout<<"freeShared "<<std::endl;
  ::operator delete(ptr);
}

template<typename T>
class SharedMemoryANocator{
    public:
        typedef T*          pointer;
        typedef size_t      size_type;

        typedef T           value_type;
        // 重新绑定分配器(rebind allocator of type U) //不能少自定义分配器中
        template <class U>
        struct rebind
        {
            typedef SharedMemoryANocator<U> other;
        };
            


        pointer allocate(size_type numObjecrs, const void *localityHint=0)
        {
            return static_cast<pointer>(mallocShared(numObjecrs * sizeof(T), (pointer)0));
        }

        void deallocate(pointer ptrToMemory, size_type numObjects)
        {
            freeShared(ptrToMemory);
        }
};

int main()
{
    typedef std::vector<double, SharedMemoryANocator<double> > SharedDoubleVec;

    {
        //开始一个块
        
        //建立一个元素在共享内存中的 vector
        SharedDoubleVec v = {1,2,3};

        //v分离来容纳它元素的内存将来自共享内存，单v本身包括它的全部数据成员，几乎肯定不被放在
        //共享内存里，v只是一个普通的基于堆的对象，所以它将被放在运行时系统为所有普通的基于堆的对象使用的任何内存
        //那几乎不会是共享内存

        //为了把 v的内容和v本身放进共享内存，你需要这样做

        //结束这个块
    }
}

    ////为了把 v的内容和v本身放进共享内存，你需要这样做
    void *localityHint=0;
    void *pVectorMemory = mallocShared(sizeof(SharedDoubleVec),localityHint);//分配足够的共享内存来容纳一个 SharedDoubleVec对象

    SharedDoubleVec *pv = new (pVectorMemory)SharedDoubleVec;// 使用 placement new 来在那块内存中建立一个SharedDoubleVec对象

    pv->~SharedDoubleVec();//销毁共享内存中的对象

    freeShared(pVectorMemory);//销毁原来的共享内存块

//第二个例子：假设你有两个堆，每个堆类由进行分配和回收的静态成员函数
class Heap1{
    public:
        static void* alloc(size_t numBytes, const void *memoryBlockToBeNear);
        static void dealloc(void *ptr);
};

void* Heap1::alloc(size_t numBytes, const void *memoryBlockToBeNear){
    std::set_new_handler(0);
    void *tmp = (void*)(::operator new((size_t)(numBytes * sizeof(memoryBlockToBeNear))));
    if (tmp == 0)
    {
        std::cout<<" out of memory"<<std::endl;
        exit(1);
    }
    std::cout<<"mallocShared "<<std::endl;
    return tmp;
}

void Heap1::dealloc(void *ptr){
    std::cout<<"freeShared "<<std::endl;
  ::operator delete(ptr);
}


class Heap2{
    public:
        static void* alloc(size_t numBytes, const void *memoryBlockToBeNear);
        static void dealloc(void *ptr);
};

void* Heap2::alloc(size_t numBytes, const void *memoryBlockToBeNear){
    std::set_new_handler(0);
    void *tmp = (void*)(::operator new((size_t)(numBytes * sizeof(memoryBlockToBeNear))));
    if (tmp == 0)
    {
        std::cout<<" out of memory"<<std::endl;
        exit(1);
    }
    std::cout<<"mallocShared "<<std::endl;
    return tmp;
}

void Heap2::dealloc(void *ptr){
    std::cout<<"freeShared "<<std::endl;
  ::operator delete(ptr);
}

//你想在不同的堆里联合定位一些STL容器的内容，设计一个分配器，使用像 Heap1和Heap2那样用于真实存在管理的类
template<typename T, typename Heap>
class SpHeapAllocator{
    public:

     typedef T*          pointer;
        typedef size_t      size_type;

        typedef T           value_type;
    

    // 重新绑定分配器(rebind allocator of type U) //不能少自定义分配器中
        template <class U>
        struct rebind
        {
            typedef SharedMemoryANocator<U> other;
        };
            

        T* allocate(size_type numObjecrs, const void *localityHint=0)
        {
            return static_cast<T*>(Heap::alloc(numObjecrs * sizeof(T), localityHint));
        }

        void deallocate(T* ptrToMemory, size_type numObjects)
        {
            Heap::dealloc(ptrToMemory);
        }
};

// //使用SpHealAllocator来把容器的元素集合在一起
std::vector<int,SpHeapAllocator<int,Heap1> > v;
std::set<int,SpHeapAllocator<int, Heap1> > s;
// //把v和s的元素放进Heap1

std::list<WIdget,SpHeapAllocator<Widget,Heap2> > L;
std::map<int, string, less<int>, SpHeapAllocator<std::pair<const int,string>, Heap2>> m;
// //把L和m的元素放进Heap2

//1，搜寻一个 vector<int> 中第一次出现 5 这个值得地方，找到了改为0
std::vector<int> v = {1,2,5,6,7};
std::vector<int>::iterator first5(find(v.begin(), v.end(),5)); //1
if (first5 != v.end()) //2
{
    *first5 = 0;//3 多线程中 1，2，3并不能保证顺序执行
}

//因此需要加锁
std::vector<int> v = {1,2,5,6,7};

getMutexFor(v);
std::vector<int>::iterator first5(find(v.begin(), v.end(),5)); //1
if (first5 != v.end()) //2
{
    *first5 = 0;//3  保证123顺序执行
}
releaseMutexFor(v);

//面向对象得解决方案是创建一个 Lock类，在它得构造函数里获取互斥量并在析构函数里释放它，这样可以减小上面两队函数得不匹配概率
template<typename Container>
class Lock{
    public:
        Lock(const COntainers container):c(container){
            getMutexFor(c);//在构造函数获取互斥量
        }

        ~Lock(){
            releaseMutexFor(c);//在析构函数里释放它
        }

    private:
        const Container& c;
};

std::vector<int> v = {1,2,5,6,7};
{    //建立新块
    Lock<std::vector<int> > lock(v);
    std::vector<int>::iterator first5(find(v.begin(), v.end(),5)); //1
    if (first5 != v.end()) //2
    {
        *first5 = 0;//3
    }
}