国产欧美一区二区三区另类精品,国产一区白浆,国产精品美女主播在线观看纯欲

Mon, 14 Oct 2013 10:22:00 GMT

STL中的容器按存储方式分��Z��c�：一�c�L��按以数组形式存储的容器（如：vector�Q�deque�Q�；另一�c�L��以不�q�箋的节点�Ş式存储的容器�Q�如�Q�list�Q�map�Q�set�Q��?/span>
在��用erase�Ҏ��删除元素�Ӟ��q�代器有时候会失效�?/span>在Effective STL�Q�条��?�Q�找��C��erase容器中元素的原则�?br />

1. 对于兌��容器(如map, set, multimap,multiset)�Q�删除当前的iterator�Q�仅仅会使当前的iterator失效�Q�只要在erase�Ӟ��递增当前iterator卛_��?/span>�q�是因�ؓmap之类的容器，使用了红黑树来实玎ͼ�插入、删除一个结点不会对其他�l�点造成影响�?/span>
错误的��用方�?/strong>�Q?br />

std::map<string, string> mapTest;
    std::map<string, string>::iterator iter;
    for ( iter = mapTest.begin();iter != mapTest.end(); iter ++ )
    {
        if ( iter->second == "test" )
        {
            mapTest.erase( iter );
        }
    }

正确的��用方�?�Q?/strong>
  std::map<string, string> mapTest;
    std::map<string, string>::iterator iter;
    for ( iter = mapTest.begin();iter != mapTest.end();)
    {
        if ( iter->second == "test" )
        {
            mapTest.erase( iter++ );
        }
        else
        {
            iter++; // Use Pre Increment for efficiency.
        }
    }
  因�ؓiter传给erase�Ҏ��的是一个副本，iter++会指向下一个元素�?/span>

正确的��用方�?�Q?br />
std::map<string, string> mapTest;
std::map<string, string>::iterator iter;
for ( iter = mapTest.begin();iter != mapTest.end();)
    {
        if ( iter->second == "test" )
        {
            iter = mapTest.erase( iter );
        }
        else
        {
++iter; // Use Pre Increment for efficiency.
        }
    }

2. 对于序列式容�?如vector,deque)�Q�删除当前的iterator会��后面所有元素的iterator都失效。这是因为vetor,deque使用了连�l�分配的内存�Q�删除一个元素导致后面所有的元素会向前移动一个位�|�。还�?/span>erase�Ҏ��可以�q�回下一个有效的iterator�?/span>
3. 对于list来说�Q�它使用了不�q�箋分配的内存，�q�且它的erase�Ҏ��也会�q�回下一个有效的iterator�Q�因此上面两�U�正��的�Ҏ��都可以��用�?/span>

其他链接�Q?a href="http://www.shnenglu.com/Herbert/archive/2009/01/08/70479.html">http://www.shnenglu.com/Herbert/archive/2009/01/08/70479.html
其他链接�Q?a >http://blog.csdn.net/kay226/article/details/6126515
其他链接�Q?a href="http://www.shnenglu.com/humanchao/archive/2013/04/22/199630.html">http://www.shnenglu.com/humanchao/archive/2013/04/22/199630.html

王�v�?/a> 2013-10-14 18:22 发表评论

STL�q�代器及�ȝ��

Tue, 05 Jun 2012 05:59:00 GMT
解释
      �q�代器是一�U�对象，它能够用来遍历STL容器中的部分或全部元素，每个�q�代器对象代表容器中的确定的地址。�P代器修改了常规指针的接口�Q�所谓�P代器是一�U�概念上的抽象：那些行�ؓ上象�q�代器的东西都可以叫做�P代器。然而�P代器有很多不同的能力�Q�它可以把抽象容器和通用��法有机的统一��h��?br />      �q�代器提供一些基本操作符�Q?�?+�?=、！=�?。这些操作和C/C++“操作array元素”时的指针接口一致。不同之处在于，�q�代器是个所谓的smart pointers�Q�具有遍历复杂数据结构的能力。其下层�q�行机制取决于其所遍历的数据结构。因此，每一�U�容器型别都必须提供自己的�P代器。事实上每一�U�容器都��其�q�代器以嵌套的方式定义于内部。因此各�U��P代器的接口相同，型别却不同。这直接导出了泛型程序设计的概念�Q�所有操作行为都使用相同接口�Q�虽然它们的型别不同�?br />
功能特点
      �q�代器��开发�h员不必整个实现类接口。只需提供一个�P代器�Q�即可遍历类中的数据�l�构�Q�可被用来访问一个容器类的所包函的全部元素，其行为像一个指针，但是只可被进行增�?++)或减��?--)操作。�D一个例子，你可用一个�P代器来实现对vector容器中所含元素的遍历�?br />      如下代码对vector容器对象生成和��用了�q�代器：
1 vector<int> the_vector;
2 vector<int>::iterator the_iterator;
3     for( int i=0; i < 10; i++ )
4 the_vector.push_back(i);
5 int total = 0;
6 the_iterator = the_vector.begin();
7 while( the_iterator != the_vector.end() )
8 {
9     total += *the_iterator;
10     the_iterator++;
11 }
12 cout << "Total=" << total << endl;
提示�Q�通过对一个�P代器的解引用操作�Q?�Q�，可以讉K��到容器所包含的元素�?br />
C++标准库�ȝ��

容器
序列
      vector=========================
      list===========================
      deque==========================

序列适配�?br />      stack:top,push,pop=============
      queue:front,back,push,pop======
      priority_queue:top,push,pop====

兌��容器
      map============================
      multimap=======================
      set============================
      multiset=======================

拟容�?br />      string=========================
      valarray=======================
      bitset=========================

