精华内容
下载资源
问答
  • 说明:本文转自... STL实践与分析 --顺序容器的定义、迭代器 一、顺序容器的定义 顺序容器 容器适配器 vector 支持快速

    说明:本文转自http://blog.csdn.net/zjf280441589/article/details/23903481

    STL实践与分析

    --顺序容器的定义、迭代器



    一、顺序容器的定义

    顺序容器


    容器适配器


    vector

    支持快速随机访问

    stack

    后进先出(LIFO)

    list

    支持快速插入/删除

    queue

    先进先出(FIFO)

    deque

    双端队列

    priority_queue

    有优先级管理的队列


    1、容器类型的操作集合形成了以下层次结构:

        1)一些操作适用于所有容器类型;

        2)另外一些操作只适用于顺序或关联容器;

        3)还有一些操作只适用于顺序或关联容器类型的一个子集。


    2、容器构造函数

    C<T>c;

    创建一个名为c的空容器。C是容器类型名,vector,T是元素类型,intstring适用于所有容器

    Cc(c2);

    创建容器c2的副本c;cc2必须具有相同的容器类型,并存放相同类型的元素。适用于所有容器。

    Cc(b,e);

    创建c,其元素是迭代器be标示的范围内元素的副本。

    适用于所有容器

    Cc(n, t);

    n个值为t的元素创建容器c,其中值t必须是容器类型C的元素类型的值,或者是可转换为该类型的值。

    只适用于顺序容器

    Cc(n);


    创建有n个值初始化元素的容器c

    只适用于顺序容器



    3、将一个容器初始化为另一个容器的副本

        将一个容器复制给另一个容器时,类型必须匹配:容器类型和元素类型都必须完全相同。

    1. vector<int> ivec;  
    2. vector<int> ivec2(ivec);  //OK  
    3. vector<double> dvec(ivec);    //Error  
    4. list<int> ilist(ivec);        //Error  

    4、初始化为一段元素的副本

        系统允许通过一对迭代器间接实现不同种容器之间进行复制:使用迭代器时,不要求容器类型相同,容器内元素类型也可以不相同,只要他们相互兼容,能够将要复制的元素转换为所构建的新容器的元素类型,即可实现复制。

    1. vector<string> svec;  
    2. //...  
    3. list<string> slist(svec.begin(),svec.end());  //OK  
    4.   
    5. vector<string>::iterator mid = svec.begin() + svec.size()/2;  
    6. deque<string> front(svec.begin(),mid);            //OK  
    7. deque<string> back(mid,svec.end());               //OK  
    8.   
    9. char *word[] = {"stately","plump","buck","mulligan"};  
    10. list<string> slist2(word,word + sizeof(word)/sizeof(*word));  //OK  
    11.   
    12. vector<int> ivec;  
    13. //...  
    14. vector<double> dvec(ivec.begin(),ivec.end()); //OK  

    5、分配和初始化指定数目的元素

        不提供元素初始化式时,标准库将为该容器实现值初始化,采用这种类型的初始化,元素类型必须是内置或复合类型,或者是提供了默认构造函数的类类型。如果元素类型没有默认构造函数,则必须显式的指定其元素初始化式。

        接受容器大小做形参的构造函数只适用于顺序容器,而关联容器不支持这种初始化。

    1. const list<int>::size_type list_size = 64;  
    2. list<int> ilist(list_size);       //OK  
    3. list<string> slist(list_size);    //OK  
    4.   
    5.        list<string> strList(list_size,"Ha~"); //OK  

    1. //P267 习题9.2  
    2.     vector<string> strVec1;  
    3.     vector<string> strVec2(strVec1);  
    4.     vector<string> strVec3(strVec2.begin(),strVec2.end());  
    5.     vector<string> strVec4(strVec3.size());  
    6.     vector<string> strVec5(strVec4.size(),"ANS");  

    6、容器内元素的约束

        C++语言中,大多数类型都可用作容器的元素类型。容器元素类型必须满足

    以下两个约束:

        •元素类型必须支持赋值运算。

        •元素类型的对象必须可以复制。

    容器操作的特殊要求

        支持复制和赋值功能是容器元素类型的最低要求。此外,一些容器操作对元素类型还有特殊要求。如果元素类型不支持这些特殊要求,则相关的容器操作就不能执行:我们可以定义该类型的容器,但不能使用某些特定的操作。

    1. class Foo  
    2. {  
    3. public:  
    4.     Foo(int x)  
    5.     {  
    6.   
    7.     }  
    8. };  
    9.   
    10. int main()  
    11. {  
    12.     vector<Foo> empty;        //OK  
    13.     vector<Foo> bad(10);  //Error  
    14.     vector<Foo> ok(10,1); //OK  
    15. }  

    有在同时指定每个元素的初始化式时,才能使用给定容器大小的构造函数来创建同类型的容器对象。


    7、容器的容器

        因为容器受容器类型的约束,所以可定义元素是容器的容器:

    1. vector< vector<string> > vvec;  

    【注意:】

         在指定容器元素为容器类型时,必须如下使用空格:

    1. vector< vector<string> > vvec;      //OK  
    2. vector< vector<string>> bad_vvec;   //Error  

    1. //P268 习题9.4  
    2.     list< deque<int> > dList;  

    1. //习题9.6  
    2. class Foo  
    3. {  
    4. public:  
    5.     Foo(int x)  
    6.     {  
    7.   
    8.     }  
    9. };  
    10.   
    11. int main()  
    12. {  
    13.     list<Foo> FList(10,1);  
    14. }  

    二、迭代器和迭代器范围

    所有标准库都提供的迭代器运算

    *iter

    返回迭代器iter所指向的元素的引用

    iter-> mem

    iter进行解引用,获取指定元素中名为mem的成员。等效于(*iter).mem

    ++iter/iter++

    iter1,使其指向容器里的下一个元素

    --iter/iter--

    iter1,使其指向容器里的前一个元素

    iter1== iter2

    iter1!= iter2

    比较两个迭代器是否相等(或不等)。当两个迭代器指向同一个iter2容器中的同一个元素,或者当它们都指向同一个容器的超出末端iter1!=的下一位置时,两个迭代器相等.



                                                                                                      vectordeque类型迭代器支持的操作

    iter+ n

    iter- n

    在迭代器上加()整数值n,将产生指向容器中前面(后面)n个元素的迭代器。新计算出来的迭代器必须指向容器中的元素或超出容器末端的下一位置

    iter1+= iter2

    iter1-= iter2

    这里迭代器加减法的复合赋值运算:iter1加上或减去iter2的运算结果赋给iter1

    iter1- iter2

    两个迭代器的减法,其运算结果加上右边的迭代器即得左边的迭代器。这两个迭代器必须指向同一个容器中的元素或超出容器末端的下一位置

    只适用于vectordeque容器

    >,>=,<,<=

    迭代器的关系操作符。当一个迭代器指向的元素在容器中位于另一个迭代器指向的元素之前,则前一个迭代器小于后一个迭代器。关系操作符的两个迭代器必须指向同一个容器中的元素或超出容器末端的下一位置

    只适用于vectordeque容器


    关系操作符只适用于vectordeque容器,因为只有这两种容器为其元素提供快速、随机的访问。

    1. vector<int> ivec;  
    2. //...  
    3. vector<int>::iterator mid = ivec.begin() + ivec.size()/2; //OK  
    4.   
    5. list<int> ilist(ivec.begin(),ivec.end());  
    6. list<int>::iterator iter = ilist.begin() + ilist.size()/2;    //Error  
    7. list<int>::iterator iter1 = ilist.begin(),  
    8.                     iter2 = ilist.end();  
    9. if (iter1 < iter2)   //Error  
    10. {  
    11.     //...  
    12. }  

        list容器的迭代器既不支持算术运算符,也不支持关系运算符,它只是提供前置/后置的自增、自减运算以及相等/不等运算。

    1. //P270 习题9.9  
    2. int main()  
    3. {  
    4.     list<int> iList;  
    5.     for (size_t i = 0; i != 15; ++i)  
    6.     {  
    7.         iList.push_back(i+1);  
    8.     }  
    9.     for (list<int>::iterator iter = iList.end(); iter != iList.begin();)  
    10.     {  
    11.         cout << *(--iter) << endl;  
    12.     }  
    13. }  

    1、对形成迭代器范围的迭代器的要求

    迭代器 firstlast如果满足以下条件,则可形成一个迭代器范围:

        •它们指向同一个容器中的元素或超出末端的下一位置。

        •如果这两个迭代器不相等,则对first反复做自增运算必须能够到达last。换句话说,在容器中,last绝对不能位于first之 前。【P270,编译器自己也不能保证上述要求】


    2、使用左闭右开区间的意义

        1)当firstlast相等,迭代器范围为空

        2)当firstlast不相等时,迭代器范围内至少有一个元素:size= last – fist

    1. //P271 习题9.12  
    2. bool findVal(vector<int>::const_iterator beg,vector<int>::const_iterator end,int val)  
    3. {  
    4.     while (beg != end)  
    5.     {  
    6.         if (*beg == val)  
    7.         {  
    8.             return true;  
    9.         }  
    10.         ++ beg;  
    11.     }  
    12.     return false;  
    13. }  
    14.   
    15. int main()  
    16. {  
    17.     vector<int> ivec;  
    18.     for (int i = 0;i != 20; ++i)  
    19.     {  
    20.         ivec.push_back(i);  
    21.     }  
    22.     vector<int>::const_iterator mid = ivec.begin() + ivec.size()/2;  
    23.     cout << findVal(ivec.begin(),ivec.end(),10) << endl;  
    24.     cout << findVal(ivec.begin(),mid,10) << endl;  
    25. }  

    1. //习题9.13  
    2. vector<int>::const_iterator findVal(vector<int>::const_iterator beg,  
    3.                                     vector<int>::const_iterator end,  
    4.                                     int val)  
    5. {  
    6.     while (beg != end)  
    7.     {  
    8.         if (*beg == val)  
    9.         {  
    10.             return beg;  
    11.         }  
    12.         ++ beg;  
    13.     }  
    14.     return beg;  
    15. }  

    1. //习题9.14  
    2. int main()  
    3. {  
    4. //  freopen("input","r",stdin);  
    5.     vector<string> strVec;  
    6.     string val;  
    7.     while (cin >> val)  
    8.     {  
    9.         strVec.push_back(val);  
    10.     }  
    11.     for (vector<string>::iterator iter = strVec.begin(); iter != strVec.end(); ++iter)  
    12.     {  
    13.         cout << *iter << endl;  
    14.     }  
    15. }  

    1. //习题9.15  
    2. int main()  
    3. {  
    4. //  freopen("input","r",stdin);  
    5.     list<string> strVec;  //修改vector -> list  
    6.     string val;  
    7.     while (cin >> val)  
    8.     {  
    9.         strVec.push_back(val);  
    10.     }  
    11.     //修改vector -> list  
    12.     for (list<string>::iterator iter = strVec.begin(); iter != strVec.end(); ++iter)  
    13.     {  
    14.         cout << *iter << endl;  
    15.     }  
    16. }   

    3、使迭代器失效的容器操作

        一些容器的操作会修改容器的内在状态或移动容器内的元素这样的操作使所有指向被移动的元素的迭代器失效,也可能同时使其他迭代器失效。使用无效迭代器是没有定义的,可能会导致与悬垂指针相同的问题。使用无效迭代器将会导致严重的运行时错误。

        无法检查迭代器是否有效,也无法通过测试来发现迭代器是否已经失效。任何无效迭代器的使用都可能导致运行时错误,但程序不一定会崩溃,否则检查这种错误也许会容易些o(∩∩)o...

    【建议:】

        使用迭代器时,通常可以编写程序使得要求迭代器有效的代码范围相对较短。 然后,在该范围内,严格检查每一条语句,判断是否有元素添加或删除,从而相应地调整迭代器的值

    展开全文
  • 容器的定义和初始化 C c; 默认构造函数,如果C是一个array,则c中元素按默认方式初始化,否则c为空; C c1(c2); c1位c2的一个拷贝,c1和c2的容器类型必须相同,而且保存的是相同的类型, C c1=c2; ...

    顺序容器属于C++ STL的一部分,也是非常重要的一部分。

    顺序容器包括:

    std::vector,包含在头文件<vector>中

    std::string, 包含在头文件<string>中

    std::deque,包含在头文件<deque>中

    std::list,包含在头文件<list>中

    std::forward_list,包含在头文件<forward_list>中

    std::array, 包含在头文件<array>中


    顺序容器几乎可以保存任意类型的元素,我们可以定义一个容器,其元素类型可以是另一个容器。顺序容器的构造函数的一个版本接受容器大小的参数,它使用了元素类型的默认构造函数,但有些类没有构造函数,我们可以定义一个保存这种类型对象的容器,但我们在构造这种容器时不能只传递给它一个元素数目的参数,必须提供一个元素初始化器。


    迭代器

    迭代器支持的操作有:*iter,iter->mem,++iter,--iter, iter1 == iter2, iter1 != iter2

    另外,forward_list::iterator 不支持递减--操作。

    另外,string、vector、deque、array的迭代器支持这些算数运算符:

    iter + n, iter - n, iter += n, iter -= n, iter1 - iter2, >、>=、<、<=


    迭代器的范围是 [begin, end),首迭代器和尾后迭代器。



    容器的定义和初始化

    C c;   默认构造函数,如果C是一个array,则c中元素按默认方式初始化,否则c为空;

    C c1(c2);  c1位c2的一个拷贝,c1和c2的容器类型必须相同,而且保存的是相同的类型,

    C c1=c2;    如果C是array,它们的大小必须相同;

    C c{a,b,c,...};  c初始化为初始化列表的中元素,列表中的元素必须与c的元素类型相容。

    C c={a,b,c,...};  对于array类型,列表中的元素个数必须等于或小于array的大小,如果小于,array剩余的元素进行值初始化

    C c(b, e);  c初始化为迭代器b到e(不包括e)之间的元素,迭代器所指向的元素必须与c中元素类型相容

    只有顺序容器(不包括array)的构造函数才接受大小参数

    C seq(n);    seq包含了n个元素,这些元素都进行了值初始化,此构造函数时explicit的

    C seq(n,t);  seq包含n个值为 t 的元素


    将一个容器拷贝为另一个容器时,两个容器的类型和保存的类型必须匹配,当array进行拷贝时,它的大小还必须相等;

    不过,当使用迭代器参数来拷贝元素时,就不要求两个容器必须是同一种容器了,只要两者保存的元素类型能相容就行。


    array的定义和初始化:

    定义一个array时,需要制定元素类型和大小。

    列表初始化array时,列表中的元素个数不能超过array大小,如果个数小于array大小,将初始化array靠前的元素,剩下的进行值初始化,如果array保存的类型时类类型,则该类必须有一个默认构造函数,以便值初始化能够进行。



    赋值和swap


    c1 = c2;// 将c1的内容替换为c2中元素的拷贝

    c1 = {a, b, c};// 赋值后, c1的大小为3

    array也可以整体赋值,这正是array与内置数组的不同之处; array在赋值时,赋值符号左右两边的对象必须具有相同的类型。

        array<int, 5> a1 = {1, 2, 3, 4, 5};
        array<int, 5> a2 = {6, 7, 8, 9, 10};
        a1 = a2; // a1中元素将替换为a2中元素的拷贝

        但不能将一个花括号列表赋值数组:

        a2 = {0}; // error


    容器的赋值运算有如下几种:

        c1 = c2;
        c  = {a, b, c};
        swap(c1, c2); 将c1中元素替换为c2中的元素,c1和c2必须具有相同的类型
        c1.swap(c2);  swap通常比从c2向c1拷贝元素快的多。
     
        // assign操作不适用于关联容器和array
        seq.assign(b, e); 	        将seq中元素替换为迭代器b和e所指向的范围之内的元素,但是b和e不能指向seq
        seq.assign(il);     	将seq中元素替换为初始化列表il中的元素</span>
        seq.assign(n, val);         将seq中元素替换为n个值为val的元素</span>

    赋值相关运算会导致指向左边容器内部的迭代器、引用和指针失效。而swap操作将容器内容交换不会导致失效。(array和string的情况除外)


    使用swap

    swap操作的是两个相同类型容器的内容。除array外,交换两个容器内部的操作保证会很快,元素本身并未交换,swap只是交换了两个容器内部的数据结构。

    元素不会被移动,这意味着,string除外,指向容器的迭代器、引用和指针在swap操作后不会失效。但在swap之后,这些元素已经属于不同的容器了。例如有两个容器vec1和vec2,假定iter1在swap前指向vec1[3], 在swap之后它指向vec2[3]。  但是,对一个string调用swap会导致迭代器、引用和指针失效。

    swap两个array会真正的交换他们的元素,所以交换array所需要的时间和array的元素数目成正比。

    新的标准库中,容器既提供成员函数版本的swap,也提供非成员函数版本的swap,我们应该习惯使用非成员版本的swap。


    容器大小操作

    每个容器类型都支持相等运算符 == 和 != ; 除了无需关联容器外,所有容器都支持关系运算符 >、>=、<、<= 。关系运算符左右两边的对象必须是相同类型的容器,且必须保存相同类型的元素。

    实际上,容器进行比较时,使用的是元素的关系运算符完成比较,因此,只有当容器储存的元素类型定义了相应的关系运算符时,我们才可以进行关系比较!



    展开全文
  • 1)首先发表一下感概,看了一些顶层容器的实现过程,发现这些东西有着千丝万缕的联系,例如顺序中加载这一些容器适配器,在SGI中,Alloator这个底层的适配器算是最好的供应者。 2)模板定义之vector template > ...


    1)首先发表一下感概,看了一些顶层容器的实现过程,发现这些东西有着千丝万缕的联系,例如顺序中加载这一些容器适配器,在SGI中,Alloator这个底层的适配器算是最好的供应者。

    2)模板定义之vector

    template<class_Ty, class _A = allocator<_Ty> >

    classvector {……} //VC源代码中截取了一部分模板定义

    vector定义在<vector>的头文件中,在VS中的路径(默认情况下C:\ProgramFiles (x86)\Microsoft VisualStudio\VC98\Include),这个模板定义了两个参数类型,一个参数_Ty是保存的元素的类型,另一个参数为分配器(allocator).allocator指定了内存分配对象的类型,现在有个默认的底层allocator,当然用户可以自定义。(我们通过查看源代码可以看见在一些函数中也时可用到了allocation,例如vector构造函数,内存申请和释放的时候,通常会调用allocator

    Vector中主要方法:

    4个构造函数1个析构函数

    赋值运算符=reverse()capacity(),两种begin(const和非const),两种end,两种rbegin,两种rendresize(),insert(), erase(), clear(), at(), push_back(), pop_back()等等。


    3)模板定义之list

    template<class_Ty, class _A = allocator<_Ty> >

    classlist {….} VC源代码中截取了一部分模板定义

    第一个参数表示保留的数据类型,第二个则是适配器。

    STIlist定义在<list>头文件中,是一个标准的双向链表。具备前移和后移的能力。但是list不能像vector那样提供随机的访问,所以list迭代器之间不能进行加减操作和其他的指针运算。List中提供随机访问的只有front()back()方法,其他的数据的访问都必须通过迭代器。

    主要方法:

    5个构造,一个析构,begin(),end(), 5insert(),push_back(), pop_back(), push_front(), pop_front(), 2种形式的erase()clear().


    3)模板定义之deque

    template<class_Ty, class _A = allocator<_Ty> >

    classdeque {…} //VC源代码中截取了一部分模板定义

    这个不是经常使用,而是习惯性作为容器适配器的底层适配器。

    Deque在头文件<deque>中,Deque是一种双向开口的连续线性空间。可以在头尾两端分别做元素的插入和删除操作。Dequevector的最大差异,一在于deque允许常数时间内对起头端进行元素的插入或者移除操作。二是deque没有所谓的容量,也的确是,它的内存管理和构造和vector完全不同。

    主要方法:

    4个构造,1个析构,有begin(),end(), operator[], front, back(), size(), max_size(), empty(),push_back(), pop_back(), push_front(), pop_front(), find()



    4)模板定义之array

    VS2008中没有array这个头文件,在C++11标准后,才有这个文件,没有看到源码,只是简单的将方法列出来。

    这个类基本上和vector类似,只是它的大小是固定的,array的大小不能增加或者收缩,array支持随机访问迭代器,元素都保存在连续的内存单元。

    支持的方法:

    front(),back(), at(), operator[], fill(),不支持push_back(),pop_back(), clear(), resize(), capacity()等等


    适配器:

    适配器没有提供迭代功能,也没有提供同时插入或者删除多个元素的能力。


    5)模板定义之queue

    template<class_Ty, class _C = deque<_Ty> >

    classqueue {…} VC源代码中截取了一部分模板定义

    queue容器适配器定义在头文件<queue>中,queue提供了标准的先入先出语义,

    _Ty参数保存了queue中的类型,第二个参数指定了queue适配器的底层容器,不过,由于queue要求顺序容器同时支持push_bcak()pop_back()这两个操作,所以只有listdeque符合底层适配器。

    Queue支持的方法:

    Size(),front(), pop(), push(),源代码也比较简单(没有考虑适配器的情况下)


    6)模板定义之stack

    template<class_Ty, class _C = deque<_Ty> >

    classstack {…} // vc的部分源代码

    stack在头文件<stack>中,stack是一种先进先出的数据结构,它只有一个出口,stack允许新增加元素,移出元素,取得元素最顶端。(没有其他办法取得其他元素)。可以看出这个类模板的参数类型也是使用底层的deque容器。

    主要方法:

    empty(), size(),两种top(), push() , pop()各类比较方法。

    7)模板定义之priority_queue

    此类使用和queue基本差不多,就是多了一个优先级的区别。


    8)模板定义之bitset

    template<size_t_N>

    classbitset {….} //这个算是最简单的模板定义了 简单了设置了一个数值型的数字


    bitset在头文件<bitset>中,默认的初始化为0.

    它的主要方法有:

    Set(), reset(), flip(), operator[], test(),

    现在简单的给出一个编程实例:(原来自己没有用过的类)

    #include"stdafx.h"

    #include<bitset>

    #include<iostream>

    usingnamespacestd;


    int_tmain(intargc,_TCHAR*argv[])

    {

    bitset<10>bit;

    bit.set(1);

    bit.set(3);

    bit[5]=true;

    bit[7]=bit[1];

    cout<<bit<<endl;//从右往左数的


    //bitset还实现了比较牛逼的功能| & ^ ~ >> << &= |= ^= <<= >>=等符号的重载


    bitset<10>bit1;

    bit1.set(1);

    bit1.set(3);

    bit1.set(7);

    bit[4]=true;

    cout<<bit1<<endl;//从右往左数的


    bit&=bit1;

    cout<<bit<<endl;

    getchar();

    return0;

    }



    到此,顺序容器和容器适配器的简单模板定义介绍达此。

    欢迎加入Jack_Li的金融交易-知识星球,这里有高大上的金融业务学习和编程知识学习,让你掌握时下最火爆的两门top行业信息,在这里你可以获得Jack_Li的经验,获得Jack_Li同学的内部推荐(证券公司,基金公司,大型金融机构等,入圈5天后发布),欢迎加入(请扫二维码):




    展开全文
  • c++顺序容器定义和初始化

    千次阅读 2015-04-15 18:54:23
    一、顺序容器的定义  容器是容纳特定类型对象的集合。这种容器根据位置来存储和访问元素。就是顺序容器 二、容器适配器  根据原始的容器类型所提供的操作,通过定义新的操作接口,来适应基础的容器类型 三...
    一、顺序容器的定义
            容器是容纳特定类型对象的集合。这种容器根据位置来存储和访问元素。就是顺序容器

    二、容器适配器
       根据原始的容器类型所提供的操作,通过定义新的操作接口,来适应基础的容器类型

    三、顺序容器的类型和容器适配器

    顺序容器

     

    容器适配器

     

    vector

    支持快速随机访问

    stack

    后进先出(LIFO)

    list

    支持快速插入/删除

    queue

    先进先出(FIFO)

    deque

    双端队列

    priority_queue

    有优先级管理的队列


    四、容器的定义
        所有的容器都是类模板,要定义一种特殊的容器,必须实例化
        vector<string> vs;
        list<int> li;
        deque<float> df;
    五、容器的构造函数
     

    C<T> c;

    创建一个名为c的空容器。C是容器类型名,如vector,T是元素类型,如int或string适用于所有容器

    C c(c2);

    创建容器c2的副本c;c和c2必须具有相同的容器类型,并存放相同类型的元素。适用于所有容器。

    C c(b,e);

    创建c,其元素是迭代器b和e标示的范围内元素的副本。

    适用于所有容器

    C c(n, t);

    用n个值为t的元素创建容器c,其中值t必须是容器类型C的元素类型的值,或者是可转换为该类型的值。

    只适用于顺序容器

    C c(n);

    创建有n个值初始化元素的容器c

    只适用于顺序容器

    注意事项:
        1、将一个容器初始化给另一个容器的副本
        要求:容器类型和元素类型必须相同
        2、初始化一段元素的副本
        系统允许通过传递一对迭代器间接实现将一种容器内的元素赋值给另一种容器
        不要求类型相同和大小相同
        vector<string> vs;
        list<int> li;
        deque<float> df;
    
        list<string> tls(vs.begin(),vs.end());
    
        deque<float>::iterator mid = df.begin()+df.size()/2;
    
        list<string> lst(mid,df.end());

        3、分配和初始化指定书目的元素
        创建容器时,可以显式指定容器的大小和一个可选的初始值
    const list<int>::size_type list_size = 100;
    list<string> slist(list_size,"hhh");

        4、不提供元素初始值时,标准库将为该容器实现值初始化。但这种初始化有限制,元素的类型必须是内置或复合类型,或者提供了默认构造函数的类类型。如果没有默认构造函数,必须显式的指定其元素初始化值
        5、只有顺序容器接受容器大小做形参的构造函数
        6、c++语言容器的元素类型
            必须支持赋值运算 
            元素类型的对象必须可以复制
        7、容器的容器
      vector<vector<int>> lines;
    六、迭代器的运算

    所有标准库都提供的迭代器运算

    *iter

    返回迭代器iter所指向的元素的引用

    iter-> mem

    对iter进行解引用,获取指定元素中名为mem的成员。等效于(*iter).mem

    ++iter/iter++

    给iter加1,使其指向容器里的下一个元素

    --iter/iter--

    给iter减1,使其指向容器里的前一个元素

    iter1== iter2

    iter1!= iter2

    比较两个迭代器是否相等(或不等)。当两个迭代器指向同一个iter2容器中的同一个元素,或者当它们都指向同一个容器的超出末端iter1!=的下一位置时,两个迭代器相等.



    展开全文
  • 简介先看 9.5节 三种顺序容器的区别 我们已经使用过三种容器定义的类型:size_type、iterator、const_iterator.所有容器都定义这三种类型,还定义了以下的类型。 - ==============================================...
  • 定义容器模板头文件

    千次阅读 2011-11-12 21:55:59
    定义容器模板头文件 头文件 描述 定义 vector 序列模板,这是一个大小可以重新设置数组类型,比普 通数组更安全、更灵活 定义 list 序列模板,这是一个序列链表,常常在任意位置插入和删除 元素 ...
  • Outlines: Review : Spring IoC容器中如何定义Bean ...Content: Spring IoC容器中如何定义 Bean依赖注入 手动注入 2-1) 通过属性property定义Beansetter依赖注入  通过属性contruct-arg定义Beancon
  • 有序容器自主定义排序器

    千次阅读 2014-08-07 20:58:52
    2.如果存储不是直接对象话比如对象指针(通常为智能指针),这个时候我们就要定义自己比较器。而比较器写法一般有两种。  ->1.类内重载函数调用运算符方法。  ->2.以函数方式提供比较器。 对于第...
  • Kubernetes 1.5 实践 给Pod中的容器定义命令和参数defining a Command and Arguments for a Container 给容器定义一个命令和参数。This page shows how to define commands and arguments when you run a container...
  • 容器的定义 容器,字面上理解就是装东西的东西。常见的变量、对象属性等都可以算是容器。一个容器能够装什么,全部取决于你对该容器的定义。当然,有这样一种容器,它存放的不是文本、数值,而是对象、对象的描述...
  • Spring中bean的定义可以通过编程,可以定义在properties文件,也可以定义在通过xml文件中,用的最多的是通过xml形式,由于xml格式具有很好的自说明便于编写及维护。对于xml的文档结构、数据定义及格式验证可以通过...
  • 容器技术是最快被数据中心所广泛接受和采用技术之一,从2013年起,据统计Docker下载量已经快达到30亿次,容器已经彻底改变了应用部署方式,但是IT基础设施管理却没有及时跟上。
  • Docker Compose是一个用来定义和运行多个docker容器的工具。一个使用Docker容器的应用,通常由多个容器组成。使用Docker Compose不再需要使用shell脚本来启动容器。 Compose 通过一个配置文件来管理多个Docker容器,...
  • Q:在W3C标准定义的阻止事件向父容器传递方法 A: e.stopImmediatePropagation() DOM中事件对象:(符合W3C标准) preventDefault() 取消事件默认行为 stopImmediatePropagation() 取消事件冒泡同时...
  • C++ STL中容器的使用全面总结

    万次阅读 多人点赞 2017-04-19 21:44:17
    一、容器的定义  在数据存储上,有一种对象类型,它可以持有其它对象或指向其它对像的指针,这种对象类型就叫做容器。很简单,容器就是保存其它对象的对象,当然这是一个朴素的理解,这种“对象”还包含了一系列...
  • #include #include #include"stdio.h" using namespace std; using namespace cv; int main() { vector vp2f; vp2f.push_back(Point2f(2, 3)); cout 【二维点向量】" ; vector vp3f(20);
  • 在上篇中,我们已经介绍了容器如何改变应用部署方式、为什么要通过CDS实现数据中心"轻量化"。那今天我们就来分析一下基于容器的Portworx存储、一个基于数据和控制面的容器定义存储技术和产品。
  • 在分析Spring IOC容器启动流程时候,在加载Bean定义信息BeanDefinition时候,用到了两个非常关键类:AnnotatedBeanDefinitionReader和ClassPathBeanDefinitionScanner。它俩完成对Bean信息加载。 因此为了...
  • 想要定义一个静态容器成员变量,保存数据以便后面共享。 1.要现在.h文件类内先声明该成员 class A{   public:  static const int vecSize = COMM_NUMBERS; //整形静态常量可以直接初始化  static ...
  • 容器定义存储(CDS)—"Portworx

    千次阅读 2016-12-15 01:20:17
    今天我们就来分析一下基于容器的Portworx存储、一个基于数据和控制面的容器定义存储技术和产品。 Portworx是一家美国存储初创公司,它研发了业界第一个容器定义存储系统Portworx。Portworx提供了全新的、统一的...

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 38,500
精华内容 15,400
关键字:

容器的定义