本文介绍了C++ STL中的四种主要容器：list、vector、set和map。list是双向链表，适合频繁插入和删除，但不支持随机访问。vector是动态数组，提供随机访问，但在内部插入和删除效率较低。set是唯一元素集合，采用红黑树实现，而map是键值对集合，同样基于红黑树，支持按键快速访问。文章通过示例展示了它们的使用方法和特性。
一、 list
链表，双向链表，只能顺序访问，不能使用[ ]（即下标）进行随机访问。
可以不分配必须的内存大小方便的进行添加和删除操作。使用的是非连续的内存空间进行存储。
优点：(1) 不使用连续内存完成动态操作。
(2) 在内部方便的进行插入和删除操作
(3) 可在两端进行push、pop
缺点：(1) 不能进行内部的随机访问，即不支持[ ]操作符和vector.at()
(2) 相对于verctor占用内存多
list<T>容器是双向链表，因此可以有效的在任何位置添加和删除。列表的缺点是不能随机访问内容，要想访问内容必须在列表的内部从头开始便利内容，或者从尾部开始。
void printList(list<int> n){
for(list<int>::iterator i=n.begin();i!=n.end();i++)
cout<< *i << " ";
cout<<endl;
}
int main(){
list<int> list1,list2;
list1.push_back(123);
list1.push_back(0);
list1.push_back(34);
list2.push_back(100);
list2.push_back(12);
//测试list排序功能
printList(list1); //输出 123 0 34
list1.sort();
printList(list1); //输出 0 34 123
list2.sort();
list1.merge(list2); //两个链表排序后进行合并，合并完仍然有序
printList(list1); //输出 0 12 34 100 123
return 0;
}
二、vector
向量 相当于一个数组 支持[ ]进行随机访问。
在内存中分配一块连续的内存空间进行存储。支持不指定vector大小的存储。STL内部实现时，首先分配一个非常大的内存空间预备进行存储，即capacituy（）函数返回的大小，当超过此分配的空间时再整体重新放分配一块内存存储，这给人以vector可以不指定vector即一个连续内存的大小的感觉。通常此默认的内存分配能完成大部分情况下的存储。
优点：(1) 不指定一块内存大小的数组的连续存储，即可以像数组一样操作，但可以对此数组
进行动态操作。通常体现在push_back() pop_back()
(2) 随机访问方便，即支持[ ]操作符和vector.at()
(3) 节省空间。
缺点：(1) 在内部进行插入删除操作效率低。
(2) 只能在vector的最后进行push和pop，不能在vector的头进行push和pop。
(3) 当动态添加的数据超过vector默认分配的大小时要进行整体的重新分配、拷贝与释放
std::vector<T>矢量容器：可以随机访问容器的内容，在序列末尾添加或删除对象，但是因为是从尾部删除，过程非常慢，因为必须移动插入或删除点后面的所有对象。
#include <vector>
#include <list>
#include <set>
#include <map>
vector <int> vec1; //vec1初始为空
vector <int> vec2(10,6); //vec2最初由10个值为6的元素
vector <int> vec3(vec2.begin(),vec2.begin()+3); //vec3最初由3个值为6的元素。
//声明迭代器
vector<int> ::iterator i;
//从前向后显示vec1中的数据 :迭代器输出使用 *i
cout<<"vec1.begin()---vec1.end():"<<endl;
for(i=vec1.begin();i!=vec1.end();i++){
cout<<*i<<" ";
}cout<<endl;
//测试添加和插入成员函数（注意：vector不支持从前插入）
vec1.push_back(2); //从后面添加一个成员2
vec1.insert(vec1.begin()+1,5); //在vec1的第一个位置上插入成员5
vec1.insert(vec1.begin()+1,vec3.begin(),vec3.end()); //在vec1的第一个位置上插入vec3的所有成员
//测试赋值成员函数（重新给vector中的某一位上的元素赋值）
vec2.assign(8,1); //vec2的8个成员初始值设为1
//访问vector数组中的某一位置上的元素
cout<<vec2[2]<<endl;
for (int i=0 ; i<vec2.size() ; i++)
{
int nColor = vec2.at(i)) ;
cout<<nColor<<endl; //输出vec2中的每一个值
}
//删除和移出
vec1.pop_back(); //删除vec1的最后一个元素
vec1.erase(vec1.begin()+1,vec1.end()-2);
三、set
特点：包含元素唯一，可用于刷选一条数列中所有不同的值。
set中的key和value是Key类型的。
set<int> set1;
for(int i=0;i<5;i++) set1.insert(i);
set1.insert(1); //插入1
for(set<int>::iterator p = set1.begin();p!=set1.end();p++)
{
int a = *p;
cout<<*p<<" "<<endl; // 虽然插入了一个1 但仍输出 0 1 2 3 4 5
}
四、map
map中的key和value是一个pair结构中的两个分量。Map支持下表运算符operator[],用访问普通数组的方式访问map，不过下标为map的键。
#include <map> //注意，STL头文件没有扩展名.h
std:map<int, Cstring> enumMap; //int是键的类型，string是值的类型
enumMap[2] = “Two”; //插入2时,先在enumMap中查找主键为2的项，没发现，然后将一个新的对象插入enumMap，键是2，值是一个空字符串，插入完成后，将字符串赋为”Two”; 该方法会将每个值都赋为缺省值，然后再赋为显示的值，如果元素是类对象，则开销比较大。我们可以用以下方法来避免开销：
enumMap.insert(map<int, CString>::value_type(2, "Two"));查找并获取map中的元素：CString tmp = enumMap[2];
但是，只有当map中有2这个键的实例时才对，否则会自动插入一个实例，值为初始化值。
我们可以使用Find()和Count()方法来发现一个键是否存在。
查找map中是否包含某个关键字条目用find()方法，传入的参数是要查找的key，在这里需要提到的是begin()和end()两个成员，分别代表map对象中第一个条目和最后一个条目，这两个数据的类型是iterator.
int nFindKey = 2; //要查找的Key
std::map<int,Cstring>::iterator it= enumMap.find(nFindKey);//定义一个条目变量(实际是指针)
if(it == enumMap.end())
{
//没找到
}
else
{
//找到
}
// 使用value()函数获取键的值，这样当键不存在时不会自动插入
int value2 = map.value(2);通过map对象的方法获取的iterator数据类型是一个std::pair对象，包括两个数据 iterator->first 和 iterator->second 分别代表关键字和存储的数据。
//遍历：
map<string,CAgent>::iterator iter;
for(iter = m_AgentClients.begin(); iter != m_AgentClients.end(); ++iter)
{
if(iter->first=="8001")
{
this->SendMsg(iter->second.pSocket,strMsg); //iter->first
}
}
//查找：
map<string,CAgent>::iterator iter=m_AgentClients.find(strAgentName);
if(iter!=m_AgentClients.end()) //有重名的
{
}
else //没有
{
}
//元素的个数
if (m_AgentClients.size()==0)
//删除
map<string,CAgent>::iterator iter=m_AgentClients.find(pSocket->GetName());
if(iter!=m_AgentClients.end())
{
m_AgentClients.erase(iter); //列表移除
}
map的合并去重
map1.insert(map1.front(), map2.begin(), map2.end()); //合并数据
std::sort(map1.begin(), map1.end()); //排序
map1.erase(std::unique(map1.begin(), map1.end()), map1.end()); //去重五、QMultiMap
，可以使用QMultiMap类来实现一键多值
QMultiMap<QString, int> map1, map2, map3;
map1.insert("values", 1);
map1.insert("values", 2);
map2.insert("values", 3);
// 可以进行相加，这样map3的“values”键将包含2,1,3三个值
map3 = map2 + map1;
QList<int> myValues = map3.values("values");
qDebug() << "the values are: ";
for (int i=0; i<myValues.size(); ++i) {
qDebug() << myValues.at(i);
}
return a.exec();
// 输出为2，1，3
QMultiMap<QString, int> multiMap;
multiMap.insert("a", 1);
multiMap.insert("a", 2);
// ***
multiMap.insertMulti("b", 3);
multiMap.insert("b", 5);
multiMap.insertMulti("b", 4);
multiMap.insert("b", 6);
// ***
multiMap.insert("c", 2);
qDebug() << multiMap.value("a");
qDebug() << "\t count :"<<multiMap.values("a").count();
qDebug() << "\t " << multiMap.values("a");
qDebug() << multiMap.value("b");
qDebug() << "\t "<< multiMap.values("b");
qDebug() << multiMap.keys(2);
// 输出
2
count : 2
(2, 1)
6
(6, 4, 5, 3)
("a", "c")也可以通过 QMultiMap的成员uniqueKeys() 获得唯一key的列表，比如刚才插入的key有：a b b c， multiMap.uniqueKeys() 里面就是：a b c.
QMultiMap<int,quint64> multiMap;
multiMap.insert(1,1582730);
multiMap.insert(1,1502870);
multiMap.insert(2,1778302);
for (auto& Nor:multiMap.uniqueKeys())
{
cout<<"key:"<< Nor <<endl;
for(auto& numer: multiMap.values(Nor))
{
cout<< "values:"<<numer<<endl;
}
}
// 输出依次为
key：1
values:1582730
values:1502870
key: 2
values:1778302
Map, Set属于标准关联容器，使用了非常高效的平衡检索二叉树：红黑树，他的插入删除效率比其他序列容器高是因为不需要做内存拷贝和内存移动，而直接替换指向节点的指针即可。
Set和Vector的区别在于Set不包含重复的数据。Set和Map的区别在于Set只含有Key，而Map有一个Key和Key所对应的Value两个元素。
重要的注：
当key为自定义类型时需要重写小于号操作符
比如自定义类为 Student
class Student
{
public：
Student();
public:
//包含两个成员变量
int year;
Qstring name;
public:
bool operator<(const Student& objOther) const;
}
Student::Student
:year(0),
{
}
bool Student operator<(const Student& objOther) const
{
return year < objOther.year && name < objOther.name ;
}
或
bool Student operator<(const Student& objOther) const
{
if(year < objOther.year && name < objOther.name)
{
return true;
}
return false ;
}
但是，如果只是比较两个自定义类的对象是否一样，即有一个参数不同就认为是两个不同的对象，重写操作应如下写法：
bool Student operator<(const Student& objOther) const
{
if(year < objOther.year || name < objOther.name)
{
retrun true;
}
return false ;
}
扫一扫
1098
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
