C++ Primer读书笔记--顺序容器小结

1、vector
     c.push_back(t)                     //在容器的尾部添加值为t的元素，返回void
     c.push_insert(p,t)               
     c.push_insert(p,n,t)              //在迭代器p指向的元素前面插入值为t的元素，返回指向新元素的迭代器
     c.push_insert(p,b,e)             //在迭代器p指向的元素前面插入在迭代器b和e范围内的元素，返回void
     c.size()                                //返回容器的元素个数。返回类型为c::size_type
     c.max_size()                        //返回c可容纳的最多元素个数。返回类型为c::size_type
     c.empty()                            //返回布尔值，容器是否为空
     c.resize(n)                           //调整容器大小为n;如果n<c.size(),则删除多出来元素；否则，添加采用值初始化的新元素,可能会使迭代器失效
     c.resize(n,t)                         //调整容器大小为n;如果n<c.size(),则删除多出来元素；否则，添加新元素，值都为t，可能会使迭代器失效
     c.front()                              //返回最后一个元素的引用，如果c为空，操作未定义
     c.back()                              //返回最后一个元素的引用，如果c为空，操作未定义
     c.at()                                  //same as c[]
     c.erase(p)                           //删除迭代器p指向的元素，返回指向删除元素的下一个的迭代器
     c.erase(b,e)                        //删除迭代器b,e之间的元素，返回指向删除元素的下一个的迭代器。若e超过末尾，则返回末端的下一个位置的迭代器
     c.clear()                             //清空c的所有元素，返回void
     c.pop_back()                     //删除最后一个元素，返回void，若c为空，则该函数未定义
     c.swap(c2)                        //交换c和c2,且该函数的速度快于复制c2到c
     c.assign(b,e)                      //将迭代器b,e之间的元素复制到c中，b,e之间的元素必须不是指向c的迭代器，包括b和e
     c.assign(n,t)                       //将c重置为n个t

2、list
     c.push_back(t)                     //在容器的尾部添加值为t的元素，返回void
     c.push_front(t)                    //在容器的前端添加值为t的元素，返回void
     c.push_insert(p,t)               
     c.push_insert(p,n,t)              //在迭代器p指向的元素前面插入值为t的元素，返回指向新元素的迭代器
     c.push_insert(p,b,e)             //在迭代器p指向的元素前面插入在迭代器b和e范围内的元素，返回void
     c.size()                                //返回容器的元素个数。返回类型为c::size_type
     c.max_size()                        //返回c可容纳的最多元素个数。返回类型为c::size_type
     c.empty()                            //返回布尔值，容器是否为空
     c.resize(n)                           //调整容器大小为n;如果n<c.size(),则删除多出来元素；否则，添加采用值初始化的新元素,可能会使迭代器失效
     c.resize(n,t)                         //调整容器大小为n;如果n<c.size(),则删除多出来元素；否则，添加新元素，值都为t，可能会使迭代器失效
     c.front()                              //返回最后一个元素的引用，如果c为空，操作未定义
     c.back()                              //返回最后一个元素的引用，如果c为空，操作未定义
     c.erase(p)                           //删除迭代器p指向的元素，返回指向删除元素的下一个的迭代器
     c.erase(b,e)                         //删除迭代器b,e之间的元素，返回指向删除元素的下一个的迭代器。若e超过末尾，则返回末端的下一个位置的迭代器
     c.clear()                              //清空c的所有元素，返回void
     c.pop_back()                       //删除最后一个元素，返回void，若c为空，则该函数未定义
     c.pop_front()                       //删除第一个元素，返回void，若c为空，则该函数未定义
     c.swap(c2)                        //交换c和c2,且该函数的速度快于复制c2到c
     c.assign(b,e)                      //将迭代器b,e之间的元素复制到c中，b,e之间的元素必须不是指向c的迭代器，包括b和e
     c.assign(n,t)                       //将c重置为n个t
     c.push_front(elem)             //在头部插入一个数据。
     c.pop_front()                     // 删除头部数据。
     c.merge(lst2)                      //将lst2合并到c中.这两个list容器对象必须排序.lst2中的元素将被删除，lst2为空。返回void.第一个版本使用<操作符，第二个指定谓词函数.
     c.merge(lst2,func)             //当源list均有序时，得到的list仍是有序的.当源list无序时，得到的list不能保证有序，之所以这样说是因为，
                                                当list1的前两个元素即表现出无序时，合并后的结果将是直接把list2接到list1的后面
     c.remove(val)
     c.remove_if(unaryPred)    //调用c.erase删除所有等于指定值或指定谓词函数返回非零值的元素。返回void
     c.sort()                              //排序
     c.reverse()                          //反向排列c中的元素
     c.splice(iter,lst2)                 //将lst2的元素移到lst中迭代器iter指向的元素前面。在lst2中删除移出的元素，lst2变空。c与lst2不能是同一个对象
     c.splice(iter,lst2,iter2)          //只移动iter2所指向的元素,这个元素必然是lst2中的元素。c和lst2可以是同一个对象。也就是说，可在一个对象中使用splice移动一个元素
     c.splice(iter,beg,end)          //同上，只是变为范围，如果iter也指向这个范围内的一个元素，则该运算未定义
     c.unique()
     c.unique(binaryPred)         //调用erase删除同一个值的连续副本(与泛型算法unique有区别)。第一个版本使用==判断，第二个指定谓词函数.