��法
http://www.cplusplus.com/reference/algorithm/      STL Algorithms 详细说明�?br />
非修�Ҏ��序列操�?br />
      for_each()=====================对序列中每个元素执行操作
      find()=========================在序列中找某个值的�W�一个出�?br />      find_if()======================在序列中扄��合某谓词的第一个元�?br />      find_first_of()================在序列中扑֏�一序列里的�?br />      adjust_find()==================扑և�盔R��的一对�?br />      count()========================在序列中�l�计某个值出现的�ơ数
      count_if()=====================在序列中�l�计与某谓词匚w��的次�?br />      mismatch()=====================找��两序列相异的�W�一个元�?br />      equal()========================如果两个序列对应元素都相同则为真
      search()=======================扑և�一序列作�ؓ子序列的�W�一个出��C��|?br />      find_end()=====================扑և�一序列作�ؓ子序列的最后一个出��C��|?br />      search_n()=====================扑և�一序列作�ؓ子序列的�W�n个出��C��|?br />修改性的序列操作

      transform()====================��操作应用于序列中的每个元素
      copy()=========================从序列的�W�一个元素�v�q�行复制
      copy_backward()================从序列的最后元素�v�q�行复制
      swap()=========================交换两个元素
      iter_swap()====================交换��p�P代器所指的两个元素
      swap_ranges()==================交换两个序列中的元素
      replace()======================用一个给定值替换一些元�?br />      replace_if()===================替换满��谓词的一些元�?br />      replace_copy()=================复制序列时用一个给定值替换元�?br />      replace_copy_if()==============复制序列时替换满��词的元素
      fill()=========================用一个给定值取代所有元�?br />      fill_n()=======================用一个给定值取代前n个元�?br />      generate()=====================用一个操作的�l�果取代所有元�?br />      generate_n()===================用一个操作的�l�果取代前n个元�?br />      remove()=======================删除��h��l�定值的元素
      remove_if()====================删除满��谓词的元�?br />      remove_copy()==================复制序列时删除给定值的元素
      remove_copy_if()===============复制序列时删除满��词的元素
      unique()=======================删除盔R��的重复元�?br />      unique_copy()==================复制序列时删除相�ȝ��重复元素
      reexample()======================反�{元素的次�?br />      reexample_copy()=================复制序列时反转元素的�ơ序
      rotate()=======================循环�U�d��元素
      rotate_copy()==================复制序列时��@环移动元�?br />      random_shuffle()===============采用均匀分布随机�U�d��元素
序列排序

      sort()=========================以很好的�q�_��ơ序排序
      stable_sort()==================排序且维持相同元素原有的��序
      partial_sort()=================��序列的前一部分排好�?br />      partial_sort_copy()============复制的同时将序列的前一部分排好�?br />      nth_element()==================��第n个元素放到它的正��位�|?br />      lower_bound()==================扑ֈ�某个值的�W�一个出�?br />      upper_bound()==================扑ֈ�大于某个值的�W�一个出�?br />      equal_range()==================扑և��h��l�定值的一个子序列
      binary_search()================在排好序的序列中��定�l�定元素是否存在
      merge()========================归�ƈ两个排好序的序列
      inplace_merge()================归�ƈ两个接箋的排好序的序�?br />      partition()====================��满��x��谓词的元素都攑ֈ�前面
      stable_partition()=============��满��x��谓词的元素都攑ֈ�前面且维持原��序
集合��法

      include()======================如果一个序列是另一个的子序列则为真
      set_union()====================构造一个已排序的�ƈ�?br />      set_intersection()=============构造一个已排序的交�?br />      set_difference()===============构造一个已排序序列�Q�包含在�W�一个序列但不在�W�二个序列的元素
      set_symmetric_difference()=====构造一个已排序序列�Q�包括所有只在两个序列之一中的元素
堆操�?br />
      make_heap()====================��序列高速得能够作�ؓ堆��?br />      push_heap()====================向堆中加入一个元�?br />      pop_heap()=====================从堆中去除元�?br />      sort_heap()====================对堆排序
最大和最��?br />
      min()==========================两个��g��较小�?br />      max()==========================两个��g��较大�?br />      min_element()==================序列中的最��元�?br />      max_element()==================序列中的最大元�?br />      lexicographic_compare()========两个序列中按字典序的�W�一个在�?br />排列

      next_permutation()=============按字典序的下一个排�?br />      prev_permutation()=============按字典序的前一个排�?br />通用数值算�?br />
      accumulate()===================�U�篏在一个序列中�q�算的结�?向量的元素求各的推广)
      inner_product()================�U�篏在两个序列中�q�算的结�?内积)
      partial_sum()==================通过在序列上的运��生序�?增量变化)
      adjacent_difference()==========通过在序列上的运��生序�?与partial_sum相反)
C风格��法

      qsort()========================快速排序，元素不能有用户定义的构造，拯��赋值和析构函数
      bsearch()======================二分法查找，元素不能有用户定义的构造，拯��赋值和析构函数

函数对象
基类
      template struct unary_function
      template struct binary_function
谓词
�q�回bool的函数对象�?br />
      equal_to=======================二元�Q�arg1 == arg2
      not_equal_to===================二元�Q�arg1 != arg2
      greater========================二元�Q�arg1 > arg2
      less===========================二元�Q�arg1 < arg2
      greater_equal==================二元�Q�arg1 >= arg2
      less_equal=====================二元�Q�arg1 <= arg2
      logical_and====================二元�Q�arg1 && arg2
      logical_or=====================二元�Q�arg1 || arg2
      logical_not====================一元，!arg
��术函数对象

      plus===========================二元�Q�arg1 + arg2
      minus==========================二元�Q�arg1 - arg2
      multiplies=====================二元�Q�arg1 * arg2
      divides========================二元�Q�arg1 / arg2
      modulus========================二元�Q�arg1 % arg2
      negate=========================一元，-arg
�U�束器，适配器和否定�?br />
      bind2nd(y)
            binder2nd==================以y作�ؓ�W�二个参数调用二元函�?br />      bind1st(x)
            binder1st==================以x作�ؓ�W�一个参数调用二元函�?br />      mem_fun()
            mem_fun_t==================通过指针调用0元成员函�?br />            mem_fun1_t=================通过指针调用一元成员函�?br />            const_mem_fun_t============通过指针调用0元const成员函数
            const_mem_fun1_t===========通过指针调用一元const成员函数
      mem_fun_ref()
            mem_fun_ref_t==============通过引用调用0元成员函�?br />            mem_fun1_ref_t=============通过引用调用一元成员函�?br />            const_mem_fun_ref_t========通过引用调用0元const成员函数
            const_mem_fun1_ref_t=======通过引用调用一元const成员函数
      ptr_fun()
            pointer_to_unary_function==调用一元函数指�?br />      ptr_fun()
            pointer_to_binary_function=调用二元函数指针
      not1()
            unary_negate===============否定一元谓�?br />      not2()
            binary_negate==============否定二元谓词

�q�代�?br />分类
      Output: *p= , ++
      Input: =*p , -> , ++ , == , !=
      Forward: *p= , =*p , -> , ++ , == , !=
      Bidirectional: *p= , =*p -> , [] , ++ , -- , == , !=
      Random: += , -= , *p= , =*p -> , [] , ++ , -- , + , - , == , != , < , > , <= , >=
插入�?br />      template back_insert_iterator back_inserter(Cont& c);
      template front_insert_iterator front_inserter(Cont& c);
      template insert_iterator back_inserter(Cont& c, Out p);
反向�q�代�?br />      reexample_iterator===============rbegin(), rend()
��P代器
      ostream_iterator===============用于向ostream写入
      istream_iterator===============用于向istream��d��
      ostreambuf_iterator============用于向流�~�冲区写�?br />      istreambuf_iterator============用于向流�~�冲��?br />
分配�?/strong>

      template class std::allocator

