《Effective STL 读书笔记》 第三章 关联容器

作者：咆哮的马甲 
出处：http://www.cnblogs.com/arthurliu/ 
本文版权归作者和博客园共有，欢迎转载，但未经作者同意必须保留此段声明，且在文章页面明显位置给出原文连接。 
转载请保持文档的完整性，严禁用于任何商业用途，否则保留追究法律责任的权利。

第十九条： 理解相等(equality)和等价(equivalence)的区别　　

• 相等的概念是基于operator==的，也就是取决于operator==的实现
• 等价关系是基于元素在容器中的排列顺序的，如果两个元素谁也不能排列在另一个的前面，那么这两个元素是等价的。
  

标准关联容器需要保证内部元素的有序排列，所以标准容器的实现是基于等价的。标准关联容器的使用者要为所使用的容器指定一个比较函数(默认为less)，用来决定元素的排列顺序。

非成员的函数(通常为STL算法)大部分是基于相等的。下列代码可能会返回不同的结果

struct CIStringCompare:
    public binary_function<string, string, bool> {
    bool operator()(const string& lhs,
                    const string& rhs) const
    {
        int i = stricmp(lhs.c_str(),rhs.c_str());
        if(i < 0)
            return true;
        else
            return false;
    }
};


set<string,CIStringCompare> s; //set的第二个参数是类型而不是函数
s.insert("A");

if(s.find("a") != s.end())  //true
{
    cout<<"a";
}

if(find(s.begin(),s.end(),"a") != s.end())   //false
{
    cout<<"a";
}

第二十条： 为包含指针的关联容器指定比较类型　　

下面的程序通常不会得到用户期望的结果。

set<string*> s;
s.insert(new string("A"));
s.insert(new string("C"));
s.insert(new string("B"));

for(set<string*>::iterator i = s.begin(); i != s.end(); i++)
{
    cout<<**i;  //输出一定会是ABC么？
}

因为set中存储的是指针类型，而它也仅仅会对指针所处的位置大小进行排序，与指针所指向的内容无关。

当关联容器中存储指针或迭代器类型的时候，往往需要用户自定义一个比较函数来替换默认的比较函数。

struct CustomedStringCompare:
    public binary_function<string*, string*, bool> {
    bool operator()(const string* lhs,
                    const string* rhs) const
    {
        return *lhs < *rhs;
    }
};


set<string*,CustomedStringCompare> s;
s.insert(new string("A"));
s.insert(new string("C"));
s.insert(new string("B"));

for(set<string*, CustomedStringCompare>::iterator i = s.begin(); i != s.end(); i++)
{
    cout<<**i; //ABC
}

　　
可以更进一步的实现一个通用的解引用比较类型

struct DerefenceLess{
    template<typename PtrType>
    bool operator()(PtrType ptr1, PtrType ptr2) const
    {
        return *ptr1 < *ptr2;
    }
};

set<string*,DerefenceLess> s;

　　


 

如果用less_equal来实现关联容器中的比较函数,那么对于连续插入两个相等的元素则有

set<int,less_equal<int>> s;
s.insert(1);
s.insert(1);

因为关联容器是依据等价来实现的,所以判断两个1是否等价!

!(1<=1) && !(1<=1) // false 不等价

所以这两个1都被存储在set中,从而破坏了set中不能有重复数据的约定.　

比较函数的返回值表明元素按照该函数定义的顺序排列,一个值是否在另一个之前。相等的值不会有前后顺序，所以，对于相等的值，比较函数应该返回false。


对于multiset又如何呢？multiset应该可以存储两个相等的元素吧？ 答案也是否定的。对于下面的操作:

multiset<int,less_equal> s;
s.insert(1);
s.insert(1);

pair<multiset<int,less_equal>::iterator,multiset<int,less_equal>::iterator> ret = s.equal_range(1);

　　

返回的结果并不是所期望的两个1。因为equal_range的实现(lower_bound:第一个不小于参数值的元素(基于比较函数的小于), upper_bound:第一个大于参数值的元素)是基于等价的，而这两个1基于less_equal是不等价的，所以返回值中比不存在1。

事实上，上面的代码在执行时会产生错误。VC9编译器Debug环境会在第3行出错，Release环境会在之后用到ret的地方发生难以预测的错误。

　　

第二十二条： 切勿直接修改set或multiset的键　　
 

set、multiset、map、multimap都会按照一定的顺序存储其中的元素，但如果修改了其中用于排序的键值，则将会破坏容器的有序性。

对于map和multimap而言，其存储元素的类型为pair<const key, value>，修改map中的key值将不能通过编译(除非使用const_cast)。
对于set和multiset，其存储的键值并不是const的，在修改其中元素的时候，要小心不要修改到键值。

class Employee
{
public:
    int id;
    string title;
};

struct compare:
    public binary_function<Employee&, Employee&, bool> {
    bool operator()(const Employee& lhs,
                    const Employee& rhs) const
    {
        return lhs.id < rhs.id;
    }
};


set<Employee,compare> s;

Employee e1,e2;

e1.id = 2;
e1.title = "QA";

e2.id = 1;
e2.title = "Developer";

s.insert(e1);
s.insert(e2);

set<Employee,compare>::iterator i = s.begin();
i->title = "Manager"; //OK to update non-key value
i->id = 3; // 破坏了有序性

　　
 有些STL的实现将set<T>::iterator的operator*返回一个const T&，用来保护容器中的值不被修改，在这种情况下，如果希望修改非键值，必须通过const_case。