3、deque
     c.push_back(t)                     //在容器的尾部添加值为t的元素，返回void
     c.push_front(t)                    //在容器的前端添加值为t的元素，返回void
     c.push_insert(p,t)               
     c.push_insert(p,n,t)              //在迭代器p指向的元素前面插入值为t的元素，返回指向新元素的迭代器
     c.push_insert(p,b,e)             //在迭代器p指向的元素前面插入在迭代器b和e范围内的元素，返回void
     c.size()                                //返回容器的元素个数。返回类型为c::size_type
     c.max_size()                        //返回c可容纳的最多元素个数。返回类型为c::size_type
     c.empty()                            //返回布尔值，容器是否为空
     c.resize(n)                           //调整容器大小为n;如果n<c.size(),则删除多出来元素；否则，添加采用值初始化的新元素,可能会使迭代器失效
     c.resize(n,t)                         //调整容器大小为n;如果n<c.size(),则删除多出来元素；否则，添加新元素，值都为t，可能会使迭代器失效
     c.front()                              //返回最后一个元素的引用，如果c为空，操作未定义
     c.back()                              //返回最后一个元素的引用，如果c为空，操作未定义
     c.at()                                  //same as c[]
     c.erase(p)                           //删除迭代器p指向的元素，返回指向删除元素的下一个的迭代器
     c.erase(b,e)                         //删除迭代器b,e之间的元素，返回指向删除元素的下一个的迭代器。若e超过末尾，则返回末端的下一个位置的迭代器
     c.clear()                              //清空c的所有元素，返回void
     c.pop_back()                      //删除最后一个元素，返回void，若c为空，则该函数未定义
     c.pop_front()                      //删除第一个元素，返回void，若c为空，则该函数未定义
     c.swap(c2)                         //交换c和c2,且该函数的速度快于复制c2到c
     c.assign(b,e)                      //将迭代器b,e之间的元素复制到c中，b,e之间的元素必须不是指向c的迭代器，包括b和e
     c.assign(n,t)                       //将c重置为n个t
     c.push_front(elem)             //在头部插入一个数据。
     c.pop_front()                     // 删除头部数据。

 

 

比较说明:
      *.vector内部分配的内存是永不释放的,即使你调用clear()也不会,这一点很不好,有误导性.有可能一个vector只在瞬间需要很大的容 量,但大多数时间只需要很小的容量，结果却是长时间的占用了很大的,没有被使用到的内存.vector也没有提供函数来释放它内部的内存,不过有一个简单 的办法
     i_math::vector<BYTE>buf;
     buf.resize(100000);//分配了一块至少100000 bytes的内存
     if (TRUE)//清空buf的内存
     {
           i_math::vector<BYTE> t;
           buf.swap(t);//把这块内存交换到一个临时的vector里去
     }
     assert(buf.capacity()==0);//内存被清空了
 
     *.deque就不一样了,deque永远不会占用太多冗余的内存,你只需要把它resize()到一个你希望的大小,它会自动释放掉那些被多余占用的内存
 
     *.vector还有一个不好的地方,当你往一个vector里添加一个成员的时候,所有指向这个vector的原来成员的指针就不能保证有效了,因为 vector会re-alloc内存.而deque不会,无论从前面还是后面添加新成员,旧的成员都不会移动位置,这一点有时候很有用

    *vector速度最快，deque也差不了多少。比起list、deque， vector的增长效率往往会更高

    *关于deque内存连续问题（待考）：1、它也支持随机防问,deque的内存是分块连续的，比如说，他有50个元素，有可能就是用3个维数为20的数组组合而成。vector就是一个完整的数组了 . 2、deque的内存并不是连续的，他在数据结构上更像一个双向的链表,所以它的插入的速度比vector要快

迭代器失效
vector在尾部插入元素不会使迭代器失效，在尾部删除元素只会使指向被删除的元素的迭代器失效
list插入删除元素不会使迭代器效率
deque在顶部和尾部插入元素不会使迭代器失效，在顶部和尾部删除元素只会使指向被删除的元素的迭代器失效