1.2.1.8 Usages Tips

• When you use STL Container, you should realize that typedef are your best friends.
  typedef vector<Foo, SpecialAllocator<Foo> > FooContainer; 
  typedef FooContainer::iterator FooIt; 
   
  FooContainer fc1; // make you programming more clearly, 
  FooContainer fc2;  // you should use typedef more 
  FooIt it1;
• Never try to expect all the container has the same interface. Even a generic erase(), for sequence, It return next iterator,(because it will invalid the iterator). But for associative, it return void(c++ 98) and return next iterator(C++ 11). If you just want to change a container in the future, you should put a container into a class: CustomCollection. then hide it from the class client. The detail can be seen in Effective STL item 2.
• The standard associative container are implemented as balanced binary search trees. It’s optimized for a mixed combination of insertions, erasures and lookup. But if that is dictionary, It can be fall into three distinct phases. setup, lookup, modify. and modify is not happen very often. lookup is very often. At this time, associative container is not best option. sorted vector also support log search time. 1) It use less space. 2) more space cause page fault in memory, then the same log search complex, but sorted vector is faster than associate container. For dictionary, please use sorted vector.
• Avoid using vector<bool>, use deque<bool> or bitset
• item 22 Avoid in-place key modification in set and multiset
  1. you can’t change key in map because it’s const default.
     map.begin()->fist = 10 //compile error
  2. For set or map, you can modify non-key part.
     iterator i = set.find(employee); 
     if( i != set.end()) 
        i->setTitle("manager")  // it’s also ok or 
        const_cast<Employee &> (*i).setTitle("manager") 
        // you must change it to a reference, then you can modify it. 
        // if you just use  const_cast<Employee > 
        // this is not right. it will create a temporary obj 
        //and then modify a temporary obj.
  3. If you want to modify the key part in set or map.
      // 1) find the one 
      iterator i = se.find(employee); 
      //2) create temp one. 
      if(i ! = se.end()) 
      Employee e(*i); 
      //3) modify 
      e.setKey("new␣key") 
      //4) delete the old one and keep ; 
       se.erase(i++); 
       //5) insert new one 
       se.insert(i,e);
• Item19 effective STL, Understand the difference between equality and equivalence in associative Containers.
  1. equality is based on operator ==. equivalence is based on operator<. Because associate container, set, map, they must sort their elements, so they must use operator<. Then it use !if(a<b)&&!if(b<a) to define equivalence, and associate container use equivalence to decide if a object exist in container.
  2. if you don’t have custom compare funciton, most of time equivalence is equal to equality, but if you define you specific compare function, you need to know below:
  3. It will cause container.find and generic algorithm find has different result
      set<string,  case_insensitive_compare> ss; 
      //ss has "AA"; 
      ss.find("aa"); //return true; 
      find(ss.begin(),ss.end(),"aa") //return false 
      //find algorithm use operator == .
  4. It will lead to item 21 in effective STL. Always have comparison functions return false for equal values. (strict weak ordering )
  5. It will lead to item 20 in effective STL. For associative container of pointers, You need to specify comaprsion types, You want to order by pointers or want to order by objects pointed by pointer.(Most of time, the second option is what we want)
     struct stringLess: binary_fucntion<const string* , 
                              const string * , bool>{ 
        bool operator()(const string* s1 , 
                                 const string * s2){ 
             return *s1<*s2; 
     } 
     } 
      set<*string,  stringLess> ss;