数�?/strong>
数值的限制

      numeric_limits<>

      CHAR_BIT
      INT_MAX
      ...

      DBL_MIN_EXP
      FLT_RADIX
      LDBL_MAX
      ...
标准数学函数

      double abs(double)=============�l�对�?不在C�?�Q�同fabs()
      double fabs(double)============�l�对�?br />      double ceil(double d)==========不小于d的最��整�?br />      double floor(double d)=========不大于d的最大整�?br />      double sqrt(double d)==========d在��^�Ҏ��Q�d必须非负
      double pow(double d, double e)=d的e�ơ幂
      double pow(double d, int i)====d的i�ơ幂
      double cos(double)=============余��u
      double sin(double)=============正��u
      double tan(double)=============正切
      double acos(double)============反余�?br />      double asin(double)============反正�?br />      double atan(double)============反正�?br />      double atan2(double x,double y) //atan(x/y)
      double sinh(double)============双曲正��u
      double cosh(double)============双曲余��u
      double tanh(double)============双曲正切
      double exp(double)=============指数�Q�以e为底
      double log(double d)===========自动�Ҏ��(以e为底),d必须大于0
      double log10(double d)=========10底对敎ͼ�d必须大于0
      double modf(double d,double*p)=�q�回d的小数部分，整数部分存入*p
      double frexp(double d, int* p)=扑և�[0.5,1)中的x,y,使d=x*pow(2,y),�q�回x�q�将y存入*p
      double fmod(double d,double m)=��点��C��敎ͼ��W�号与d相同
      double ldexp(double d, int i)==d*pow(2,i)

      int abs(int)===================�l�对�?br />      long abs(long)=================�l�对�?不在C�?
      long labs(long)================�l�对�?br />      struct div_t { implementation_defined quot, rem; }
      struct ldiv_t { implementation_defined quot, rem; }
      div_t div(int n, int d)========用d除n�Q�返�?商，余数)
      ldiv_t div(long n, long d)=====用d除n�Q�返�?商，余数)(不在C�?
      ldiv_t ldiv(long n, long d)====用d除n�Q�返�?商，余数)
向量��术

      valarray
复数��术

      template class std::complex;

王�v�?/a> 2012-06-05 13:59 发表评论

C++ Queues(队列)、Priority Queues(优先队列)

Tue, 05 Jun 2012 05:21:00 GMT
C++ Queues(队列)

C++队列是一�U�容器适配器，它给予程序员一�U�先�q�先�?FIFO)的数据结构�?br />1.back() �q�回一个引用，指向最后一个元�?br />2.empty() 如果队列�I�则�q�回�?br />3.front() �q�回�W�一个元�?br />4.pop() 删除�W�一个元�?br />5.push() 在末��֊�入一个元�?br />6.size() �q�回队列中元素的个数

队列可以用线性表(list)或双向队�?deque)来实�?注意vector container 不能用来实现queue�Q�因为vector 没有成员函数pop_front!)�Q?br />queue> q1;
queue> q2;
其成员函数有“判空(empty)” �?#8220;��寸(Size)” �?#8220;首元(front)” �?#8220;��օ�(backt)” �?#8220;加入队列(push)” �?#8220;弹出队列(pop)”�{�操作�?br />
例：

1 int main()
2 {
3     queue<int> q;
4     q.push(4);
5     q.push(5);
6     printf("%d\n",q.front());
7     q.pop();
8 }

C++ Priority Queues(优先队列)

C++优先队列�c�M��队列�Q�但是在�q�个数据�l�构中的元素按照一定的断言排列有序�?br />1.empty() 如果优先队列为空�Q�则�q�回�?br />2.pop() 删除�W�一个元�?br />3.push() 加入一个元�?br />4.size() �q�回优先队列中拥有的元素的个�?br />5.top() �q�回优先队列中有最高优先��的元�?br />
优先�U�队列可以用向量(vector)或双向队�?deque)来实�?注意list container 不能用来实现queue�Q�因为list 的�P代器不是��L��存取iterator�Q�而pop 中用到堆排序时是要求randomaccess iterator �?)�Q?br />priority_queue, less> pq1; // 使用递增less函数对象排序
priority_queue, greater> pq2; // 使用递减greater函数对象排序
其成员函数有“判空(empty)” �?#8220;��寸(Size)” �?#8220;栈顶元素(top)” �?#8220;压栈(push)” �?#8220;�Ҏ��(pop)”�{��?br />
例：

1 #include <iostream>
2 #include <queue>
3 using namespace std;
4
5 class T {
6 public:
7     int x, y, z;
8     T(int a, int b, int c):x(a), y(b), z(c)
9     {
10     }
11 };
12 bool operator < (const T &t1, const T &t2)
13 {
14     return t1.z < t2.z; // 按照z的顺序来军_��t1和t2的顺�?/span>
15 }
16 main()
17 {
18     priority_queue<T> q;
19     q.push(T(4,4,3));
20     q.push(T(2,2,5));
21     q.push(T(1,5,4));
22     q.push(T(3,3,6));
23     while (!q.empty())
24     {
25         T t = q.top();
26         q.pop();
27         cout << t.x << " " << t.y << " " << t.z << endl;
28     }
29     return 1;
30 }
      输出�l�果�?注意是按照z的顺序从大到��出队的)�Q?
      3 3 6
      2 2 5
      1 5 4
      4 4 3

      再看一个按照z的顺序从��到大出队的例子�Q?
1 #include <iostream>
2 #include <queue>
3 using namespace std;
4 class T
5 {
6 public:
7     int x, y, z;
8     T(int a, int b, int c):x(a), y(b), z(c)
9     {
10     }
11 };
12 bool operator > (const T &t1, const T &t2)
13 {
14     return t1.z > t2.z;
15 }
16 main()
17 {
18     priority_queue<T, vector<T>, greater<T> > q;
19     q.push(T(4,4,3));
20     q.push(T(2,2,5));
21     q.push(T(1,5,4));
22     q.push(T(3,3,6));
23     while (!q.empty())
24     {
25         T t = q.top();
26         q.pop();
27         cout << t.x << " " << t.y << " " << t.z <<  endl;
28     }
29     return 1;
30 }
      输出�l�果为：
      4 4 3
      1 5 4
      2 2 5
      3 3 6
      如果我们把第一个例子中的比较运��符重蝲为： bool operator < (const T &t1, const T &t2) { return t1.z > t2.z; // 按照z的顺序来军_��t1和t2的顺序} 则第一个例子的�E�序会得到和�W�二个例子的�E�序相同的输出结果�?br />

王�v�?/a> 2012-06-05 13:21 发表评论

C++ Stacks�Q�堆栈）

Tue, 05 Jun 2012 05:16:00 GMT
C++ Stack�Q�堆栈）是一个容器类的改�~�，为程序员提供了堆栈的全部功能�Q?#8212;—也就是说实现了一个先�q�后出（FILO�Q�的数据�l�构�?br />1.empty() 堆栈为空则返回真
2.pop() �U�除栈顶元素
3.push() 在栈��增加元�?br />4.size() �q�回栈中元素数目
5.top() �q�回栈顶元素

栈可以用向量(vector)、线性表(list)或双向队�?deque)来实玎ͼ�
stack> s1;
stack > s2;
stack> s3;
其成员函数有“判空(empty)” �?#8220;��寸(Size)” �?#8220;栈顶元素(top)” �?#8220;压栈(push)” �?#8220;�Ҏ��(pop)”�{��?br />
范例引自�Q?a >http://blog.csdn.net/morewindows/article/details/6950881