set<Employee,compare>::iterator i = s.begin();
const_cast<Employee&>(*i).title = "Manager"; //OK
const_cast<Employee*>(&*i).title = "Arch"; //OK
const_cast<Employee>(*i).title = "Director"; // Bad 仅仅就修改了临时变量的值 set中的值没有发生改变

　　
对于map和multimap而言，尽量不要修改键值，即使是通过const_cast的方式，因为STL的实现可能将键值放在只读的内存区域当中。

相对安全(而低效)的方式来修改关联容器中的元素

1. 找到希望修改的元素。
2. 将要被修改的元素做一份拷贝。(注意拷贝的Map的key值不要声明为const)
3. 修改拷贝的值。
4. 从容器中删除元素。(erase 见第九条)
5. 插入拷贝的那个元素。如果位置不变或邻近，可以使用hint方式的insert从而将插入的效率从对数时间提高到常数时间。

set<Employee,compare> s;

Employee e1,e2;

e1.id = 2;
e1.title = "QA";

e2.id = 1;
e2.title = "Developer";

s.insert(e1);
s.insert(e2);

set<Employee,compare>::iterator i = s.begin();
Employee e(*i);
e.title = "Manager";

s.erase(i++);
s.insert(i,e);

　

第二十三条： 考虑使用排序的vector替代关联容器　　
 

哈希容器大部分情况下可以提供常数时间的查找效率，标准容器也可以达到对数时间的查找效率。

标准容器通常基于平衡二叉树实现， 这种实现对于插入、删除和查找的混合操作提供了优化。但是对于3步式的操作(首先进行插入操作，再进行查找操作，再修改元素或删除元素)，排序的vector能够提供更好的性能。
因为相对于vector，关联容器需要更大的存储空间。在排序的vector中存储数据比在关联容器中存储数据消耗更少的内存，考虑到页面错误的因素，通过二分搜索进行查找，排序的vector效率更高一些。

如果使用排序的vector替换map，需要实现一个自定义的排序类型，该排序类型依照键值进行排序。
　

第二十四条： 当效率至关重要时，请在map:operator[]和map:insert之间谨慎作出选择　
 

从效率方面的考虑，当向map中添加元素时，应该使用insert，当需要修改一个元素的值的时候，需要使用operator[]

如果使用operator[]添加元素

class Widget{
};


map<int,Widget> m;
Widget w;

m[0] = w；
9 //Widget构造函数被调用两次 

对于第8行，如果m[0]没有对应的值，则会通过默认的构造函数生成一个widget对象，然后再用operator=将w的值赋给这个widget对象。 使用insert可以避免创建这个中间对象。

map<int,Widget> m;
Widget w; 

m.insert(map<int,Widget>::value_type(0,w));  //没有调用构造函数

　　
如果使用insert修改元素的值（当然，不会有人这样做）

map<int,Widget> m;
Widget w(1); 
m.insert(map<int,Widget>::value_type(0,w)); 

Widget w2(2);

m.insert(map<int,Widget>::value_type(0,w2)).first->second = w2;  //构造了一个pair对象

// 上面这段代码比较晦涩
// map::insert(const value_type& x)的返回值为pair<iterator,bool> 

// 当insert的值已经存在时，iterator指向这个已经存在的值，bool值为false。
// 反之，指向新插入的值，bool值为true。

使用operator[]则轻便且高效的多

map<int,Widget> m;
Widget w(1); 
m.insert(map<int,Widget>::value_type(0,w));

Widget w2(2);

m[0] = w2;

　
一个通用的添加和修改map中元素的方法

template<typename MapType,
         typename KeyType,
         typename ValueType>
typename MapType::iterator InsertOrUpdate(MapType& map,const KeyType& k, const ValueType& v) // 注意typename的用法 从属类型前一定要使用typename
{
    typename MapType::iterator i = map.lower_bound(k); // 如果i！=map.end()，则i->first不小于k

    if(i!=map.end() && !map.key_comp()(k,i->first)) // k不小于i->first 等价！
    {
        i->second = v;
        return i;
    }

    else
    {
        return map.insert(i,pair<const KeyType, ValueType>(k,v));
    }
};


map<int,Widget> m;
Widget w(1); 

map<int,Widget>::iterator i  = InsertOrUpdate<map<int,Widget>,int,Widget>(m,0,w);

　

第二十五条： 熟悉非标准的哈希容器
 

如果你和我一样对于hash容器仅仅停留在知道的层次，这篇文章是我看到的国内对于hash_map讲解的最为认真的文章，建议参考一下。

常见的hash容器的实现有SGI和Dinkumware，SGI的hashset的声明类似于

template<typename T,
         typename HashFunction = hash<T>,
         typename CompareFunction = equal_to<T>,
         typename Allocator = allocator<T>>
class hashSet;

　　
Dinkumware的hash_set声明

template<typename T,
         typename CompareFunction>
class hash_compare;

template<typename T,
         typename HashingInfo = hash_compare<T,less<T>>,
         typename Allocator = allocator<T>>
class hash_set;

　　
SGI使用传统的开放式哈希策略，由指向元素的单向链表的指针数组(桶)构成。Dinkumware同样使用开放式哈希策略，由指向元素的双向链表的迭代器数组(桶)组成。从内存的角度上讲，SGI的设计要节省一些。