一、容器

一开始理解容器的时候，可以把容器看成库，都是提供一系列特定功能的。

二、常见的容器

STL标准模板库的分类：

    顺序容器：
            vector: 向量容器
            list  ：列表容器
            deque : 双端队列容器
    
    关联容器：查询一个元素是否存在，并且有效的获取该元素数据。
            map(映射)
            set(集合)
    
    哈希容器：
            unordered_set      哈希集合
            unordered_multiset 哈希多重集合
            unordered_map      哈希映射
            unordered_multimap 哈希多重映射

三、关于vector容器的自我生长特性

当我们定义一个vector对象输出其长度和容量时发现为：0，0；
而在我们添加元素超过一定的个数时，输出其容量发现，容量变大了。这就体现了vector的自我生长。（使用size和capacity可获取长度和容量）
具体实例如下所示：

#include <vector>
#include <iostream>
using namespace std;

int main()
{
    //定义一个vector对象
    vector< int > ivec;

    //在输出添加新的元素之前，输出元素vector对象的长度和大小
    cout << "ivec: size: " << ivec.size()
    << " capacity: " << ivec.capacity() << endl;
    
    //往容器对象中添加多次元素，查看长度和容量
    for ( int ix = 0; ix < 24; ++ix ) {
    ivec.push_back( ix );
    cout << "ivec: size: " << ivec.size()
    << " capacity: " << ivec.capacity() << endl;
    }
}

运行结果：

ivec: size: 0 capacity: 0
ivec: size: 1 capacity: 1
ivec: size: 2 capacity: 2
ivec: size: 3 capacity: 4
ivec: size: 4 capacity: 4
ivec: size: 5 capacity: 8
ivec: size: 6 capacity: 8
ivec: size: 7 capacity: 8
ivec: size: 8 capacity: 8
ivec: size: 9 capacity: 16
ivec: size: 10 capacity: 16
ivec: size: 11 capacity: 16
ivec: size: 12 capacity: 16
ivec: size: 13 capacity: 16
ivec: size: 14 capacity: 16
ivec: size: 15 capacity: 16
ivec: size: 16 capacity: 16
ivec: size: 17 capacity: 32
ivec: size: 18 capacity: 32
ivec: size: 19 capacity: 32
ivec: size: 20 capacity: 32
ivec: size: 21 capacity: 32
ivec: size: 22 capacity: 32
ivec: size: 23 capacity: 32
ivec: size: 24 capacity: 32

以上体现了容量按8字节自我生长的特点，具体生长特点由平台确定！

在使用vector，每次申请释放内存时，申请需要为每个元素调用拷贝构造函数，释放需要每个元素调用析构函数。
vector的动态自我增长频繁，则插入元素的开销就越大。

解决方法：

① 当vector开销很大时，可换成list容器
② 通过指针间接存储复杂类的对象。指向类的指针的拷贝和释放不需要调用给类的拷贝构造函数和析构函数！

三、顺序容器vector于list的基本使用

① 定义容器对象的基本方式

1）定义对象不确定容量
2）定义对象并且确定容量
3）定义对象并且确定长度同时初始化

② 定义对象，不确定容量,我们可以直接定义向量容器和列表容器的对象。如下所示：在没有确定对象的长度，那么长度为0，也就是空的。

	#include <iostream>
	#include <vector>
	#include <list>
	#include <string>
	using namespace std;
	
	int main()
	{
	    //定义一个整形向量容器对象
	    vector <int> i_vec;
	
	    //定义一个字符串列表容器对象
	    list <string> s_lis;
	
	    //没有确定长度输出长度为0
	    cout<<"i_vec的长度:"<<i_vec.size()<<endl;
	    cout<<"is_lis的长度:"<<s_lis.size()<<endl;
	
	    //没有确定长度,则为空
	    if(i_vec.empty() && s_lis.empty())
	    {
	        cout<<"两个对象都是空的!"<<endl;
	    }
	    return 0;
	}

运行结果：

i_vec的长度:0
is_lis的长度:0
两个对象都是空的!

③ 确定对象容量，以下实例确定了对象的长度为10，那么就不空！

#include <iostream>
#include <vector>
#include <list>
#include <string>
using namespace std;

int main()
{
    //定义一个整形向量容器对象,并且确定长度为10
    vector <int> i_vec(10);
    //定义一个字符串列表容器对象,并且确定长度为10
    list <string> s_lis(10);

    //没有确定长度输出长度为0
    cout<<"i_vec的长度:"<<i_vec.size()<<endl;
    cout<<"is_lis的长度:"<<s_lis.size()<<endl;
    
    //没有确定长度,则为空
    if(!(i_vec.empty()) && !(s_lis.empty()))
    {
        cout<<"两个对象都不空的!"<<endl;
    }
    return 0;
}

④确定容量并且初始化容器对象

#include <iostream>
#include <vector>
#include <list>
#include <string>
using namespace std;

int main()
{
    //定义一个整形向量容器对象,并且确定长度为10，并且初始化为-1
    vector <int> i_vec(10,-1);

    //定义一个字符串列表容器对象,并且确定长度为10，并且初始化为"dante"
    list <string> s_lis(10,"dante");

    //没有确定长度输出长度为0
    cout<<"i_vec的长度:"<<i_vec.size()<<endl;
    cout<<"is_lis的长度:"<<s_lis.size()<<endl;

    //没有确定长度,则为空
    if(!(i_vec.empty()) && !(s_lis.empty()))
    {
        cout<<"两个对象都不空的!"<<endl;
    }

    for(int n=0; n<i_vec.size(); n++)
    {
        cout<<"i_vec["<<n<<"] = "<<i_vec[n]<<endl;
    }
    list <string> ::iterator mp;
    for(mp = s_lis.begin(); mp != s_lis.end(); mp++)
    {
        cout<<"s_lis:"<<*mp<<endl;
    }
    return 0;
}

运行结果：

i_vec的长度:10
is_lis的长度:10
两个对象都不空的!
i_vec[0] = -1
i_vec[1] = -1
i_vec[2] = -1
i_vec[3] = -1
i_vec[4] = -1
i_vec[5] = -1
i_vec[6] = -1
i_vec[7] = -1
i_vec[8] = -1
i_vec[9] = -1
s_lis:dante
s_lis:dante
s_lis:dante
s_lis:dante
s_lis:dante
s_lis:dante
s_lis:dante
s_lis:dante
s_lis:dante
s_lis:dante