1 int main()
2 {
3     //可以使用list或vector作�ؓ栈的容器�Q�默认是使用deque的�?nbsp;
4     stack<int, list<int>>      a;
5     stack<int, vector<int>>   b;
6     int i;
7
8     //压入数据
9     for (i = 0; i < 10; i++)
10     {
11         a.push(i);
12         b.push(i);
13     }
14
15     //栈的大小
16     printf("%d %d\n", a.size(), b.size());
17
18     //取栈��Ҏ��据�ƈ��数据弹出栈
19     while (!a.empty())
20     {
21         printf("%d ", a.top());
22         a.pop();
23     }
24     putchar('\n');
25
26     while (!b.empty())
27     {
28         printf("%d ", b.top());
29         b.pop();
30     }
31     putchar('\n');
32     return 0;
33 }
34

王�v�?/a> 2012-06-05 13:16 发表评论

C++ Sets & MultiSets

Tue, 05 Jun 2012 02:51:00 GMT
STL Set介绍

集合(Set)是一�U�包含已排序对象的关联容器。多元集�?MultiSets)和集�?Sets)相像�Q�只不过支持重复对象,其用法与set基本相同�?br />Set 又称集合�Q�实际上��是一�l�元素的集合�Q�但其中所包含的元素的值是唯一的，且是按一定顺序排列的�Q�集合中的每个元素被�U�C��集合中的实例。因为其内部是通过链表的方式来�l�织�Q�所以在插入的时候比vector 快，但在查找和末��添加上比vector 慢�?br />multiset 是多重集合，其实现方式和set 是相似的�Q�只是它不要求集合中的元素是唯一的，也就是说集合中的同一个元素可以出现多�ơ�?br />
构造：
explicit set(const Compare&=compare());
如：set > set1;
less是一个标准类�Q�用于�Ş成升序排列函数对象。降序排列是用greater�?
Template set(InputIterator, InputIterator,\ const Compare&=compare());
如：set >set2(vector1.begin(),vector1.end());
通过指定某一预先定义的区间来初始化set对象的构造函数�?
set�Q�const set�Q?
如：set >set3(set2);

�Ҏ��Q?/strong>
1.begin() �q�回指向�W�一个元素的�q�代�?br />2.clear() 清除所有元�?br />3.count() �q�回某个值元素的个数
4.empty() 如果集合为空�Q�返回true
5.end() �q�回指向最后一个元素的�q�代�?br />6.equal_range() �q�回�W�一�?gt;=关键字的�q�代器和>关键字的�q�代�?br />      语法�Q?br />      pair equal_range( const key_type &key );
      //key是用于排序的关键�?br />      Set ctr;
      例如�Q?br />      Pair::iterator,set::iterarot>p;
      For(i=0;i<=5;i++) ctr.insert(i);
      P=ctr.equal_range(2);
      那么*p.first==2;*p.second==3;
7.erase() 删除集合中的元素
      语法:
      iterator erase( iterator i ); //删除i位置元素
      iterator erase( iterator start, iterator end );
      //删除从start开始到end(end为第一个不被删除的�?�l�束的元�?br />      size_type erase( const key_type &key );
      //删除�{�于key值的所有元素（�q�回被删除的元素的个敎ͼ�
      //前两个返回第一个不被删除的双向定位�?不存在返回末��?br />      //�W�三个返回删除个�?br />8.find() �q�回一个指向被查找到元素的�q�代�?br />      语法:
      iterator find( const key_type &key );
      //查找�{�于key值的元素�Q��ƈ�q�回指向该元素的�q�代�?
      //如果没有扑ֈ�,�q�回指向集合最后一个元素的�q�代�?br />9.get_allocator() �q�回集合的分配器
10.insert() 在集合中插入元素
      语法:
      iterator insert( iterator i, const TYPE &val ); //在�P代器i前插入val
      void insert( input_iterator start, input_iterator end );
      //��P代器start开始到end�Q�end不被插入�Q�结束返回内的元素插入到集合�?br />      pair insert( const TYPE &val );
      //插入val元素�Q�返回指向该元素的�P代器和一个布��值来说明val是否成功被插�?br />      //应该注意的是在集�?Sets中不能插入两个相同的元素)
