effective stl读书笔记 & stl里面提供的算法 & emplace & ostream_iterator

加锁和解锁，也可以在构造函数和析构函数里面，自动调用。

相等和等价的关系：等价是用在排序的时候，跟less函数有关。

vector，deque，string 要用erase-remove组合；而关联容器，直接erase就可以了。

copy(x.begin(), x.end(), ostream_iterator<string>(cout, "\n"));

但是如果x的类型是string*，就不行。

自定义一个print(const string*ps);

然后 for_each(x.begin(), x.end(), print);

或者

struct Dereference{

template<typename T>

const T& operator()(const T* ptr)const {

return *ptr;

}

}

transform(x.begin(), x.end(),

ostream_iterator<string>(cout, "\n"),

Dereference());

注意transform的两种形式：

template < class InputIterator, class OutputIterator, class UnaryOperator >
  OutputIterator transform ( InputIterator first1, InputIterator last1,
                             OutputIterator result, UnaryOperator op );

template < class InputIterator1, class InputIterator2,
           class OutputIterator, class BinaryOperator >
  OutputIterator transform ( InputIterator1 first1, InputIterator1 last1,
                             InputIterator2 first2, OutputIterator result,
                             BinaryOperator binary_op );

有如下两个使用原型，一个将迭代器区间[first，last)中元素，执行一元函数对象op操作，交换后的结果放在[result，result+（last-first)）区间中。另一个将迭代器区间[first1，last1)的元素*i，依次与[first2，first2+（last-first）)的元素*j，执行二元函数操作binary_op(*i,*j)，交换结果放在[result，result+（last1-first1)）。

set的比较类型，是less_equal，注意语义里面带了equal。

可以我看cplusplus网站上面定义的是less。

那还是以less为准吧。

http://www.cplusplus.com/reference/set/set/set/

用advance和distance可以把const iterator 转换成 iterator

其实是这样，iterator i = x.begin(); ci是const iterator

那么 advance(i, distance(i, ci))；也就是把 i 移动到 ci 的位置。

对于 reverse_iterator类型，有一个base函数，能够返回对应的正向iterator信息，因为有的函数只支持正向iterator.

但是这个base返回的iterator，只能在insert的时候用，因为指向的reverse那个方向的前一个节点。

对于erase的时候，就不能用了，因为和reverse的指的不是一个节点。

算法

transform 很多地方都能够用到。

但是一定要注意，result的空间要大于等于待放入的内容。不然结果未定义。

比如：

尾部加入，用back_inserter

result.reserve(result.size()+values.size());

transform(value.begin(), value.end(),

back_inserter(result),

transfunc);

如果需要覆盖

if (result.size() < value.size()) {

result.resize(value.size())

}

transform(value.begin(), value.end(),

result.begin(),

transfunc);

partial_sort对于头部排序，很好用。

partial_sort(w.begin(), w.begin()+20, w.end(), comp);

而如果前面20个也不关心顺序，那么用

nth_element

用法：

nth_element(w.begin(), w.begin()+19, w.end(), comp);

partial_sort是不稳定的，nth_element，sort也没有提供稳定性。

partition函数用来分隔的。注意，partition是快排很好的工具，但是stl里面的partition因为第三个参数是一个bool函数，所以在快排的时候，不太好用。

bool函数为true的，放在partition的前面。

bool isOdd(int i) {return (i%)==;}

int ir[] = {, , , , , };
vector<int> x(ir, ir+sizeof(ir)/sizeof(int));

vector<int>::iterator itr = partition(x.begin(), x.end(), isOdd);

copy(x.begin(), itr, ostream_iterator<int>(cout, " "));
cout<<endl;
copy(itr, x.end(), ostream_iterator<int>(cout, " "));

输出：

stack和vector都有 emplace函数，而stack其实是调用了底层容器的emplace_back，

都是C++11的。

The container is extended by inserting a new element at position. This new element is constructed in place using args as the arguments for its construction.

int main ()
{
  std::vector<int> myvector = {,,};

  auto it = myvector.emplace ( myvector.begin()+,  );
  myvector.emplace ( it,  );
  myvector.emplace ( myvector.end(),  );

  std::cout << "myvector contains:";
  for (auto& x: myvector)
    std::cout << ' ' << x;
  std::cout << '\n';

  return ;
}

Output:
myvector contains: