effective STL

void test()
{
//条款4 使用empty()判断空
//条款5 使用assign赋值，insert赋值
vector<int> v1(10.5), v2(20.7);
v1.clear();
//copy(v2.begin() + v2.size() / 2, v2.end(), back_inserter(v1));

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

//条款6 拷贝int文件到list中
ifstream dataFie("ints.dat");
//list<int> data(istream_iterator<int>(dataFile), istream_iterator<int>()); //什么都不会做？声明了个函数data，第一个参数是dataFile，第二个参数是 函数指针
list<int> data( (istream_iterator<int>(dataFie)), istream_iterator<int>());//用括号括住形式参数是非法的，但是括住实参是合法的

//下面3个同意义
int f(double(d)); //完整参数
int f(double d);
int f(double); //省略参数名

//下面3个同意义
int g(double(*pf)());//g带有一个函数指针为参数
int g(double pf()); //pf是一个函数指针
int g(double());//参数名省略

//条款7 容器中有指针时，new出来的对象 需要手动释放，即容器只负责释放自己的内容

vector<line_iterator *> lwp;
//for crash safe
{
//使用智能指针 shared_ptr代替指针。。。妈蛋
}
for_each(lwp.begin(), lwp.end(), DeleteObject<line_iterator>());//需要指定删除对象，当成员是非虚析构函数，一不留神 容易弄错内存泄漏
for_each(lwp.begin(), lwp.end(), DeleteObject_Init());//编译器自动推导 析构对象

//条款8 放弃auto_ptr

//条款9 删除的时候 如何选择
//Container<int> c
//连续内存容器
vector/* deque string */<int> c; //remove只是放在尾部，不删除
c.erase(remove(c.begin(), c.end(), 1963), c.end());
//链表
list<int> c2;
c2.remove(1963);

//关联容器 set multiset map multimap
set<int> s1;
s1.erase(1963);

//如果把1963 替换为函数 bool isbad(int i) 呢
c.erase(remove_if(c.begin(), c.end(), isbad), c.end());
c2.remove_if(isbad);
for (set<int>::iterator i = s1.begin(); i != s1.end(); )
{
if (isbad(*i)) {
s1.erase(i++); //删除之前i指向下一个
}
else
++i;
}

//条款10，11分配器 暂时看不懂

//条款12 stl线程安全的问题
//template <typename T>
class Lock
{
Lock(const T)
{
//lock
}
~Lock()
{
//un lock

}
};
//条款13 vector 和 string 替代数组，不使用数组
//条款14 vector 和string 根据需求提前reverse(将容量括到至少n大小)，降低重新分配内存概率，或者开始分配很大，后面数据稳定后修剪掉多余的部分

//条款15 string 实现的一些方式

//条款16 C风格的api的使用，vector与string 可以很好的融入C风格api............可以作为其他的容器使用C风格api的桥梁

//条款17 使用"交换技巧"来修整过剩容量 vector<int>(aim_vector).swap(aim_vector)

//条款18 vector<bool> 使用了bit位优化位置，不支持很多容器操作，应使用bitset

//条款19 比较函数使关联容器有序， 但比较的是等价不是相等

//条款20 关联容器中存放指针是，按照指针排序，必须使用仿函数(类)，来自定义比较函数，使元素有序

//条款21 标准关联容器中，相等的值永远返回false，避免插入消耗cpu，破坏有序结构

//条款22 避免原地修改set和multiset的键值

map<int, string> m;
// m.begin()->first = 10; 只读无法修改，若需要修改怎么办。。
//map 的键和值是分开的，键没法修改
set<int> k;
//k.begin(). 100;
//set 的键和值相同，但是排序方式可能是键里面的一部分，可以修改键，但是要保证不修改影响到排序的一部分

//条款23 查找相关 使用hashtable ;vector 和 map对比的话，vector少存储一些东西，因为存在引用局部性，缺页中断概率低，二分查找比二叉树来得快

//条款24 map[] 在添加新元素时性能低下，同时insert在修改老元素时候性能低下
m[1] = "abc"; //判断是否存在1，默认够着1个string，赋值abc
m.insert(map<int,string>::value_type(1, "abc")); // 构造1个abc，节省 默认构造，销毁，赋值
//实现见高效 map添加元素操作

//条款25 哈希表可以使用现成的

//条款26 尽量使用iterator 代替 const_iterator ,reverse_iterator和const_reverse_iterator
//insert 和erase 要求 iterator
//不可能从 const_iterator 转换到 iterator
//iterator 是 reverse_iterator的base(),转换回去，可能出现需要调整 条款28

//条款27 const_iterator 转化为 const
typedef deque<int> IntDeque;
typedef IntDeque::iterator Iter;
typedef IntDeque::const_iterator ConstIter;
ConstIter ci;
//Iter i(ci); //错误
//Iter i(const_cast<Iter&>(ci)); //基础类型不能const_cast转换
IntDeque d;
Iter i(d.begin());
advance(i, distance<ConstIter>(i, ci));//效率如何，数据结构基本性能

//条款28 通过 reverse_iterator 的base() 得到iterator

vector<int> v;
v.reserve(5);

for (int i = 0; i < 5; ++i)
v.push_back(i);
vector<int>::reverse_iterator ri =find(v.rbegin(),v.rend(), 3);//(v.begin(), v.end(), 3);
vector<int>::iterator i(ri.base());//i指向 ri的后面一个位置
v.erase((++ri).base());//删除ri指向的元素

//条款29 需要一个个字符输入(输出)时，考虑istreambuf_iterator(ostreambuf_iterator)

ifstream inputFile("indatatxt");
//关闭忽略空格标志，istream_iterator 依赖与>>函数
inputFile.unsetf(ios::skipws);
string fileDate((istream_iterator<char>(inputFile)), istream_iterator<char>());//但这一行是无法读取空格等字符，速度很慢

//使用istreambuf_iterator
string fileDate((istreambuf_iterator<char>(inputFile)), istreambuf_iterator<char>()); //抓取字符，速度飞快 提高40%

//
//算法部分
//
//
//条款30 顺序容器(目标地点)尾部插入transform用法
vector<int> values;
vector<int> results;
int transmogrify(int x);
transform(values.begin(), values.end(), back_inserter(results), transmogrify);
transform(values.begin(), values.end(), inserter(results,results.begin()+results.size()/2), transmogrify);

//条款31 选择排序api
partial_sort(values.begin(), values.begin() + 20, values.end());//,func); 缺省比较函数,前20个有序
nth_element(values.begin(), values.begin() + 19, values.end());//,func); 前20个无序
bool is_valid(int & a);
partition(values.begin(), values.end(),is_valid);// 返回第一个不满足is_valid的元素

list<int> test_l;
test_l.sort(); //稳定排序
partition(test_l.begin(), test_l.end(), is_valid); //partition可以使用在任何双向迭代器

//条款32 关于 remove
/*
template <class ForwardIterator,class T>
ForwardIterator remove(ForwardIterator first,ForwardIterator end,const T& value);
只有迭代器，都不知道自己操作的对象，所以没法删除数据
*/

//条款34 算法使用条件

//条款35 忽略大小写字符串比较
string ss1, ss2;
typedef pair<string::const_iterator, string::const_iterator> psci;
int ciCharCompare(char, char);
//找到不匹配
psci p = mismatch(ss1.begin(), ss1.end(), ss2.begin(),ss2.end(),not2(ptr_fun(ciCharCompare)) ); //参考条款41

//条款36 了解copy_if的正确实现
//什么鬼 暂时不知道

//条款37 使用for_each 与accumulate 统计区间
vector<string> ssvec;
string::size_type stringLengthSum(string::size_type sumSoFar, const string& s);
accumulate(ssvec.begin(), ssvec.end(), 0, stringLengthSum);

//条款38 STL中传递或者返回的函数，把仿函数类设计为用于值传递，使用对象（指针）组合保证

//条款39

}