11.lower_bound() �q�回指向大于�Q�或�{�于�Q�某值的�W�一个元素的�q�代�?br />      语法:
      iterator lower_bound( const key_type &key );
      //�q�回一个指向大于或者等于key值的�W�一个元素的�q�代�?br />12.key_comp() �q�回一个用于元素间值比较的函数
      语法:
      key_compare key_comp();
      //�q�回一个用于元素间值比较的函数对象
13.max_size() �q�回集合能容�U�的元素的最大限�?br />14.rbegin() �q�回指向集合中最后一个元素的反向�q�代�?br />      �C�Z��Q?br />      Set ctr;
      Set::reverse_iterator rcp;
      For(rcp=ctr.rbegin();rcp!=ctr.rend();rcp++)
      Cout<<*rcp<<” ”;
15.rend() �q�回指向集合中第一个元素的反向�q�代�?br />16.size() 集合中元素的数目
17.swap() 交换两个集合变量
      语法:
      void swap( set &object ); //交换当前集合和object集合中的元素
18.upper_bound() �q�回大于某个值元素的�q�代�?br />      语法:
      iterator upwer_bound( const key_type &key );
      //�q�回一个指向大于key值的�W�一个元素的�q�代�?br />19.value_comp() �q�回一个用于比较元素间的值的函数
      语法:
      iterator upper_bound( const key_type &key );//�q�回一个用于比较元素间的值的函数对象
20.Set集合的�ƈ�Q�交和差
set_union(a.begin(),a.end(),b.begin(),b.end(),insert_iterator >(c,c.begin()));
set_intersection(a.begin(),a.end(),b.begin(),b.end(),insert_iterator >(c,c.begin()));
set_difference(a.begin(),a.end(),b.begin(),b.end(),insert_iterator >(c,c.begin()));

以下转自�Q?a >http://blog.csdn.net/wangji163163/article/details/3740948

STL Set 交集合集差集

Set是关联容器。其键值就是实��|��实值就是键��|��不可以有重复�Q�所以我们不能通过set的�P代器来改变set的元素的��|��set拥有和list相同的特性：当对他进行插入和删除操作的时候，操作之前的�P代器依然有效。当然删除了的那个就没效了。Set的底层结构是RB-tree�Q�所以是有序的�?/p>
   stl中特别提供了一�U�针对set的操作的��法�Q�交集set_intersection�Q��ƈ集set_union�Q�差集set_difference。对�U�差集set_symeetric_difference�Q�这些算法稍后会讲到�?/p>
一�Q�set模板�cȝ��声明�?/p>

1 template <
2    class Key,
3    class Traits=less<Key>,
4    class Allocator=allocator<Key>
5 >
6 class set�?/span>

其中个参数的意义如下�Q?/strong>

key�Q?/strong>要放入set里的数据�c�d��Q�可以是��M��c�d��的数据�?/p>
Traits�Q?/strong>�q�是一个仿函数�Q�关于仿函数是什么，我后面的文章会讲刎ͼ�。提供了��h��比较功能的仿函数�Q�来觉得元素在set里的排列的顺序，�q�是一个可选的参数�Q�默认的是std::less�Q�如果要自己提供�q�个参数�Q�那么必��要遵��@此规则：��h��两个参数�Q�返回类型�ؓbool�?/p>
Allocator:�I�间配置器，�q�个参数是可选的�Q�默认的是std::allocator.

二：set里的基本操作

我们可以通过下面的方法来实例化一个set�?/span>�?/span>

std::set s;那个s�q�个对象里面存贮的元素是从小到大排序的，(因�ؓ用std::less作�ؓ比较工具�?

如果要想在s里面插入数据�Q�可以用inset函数�Q�set没用重蝲[]操作�Q�因为set本生的值和索引是相同的)

s.insert(3);s.insert(5).....

因�ؓset是集合，那么集合本��n��p��求是唯一性，所以如果要像set里面插入数据和以前的数据有重合，那么插入不成功�?/font>

可以通过下面的方法来遍历set里面的元�?/font>

1 std::set<int>::iterator it = s.begin();
2 while(it!=s.end())
3 {
4    cout<<*it++<<endl;//�q�代器依�ơ后�U�，直到末尾�?/span>
5 }

如果要查找一个元素用find函数�Q�it = s.find(3);�q�样it是指�?的那个元素的。可以通过rbegin�Q�rend来逆向遍历

1 std::set<int>::reverse_iterator it = s.rbegin();
2
3 while(it!=s.rend())
4
5 {cout<<*it++<<endl;}

�q�有其他的一些操作在�q�就不一一列出了�?/font>

三：与set相关的一�l�算�?/font>

set_intersection() :�q�个函数是求两个集合的交�?/font>。下面是stl里的源代�?/p>
1 template<class _InIt1,
2 class _InIt2,
3 class _OutIt> inline
4 _OutIt set_intersection(_InIt1 _First1, _InIt1 _Last1,
5    _InIt2 _First2, _InIt2 _Last2, _OutIt _Dest)
6 { // AND sets [_First1, _Last1) and [_First2, _Last2), using operator<
7 for (; _First1 != _Last1 && _First2 != _Last2; )
8    if (*_First1 < *_First2)
9     ++_First1;
10    else if (*_First2 < *_First1)
11     ++_First2;
12    else
13     *_Dest++ = *_First1++, ++_First2;
14 return (_Dest);
15 }

      �q�是个模板函敎ͼ�从上面的��法可以看出�Q�传�q�去的两个容器必��L��有序的。_Dest指向输出的容器，�q�个容器必须是预先分配好�I�间的，否则会出错的,�q�回值指向保存结果的容器的尾端的下一个位�|�。eg.

1 set_union() :求两个集合的�q��Q�参数要求同上�?br /> 2
3 std::set_difference�Q�）�Q�差�?br /> 4
5 set_symmetric_difference�Q�）�Q�得到的�l�果是第一个�P代器相对于第二个的差集�ƈ上第二个相当于第一个的差集。代码：
6
7 struct compare
8 {
9 bool operator ()(string s1,string s2)
10 {
11    return s1>s2;
12 }///自定义一个仿函数
13 };
14 int main()
15 {
16 typedef std::set<string,compare> _SET;
17 _SET s;
18 s.insert(string("sfdsfd"));
19 s.insert(string("apple"));
20 s.insert(string("english"));
21 s.insert(string("dstd"));
22 cout<<"s1:"<<endl;
23 std::set<string,compare>::iterator it = s.begin();
24 while(it!=s.end())
25    cout<<*it++<<"   ";
26 cout<<endl<<"s2:"<<endl;
27 _SET s2;
28 s2.insert(string("abc"));
29 s2.insert(string("apple"));
30 s2.insert(string("english"));
31 it = s2.begin();
32 while(it!=s2.end())
33    cout<<*it++<<"   ";
34 cout<<endl<<endl;
35
36 string str[10];
37 string *end = set_intersection(s.begin(),s.end(),s2.begin(),s2.end(),str,compare());//求交集，�q�回值指向str最后一个元素的��
38 cout<<"result of set_intersection s1,s2:"<<endl;
39    string *first = str;
40    while(first<end)
41     cout <<*first++<<" ";
42    cout<<endl<<endl<<"result of set_union of s1,s2"<<endl;
43    end = std::set_union(s.begin(),s.end(),s2.begin(),s2.end(),str,compare());//�q��
44    first = str;
45    while(first<end)
46     cout <<*first++<<" ";
47    cout<<endl<<endl<<"result of set_difference of s2 relative to s1"<<endl;
48    first = str;
49    end = std::set_difference(s.begin(),s.end(),s2.begin(),s2.end(),str,compare());//s2相对于s1的差�?/span>
50    while(first<end)
51     cout <<*first++<<" ";
52    cout<<endl<<endl<<"result of set_difference of s1 relative to s2"<<endl;
53    first = str;
54    end = std::set_difference(s2.begin(),s2.end(),s.begin(),s.end(),str,compare());//s1相对于s2的差�?/span>
55
56    while(first<end)
57     cout <<*first++<<" ";
58    cout<<endl<<endl;
59    first = str;
60 end = std::set_symmetric_difference(s.begin(),s.end(),s2.begin(),s2.end(),str,compare());//上面两个差集的�ƈ�?/span>
61    while(first<end)
62     cout <<*first++<<" ";
63    cout<<endl;
64 }
65
66 set<int>   s3   ;
67 set<int>::iterator   iter   =   s3.begin()   ;
68 set_intersection(s1.begin(),s1.end(),s2.begin(),s2.end(),inserter(s3,iter));
69 copy(s3.begin(),s3.end(),   ostream_iterator<int>(cout,"   "));

王�v�?/a> 2012-06-05 10:51 发表评论

C++ Maps & MultiMaps

Mon, 04 Jun 2012 08:57:00 GMT
     摘要: C++ Maps & MultiMapsC++ Maps是一�U�关联式容器�Q�包�?#8220;关键�?�?#8221;寏V�? C++ Multimaps和maps很相��|��但是MultiMaps允许重复的元素�? 1.begin() �q�回指向map头部的�P代器 2.clear() 删除所有元�? 3.count() �q�回指定元素出现的次�?    语法...  阅读全文

王�v�?/a> 2012-06-04 16:57 发表评论

C++ Deque(双向队列)

Mon, 04 Jun 2012 07:57:00 GMT

C++ Deque(双向队列)

    是一�U�优化了的、对序列两端元素�q�行��d��和删除操作的基本序列容器。它允许较�ؓ快速地随机讉K��Q�但它不�?/span>vector 把所有的对象保存在一块连�l�的内存块，而是采用多个�q�箋的存储块�Q��ƈ且在一个映��结构中保存对这些块及其��序的跟�t�。向deque 两端��d��或删除元素的开销很小。它不需要重新分配空��_��所以向末端增加元素�?/span>vector 更有效�?

    实际上，deque 是对vector �?/span>list 优缺点的�l�合�Q�它是处于两者之间的一�U�容器�?

Deque 的特点：

    (1) 随机讉K��方便�Q�即支持[ ] 操作�W�和vector.at() �Q�但性能没有vector 好；

    (2) 可以在内部进行插入和删除操作�Q�但性能不及list �Q?

    (3) 可以在两端进�?/span>push �?/span>pop �Q?

    (4) 相对�?/span>verctor 占用更多的内存�?

双向队列和向量很�怼��Q�但是它允许在容器头部快速插入和删除�Q�就像在��N��一��P��?/span>

1.Constructors 创徏一个新双向队列

   语法:

      deque();//创徏一个空双向队列

      deque( size_type size );// 创徏一个大��ؓsize的双向队�?

      deque( size_type num, const TYPE &val ); //攄��num�?/span>val的拷贝到队列�?

      deque( const deque &from );// �?/span>from创徏一个内容一��L��双向队列

      deque( input_iterator start, input_iterator end );

      // start �?end - 创徏一个队列，保存�?/span>start�?/span>end的元素�?

2.Operators 比较和赋值双向队�?

      //可以使用[]操作�W�访问双向队列中单个的元�?

3.assign() 讄��双向队列的�?

   语法:

      void assign( input_iterator start, input_iterator end);

      //start�?/span>end指示的范围�ؓ双向队列赋�?

      void assign( Size num, const TYPE &val );//讄��?/span>num�?/span>val�?

4.at() �q�回指定的元�?nbsp;
   语法:

      reference at( size_type pos ); �q�回一个引用，指向双向队列中位�|?/span>pos上的元素

5.back() �q�回最后一个元�?

   语法:

      reference back();//�q�回一个引用，指向双向队列中最后一个元�?

6.begin() �q�回指向�W�一个元素的�q�代�?

   语法:

      iterator begin();//�q�回一个�P代器�Q�指向双向队列的�W�一个元�?

7.clear() 删除所有元�?

8.empty() �q�回真如果双向队列�ؓ�I?

9.end() �q�回指向��N��的�P代器

10.erase() 删除一个元�?

   语法:

      iterator erase( iterator pos ); //删除pos位置上的元素

      iterator erase( iterator start, iterator end ); //删除start�?/span>end之间的所有元�?

      //�q�回指向被删除元素的后一个元�?

11.front() �q�回�W�一个元素的引用

12.get_allocator() �q�回双向队列的配�|�器

13.insert() 插入一个元素到双向队列�?

   语法:

      iterator insert( iterator pos, size_type num, const TYPE &val ); //pos前插�?/span>num�?/span>val�?

      void insert( iterator pos, input_iterator start, input_iterator end );

      //插入�?/span>start�?/span>end范围内的元素�?/span>pos前面

14.max_size() �q�回双向队列能容�U�的最大元素个�?

15.pop_back() 删除��N��的元�?

16.pop_front() 删除头部的元�?

17.push_back() 在尾部加入一个元�?

18.push_front() 在头部加入一个元�?

19.rbegin() �q�回指向��N��的逆向�q�代�?

20.rend() �q�回指向头部的逆向�q�代�?

21.resize() 改变双向队列的大��?

22.size() �q�回双向队列中元素的个数

23.swap() 和另一个双向队列交换元�?

   语法�Q?

      void swap( deque &target );// 交换target和现双向队列中元�?/span>

王�v�?/a> 2012-06-04 15:57 发表评论

c++ List(双向链表)

Mon, 04 Jun 2012 07:50:00 GMT
     摘要: List(双向链表)介绍:        List是一个线性链表结构，它的数据��p��q�个节点构成�Q�每一个节炚w��包括一个信息块�Q�即实际存储的数据）、一个前驱指针和一个后驱指针。它无需分配指定的内存大��且可以��L��伸羃�Q�这是因为它存储在非�q�箋的内存空间中�Q��ƈ且由指针��有序的元素链接��h��?    &nbs...  阅读全文

王�v�?/a> 2012-06-04 15:50 发表评论

Vector介绍

Mon, 04 Jun 2012 01:18:00 GMT

C++ Vector�Q�向量容器）

是一个线性顺序结构。相当于数组�Q�但其大��可以不预先指定�Q��ƈ且自动扩展。它可以像数�l�一栯��操作�Q�由于它的特性我们完全可以将vector 看作动态数�l��?

在创��Z��?/span>vector 后，它会自动在内存中分配一块连�l�的内存�I�间�q�行数据存储�Q�初始的�I�间大小可以预先指定也可以由vector 默认指定�Q�这个大��即capacity �Q�）函数的返回倹{��当存储的数据超�q�分配的�I�间时vector 会重新分配一块内存块�Q�但�q�样的分配是很耗时的，在重新分配空间时它会做这��L��动作�Q?

首先�Q�vector 会申请一块更大的内存块；

然后�Q�将原来的数据拷贝到新的内存块中�Q?

其次�Q�销毁掉原内存块中的对象�Q�调用对象的析构函数�Q�；

最后，��原来的内存�I�间释放掉�?

如果vector 保存的数据量很大�Ӟ��q�样的操作一定会��D��p�糕的性能�Q�这也是vector 被设计成比较�Ҏ��拯��的值类型的原因�Q�。所以说vector 不是在什么情况下性能都好�Q�只有在预先知道它大��的情况下vector 的性能才是最优的�?/span>

vector 的特点：

(1) 指定一块如同数�l�一��L��q�箋存储�Q�但�I�间可以动态扩展。即它可以像数组一��h��作，�q�且可以�q�行动态操作。通常体现�?/span>push_back() pop_back() �?

(2) 随机讉K��方便�Q�它像数�l�一栯��讉K��Q�即支持[ ] 操作�W�和vector.at()

(3) 节省�I�间�Q�因为它是连�l�存储，在存储数据的区域都是没有被浪费的�Q�但是要明确一�?/span>vector 大多情况下�ƈ不是满存的，在未存储的区域实际是��费的�?

(4) 在内部进行插入、删除操作效率非�怽��Q�这��L��操作基本上是被禁止的�?/span>Vector 被设计成只能在后端进行追加和删除操作�Q�其原因�?/span>vector 内部的实现是按照��序表的原理�?

(5) 只能�?/span>vector 的最后进�?/span>push �?/span>pop �Q�不能在vector 的头�q�行push �?/span>pop �?

(6) 当动态添加的数据��过vector 默认分配的大��时要进行内存的重新分配、拷贝与释放�Q�这个操作非常消耗性能�?所以要vector 辑ֈ�最优的性能�Q�最好在创徏vector 时就指定其空间大��?

Vectors 包含着一�p�d��q�箋存储的元�?/span>,其行为和数组�c�M��。访�?/span>Vector中的��L��元素或从末尾��d��元素都可以在帔R��U�时间复杂度内完成，而查扄��定值的元素所处的位置或是�?/span>Vector中插入元素则是线性时间复杂度�?/span>

1.Constructors 构造函�?

vector v1; //构造一个空的vector

vector v1( 5, 42 ); //构造了一个包�?个��gؓ42的元素的Vector

2.Operators 对vector�q�行赋值或比较

C++ Vectors能够使用标准�q�算�W? ==, !=, <=, >=, <, �?>.

要访问vector中的某特定位�|�的元素可以使用 [] 操作�W?

两个vectors被认为是相等�?如果:

1.它们��h��相同的容�?

2.所有相同位�|�的元素相等.

vectors之间大小的比较是按照词典规则.

3.assign() 对Vector中的元素赋�?

语法�Q?

void assign( input_iterator start, input_iterator end );

// ��区间[start, end)的元素赋到当前vector

void assign( size_type num, const TYPE &val );

// 赋num个��gؓval的元素到vector�?�q�个函数��会清除掉�ؓvector赋��g��前的内容�?/span>

4.at() �q�回指定位置的元�?

语法�Q?

TYPE at( size_type loc );//差不多等同v[i];但比v[i]安全;

5.back() �q�回最末一个元�?

6.begin() �q�回�W�一个元素的�q�代�?

7.capacity() �q�回vector所能容�U�的元素数量(在不重新分配内存的情况下�Q?

8.clear() 清空所有元�?

9.empty() 判断Vector是否为空�Q�返回true时�ؓ�I�）

10.end() �q�回最末元素的�q�代�?译注:实指向最末元素的下一个位�|?

11.erase() 删除指定元素

语法�Q?

iterator erase( iterator loc );//删除loc处的元素

iterator erase( iterator start, iterator end );//删除start和end之间的元�?/span>

12.front() �q�回�W�一个元素的引用

13.get_allocator() �q�回vector的内存分配器

14.insert() 插入元素到Vector�?

语法�Q?

iterator insert( iterator loc, const TYPE &val );

//在指定位�|�loc前插入��gؓval的元�?�q�回指向�q�个元素的�P代器,

void insert( iterator loc, size_type num, const TYPE &val );

//在指定位�|�loc前插入num个��gؓval的元�?

void insert( iterator loc, input_iterator start, input_iterator end );

//在指定位�|�loc前插入区间[start, end)的所有元�?

15.max_size() �q�回Vector所能容�U�_��素的最大数量（上限�Q?

16.pop_back() �U�除最后一个元�?

17.push_back() 在Vector最后添加一个元�?

18.rbegin() �q�回Vector��N��的逆�P代器

19.rend() �q�回Vector起始的逆�P代器

20.reserve() 讄��Vector最��的元素容纳数量

//为当前vector预留臛_��共容�U�size个元素的�I�间

21.resize() 改变Vector元素数量的大��?

语法:

void resize( size_type size, TYPE val );

//改变当前vector的大��ؓsize,且对新创建的元素赋值val

22.size() �q�回Vector元素数量的大��?

23.swap() 交换两个Vector

语法�Q?

void swap( vector &from );

Vector用法 �Q?/span>

1.声明�Q?

一个vector�c�M��于一个动态的一�l�数�l��?/span>

vector a; //声明一个元素�ؓint�c�d��的vector a

vectot a; //声明一个元素�ؓMyType�c�d��的vector a

�q�里的声明的a包含0个元素，既a.size()的��gؓ0�Q�但它是动态的�Q�其大小会随着数据的插入和删除改变而改变�?/span>

vector a(100, 0); //�q�里声明的是一个已�l�存放了100�?的整数vector

你可以用以下的几�U�方法声明一�?vector 对象�Q?/span>

vector v(5, 3.25); //初始化有5 个元素，其值都�?.25

vector v_new1(v);

vector v_new2 = v;

vector v_new3(v.begin(), v.end());

�q�四个vector 对象是相�{�的�Q�可以用operator==来判断�?/span>

2.向量操作

常用函数�Q?

size_t size(); // �q�回vector的大��，卛_��含的元素个数

void pop_back(); // 删除vector末尾的元素，vector大小相应减一

void push_back(); //用于在vector的末��添加元�?

T back(); // �q�回vector末尾的元�?

void clear(); // ��vector清空�Q�vector大小变�ؓ0

其他讉K��方式�Q?

cout<

cout<

以上区别在于后者在讉K��界时会抛出异常�Q�而前者不会�?/span>

3.遍历

(1). for(vector::iterator it=a.begin(); it!=a.end();it++)

cout<<*it<

(2). for(int i=0;i

cout<

现在惛_��到容器中能保存的最大元素数量就可以�?vector �cȝ��成员函数max_size()�Q?/span>

vector::size_type max_size = my_shapes.max_size();

当前容器的实际尺�?--- 已有的元素个数用size()�Q?/span>

vector::size_type size = my_shapes.size();

��像size_type 描述了vector ��寸的类型，value_type 说明了其中保存的对象的类型：

cout << “value type: “ << typeid(vector::value_type).name();

输出�Q?/span>

value type: float

可以用capacity()来取得vector 中已分配内存的元素个敎ͼ�

vector v;

vector::size_type capacity = v.capacity();

vector �c�M��于数�l�，可以使用下标[]讉K��Q?/span>

vector v(10);

v[0] = 101;

注意到这里预先给10 个元素分配了�I�间。你也可以��用vector 提供的插入函数来动态的�?/span>

展容器。成员函数push_back()��在vector 的尾部添加了一个元素：

v.push_back(3);

也可以用insert()函数完成同样的工作：

v.insert(v.end(), 3);

�q�里insert()成员函数需要两个参敎ͼ�一个指向容器中指定位置的�P代器(iterator)�Q�一个待�?/span>

入的元素。insert()��元素插入到�q�代器指定元素之前�?/span>

现在对�P代器(Iterator)做点解释。Iterator 是指�?pointer)的泛化，iterator 要求定义

operator*�Q�它�q�回指定�c�d��的倹{��Iterator 常常和容器联�p�d��一赗��例子：

vector v(3);

v[0] = 5;

v[1] = 2;

v[2] = 7;

vector::iterator first = v.begin();

vector::iterator last = v.end();

while (first != last)

cout << *first++ << “ “;

上面代码的输出是�Q?/span>

5 2 7

begin()�q�回的是vector 中第一个元素的iterator�Q�而end()�q�回的�ƈ不是最后一个元素的

iterator�Q�而是past the last element。在STL 中叫past-the-end iterator�?br />
�l�合查找
vector::iterator result = find( v.begin( ), v.end( ), 2 ); //查找2
if ( result == v.end( ) ) //没找�?/span>
        cout << "No" << endl;
else //扑ֈ�
        cout << "Yes" << endl;

王�v�?/a> 2012-06-04 09:18 发表评论

STL介绍

Mon, 04 Jun 2012 00:52:00 GMT

STL介绍
    C++ STL (Standard Template Library标准模板�?/span>) 是通用�c�L��板和��法的集合，它提供给�E�序员一些标准的数据�l�构的实现如 queues(队列), lists(链表), �?stacks(�?/span>)�{?/span>. 该库包含了诸多在计算�?a >�U�学领域里所常用的基本数据结构和基本��法。提供了一个可扩展的应用框�Ӟ��高度体现了��Y件的可复用性�?/span>

从逻辑层次来看�Q�在STL中体��C��泛型化程序设计的思想�Q�generic programming�Q�，引入了诸多新的名词，比如像需求（requirements�Q�，概念�Q�concept�Q�，模型�Q�model�Q�，容器�Q�container�Q�，��法�Q�algorithmn�Q�，�q�代子（iterator�Q�等。与OOP�Q�object-oriented programming�Q�中的多态（polymorphism�Q�一��P��泛型也是一�U��Y件的复用技术�?/span>

从实现层�ơ看�Q�整个STL是以一�U�类型参数化�Q�type parameterized�Q�的方式实现的，�q�种方式��Z��一个在早先C++标准中没有出现的语言�Ҏ�?-模板�Q�template�Q��?br />

C++ STL 提供�l�程序员以下三类数据�l�构的实�?/strong>�Q?

标准容器�c?br />

��序性容�?/strong>

   vector 从后面快速的插入与删除，直接讉K��M��元素

   deque 从前面或后面快速的插入与删除，直接讉K��M��元素

   list 双链表，从�Q何地方快速插入与删除

三者比较：
   vector 是一�D�连�l�的内存块，而deque 是多个连�l�的内存块， list 是所有数据元素分开保存�Q�可以是��M��两个元素没有�q�箋。vector 的查询性能最好，�q�且在末端增加数据也很好�Q�除非它重新甌��内存�D�；适合高效地随机存储。list 是一个链表，��M��一个元素都可以是不�q�箋的，但它都有两个指向上一元素和下一元素的指针。所以它�Ҏ��入、删除元素性能是最好的�Q�而查询性能非常差；适合大量地插入和删除操作而不兛_��随机存取的需求。deque 是介于两者之��_��它兼��了数组和链表的优点�Q�它是分块的链表和多个数�l�的联合。所以它有被list好的查询性能�Q�有被vector好的插入、删除性能�?如果你需要随卛_��取又兛_��两端数据的插入和删除�Q�那么deque是最佳之选�?br />

兌��容器

   set 快速查找，不允讔R��复�?

   multiset 快速查找，允许重复�?

   map 一对多映射�Q�基于关键字快速查找，不允讔R��复�?

   multimap 一对多映射�Q�基于关键字快速查找，允许重复�?br />
   兌��容器(Associative Container)提供了快速检索基于关键词(Key)的数据的能力。和序列容器(vector、list、deque)一��P��兌��容器用来存储数据�Q�而且设计兌��容器时考虑��C��优化数据��索的意图 --- 通过关键�?Key)作�ؓ标识把单一的数据记录组�l�到特定的结构中(如tree)。STL 提供了不同的兌��容器�Q�集�?set)、多元集�?multiset)、映��?map)、多元映��?multimap)。set 和map 支持唯一关键�?unique key)�Q�就是对每个KEY�Q�最多只保存一个元�?数据
记录)。multiset 和multimap 则支持相同关键词(equal key)�Q�这样可有很多个元素可以用同一个KEY �q�行存储。set(multiset)和map(multimap)之间的区别在于set(multiset)中的存储数据内含了KEY 表达式；而map(multimap)则将Key 表达式和对应的数据分开存放�?/span>

容器适配�?/strong>

   stack 后进先出

   queue 先进先出

   priority_queue 最高优先��元素��L��W�一个出�?br />
   STL 中包含三�U�适配器：栈stack 、队列queue 和优先��priority_queue 。适配器是容器的接口，它本�w�不能直接保存元素，它保存元素的机制是调用另一�U�顺序容器去实现�Q�即可以把适配器看�?#8220;它保存一个容器，�q�个容器再保存所有元�?#8221;�?br />   STL 中提供的三种适配器可以由某一�U�顺序容器去实现。默认下stack 和queue ��Z��deque 容器实现�Q�priority_queue 则基于vector 容器实现。当然在创徏一个适配器时也可以指定具体的实现容器�Q�创建适配器时在第二个参数上指定具体的��序容器可以覆盖适配器的默认实现。由于适配器的特点�Q�一个适配器不是可以由��M��个顺序容器都可以实现的�?br />   栈stack 的特�Ҏ��后进先出�Q�所以它兌��的基本容器可以是��L��一�U�顺序容器，因�ؓ�q�些容器�c�d��l�构都可以提供栈的操作有求，它们都提供了push_back 、pop_back 和back 操作�?br />   队列queue 的特�Ҏ��先进先出�Q�适配器要求其兌��的基��容器必须提供pop_front 操作�Q�因此其不能建立在vector 容器上�?/span>

王�v�?/a> 2012-06-04 08:52 发表评论

国产欧美一区二区三区另类精品,国产一区白浆,国产精品美女主播在线观看纯欲

STL�q�代器及�ȝ��

C++ Queues(队列)、Priority Queues(优先队列)

C++ Stacks�Q�堆栈）

C++ Sets & MultiSets

STL Set 交集 合集 差集

C++ Maps & MultiMaps

C++ Deque(双向队列)

c++ List(双向链表)

Vector介绍

STL介绍

STL Set 交集合集差集