C++ 常见容器使用汇总

集合 有序（自动排序，默认从小到大） 元素唯一
例：

#include 
#include 

using namespace std;

set set1;       // 从小到大排列
set> set2;    // 从小到大排列       
set> set3;   // 从大到小排列

set set1;                  // 从小到大排列
for(int i = 0; i<5; i++)
{
    int tmp = rand();
    set1.insert(tmp);
}
set1.insert(100);
set1.insert(100);
set1.insert(100);

for(set::iterator it =set1.begin(); it !=set1.end(); it++)
{
     cout << *it << " ";
}            //  输出  1 3 100 4566 7889 88899

while (!set1.empty())     //  遍历删除所有元素
{
     set::iterator it = set1.begin();
     set1.erase(set1.begin());      // 删除首元素
}

set> set1;                  // 从大到小排列
for(int i = 0; i<5; i++)
{
    int tmp = rand();
    set1.insert(tmp);
}
set1.insert(100);
set1.insert(100);
set1.insert(100);

for(set::iterator it =set1.begin(); it !=set1.end(); it++)
{
     cout << *it << " ";
}            //  输出   88899   8888 777 555 100 13 

struct funstudent                    //  仿函数
{
    bool operator()(const student &left,  const student &right)
    {
        if(left.age < right.age)
	   {
           return true;
	   }
	   else
	   {
           return false;
	   }
    }	
}
void main()
{
     student s1("s1", 31);
     student s1("s2", 22);
     student s1("s3", 44);
     student s1("s4", 11);

     set  set1;       //  必须借用仿函数实现
     set1.insert(s1);
     set1.insert(s2);
     set1.insert(s3);
     set1.insert(s4);

     //遍历
    for(set::iterator it = set1.begin(), it != set1.end(), it++)
	{
         cout  << it->age < 
使用pair 来判断插入的结果 
// 注：相同的元素插入会失败
 
set  set1; 
pair::iterator, bool> pair1 = set1.insert(s1);
if(pair.second == true)
{
     cout << "插入s1成功" <
     cout << "插入s1失败" < 
set容器的find查找操作 
set set1;
for(int i = 0; i<10; i++)
{
      set1.insert(i+1);
}
for(set::iterator it = set1.begin(); it!=set1.end(); it++)
{
     cout << *it <iterator it0 =set1.find(5);
cout << *it0 <::iterator, set::iterator> pair1 = set1.equal_range(5);
set::iterator it3 =pair1.first;      输出大于等于5的元素
cout << *it3 <::iterator it4 =pair1.second;  输出大于5 的元素
cout << *it4 < 
vector容器使用 
vector容器常见使用场景 
#include 

using namespace std;

vector v1;
cout << "length" << v1.size() < 0)          // 遍历并删除所有元素
{
	v1.pop_back();    // 删除尾部元素		
}
 
vector 的初始化方式 
//方式一
vector v1;
v1.push_back(1);
v1.push_back(3);
v1.push_back(5);
//方式二
vector v2 = v1;
//方式三
vector v3(3, 9);   // 存放3个元素，每个元素的值是9
 
vector 的遍历 
vector v1(10);      //提前把内存准备好
for(int i=0; i<10; i++)
{
      v1[i] = i + 1;
}

for(int i = 0; i < 10; i++)
{
    printf("%d ", v1[i]);
}

//push_back 的强化记忆
vector v1(2);  //占用index 1,2
v1.push_back(100);  //从index 2开始插入
v1.push_back(200);  //从index 3开始插入
//输出   0 0 100 200             大小为 4
 
用迭代器遍历容器 vector 
vector::const_iterator                
vector::const_reverse_iterator

vector v1(10);      //提前把内存准备好
for(int i=0; i<10; i++)
{
      v1[i] = i + 1;
}
//正向遍历
for(vector::iterator it = v1.begin(); it!=v1.end(); it++)
{
     cout << *it << " ";       // 1 2 3 4 5 6 7 8 9 10
}
//逆序遍历
for(vector::reverse_iterator rit = v1.rbegin(); rit!=v1.rend(); rit++)
{
     count << *rit << " ";            // 10 9 8 7 6 5 4 3 2 1
}
 
vector的删除 
vector v1(10);      
for(int i=0; i<10; i++)
{
     v1[i] = i + 1;
}
//区间删除
v1.erase(v1.begin(), v1.begin()+3);        //输出 4 5 6 7 8 9 10

//根据元素的位置，指定位置删除
v1.erase(v1.begin()); //删除第一个元素 , 在前面的基础上输出 5 6 7 8 9 10
//v1.erase(v1.begin() + 1);  //删除第二个元素，总大小继续减1

//删除指定元素
std::remove(v1.begin(), v1.end(), 3); //将容器中为3的元素全部删除，但容器总容量不变

// 删除最后一个元素
vector v2{ 1,2,3,4,5 };
v2.pop_back();   //删除最后一个元素，但总容量不变
for(int i=0; i
	cout << v2[i] << endl;
}
//输出: 1 2 3 4

//根据元素的值删除
v1[1] = 2;
v1[3] = 2;            // 5 2 7 2 9 10
for(vector::iterator it = v1.begin(); it!=v1.end(); )
{
     if(*it == 2)
     {
         it = v1.erase(it); 
//当删除迭代器所指向的元素的时候，erase删除元素会让it自动向下移动，所以it++写在下面  
     }
     else
     {
         it++;
     }
}    //    输出 5 7 9 10
 
vector的插入与清空 
vector v1;
v1.insert(v1.begin(), 100);
printf("data=%dn", v1.front()); //100

printf("%dn", v1.size());  //1
v1.clear();
printf("%dn", v1.size());  // 0
 
queue容器使用 
队列中基本数据类型 
#include 
#include 

queue q;
q.push(1);
q.push(2);
q.push(3);

cout << "队头元素" <
    int tmp = q.front();
    cout << tmp << " ";                     
    //或者     
    //cout << q.front() < 
队列的算法和容器的分离 
teacher t1, t2, t3;
t1.age = 31;
t2.age = 32;
t3.age = 33;
//普通常量存储
queue s;
s.push(t1);
s.push(t2);    
s.push(t3);   
 
while( !s.empty())
{
    teacher tmp = s.front();
    cout << age < 
teacher t1, t2, t3;
t1.age = 31;
t2.age = 32;
t3.age = 33;
//指针类型存储
queue s;
s.push(&t1);
s.push(&t2);    
s.push(&t3);    

while( !s.empty())
{
     teacher *p = s.front();
     cout << p->age < 
map容器使用 
#include 
#include 
 
map容器的插入操作 
//方法1
map1.insert(pair(1, "teacher01"));

//方法2
map1.insert(make_pair(3, "teahcer01"));

//方法3
map1.insert(map::value_type(5, "teacher01"));

//方法4
map1[7] = "teacher07";
 
map容器的遍历操作 
for(map::iterator it =map1.begin(); it !=map1.end(); it++)
{
    cout << it->first << "t" << it->second < 
map容器的删除操作 
while(!map1.empty())
{
    map::iterator it = map1.begin();     
    map1.erase(it);
}
 
判断是否插入成功 
（1）方式一
 
前3种方法插入都是用这种方式判断：
pair::iterator, bool> mypair = map1.insert(pair(1, "teacher01");
if(mypair.second == true)
{
    cout<< "key 插入成功" < 
（2）方式二
 
map1[7] = "teacher07";
map1[7] = "teacher77";       // 不会插入失败，   只会覆盖，输出  teacher77
 
map的查找操作： 
map::iterator it2 = map1.find(100);
if(it2 == map1.end())
{
    cout << "key 100 的值 不存在" <
    cout <first << "t" << it2->second <::iterator, map::iterator> mypair = map1.equal_range(5);
// 第一个迭代器  >=5 的位置
//第二个迭代器 >5 的位置
if( mypair.first == map1.end())
{
    cout << ">=5的位置不存在" <
    cout << mypair.first->first <<"t" <second <
    cout << ">=5的位置不存在" <
    cout << mypair.second->first <<"t" <second < 
stack容器用法 
栈模型 
#include 
#include 

using namespace std;

stack s;
 
入栈 
for(int i =0; i<10; i++)
{
    s.push(i+1);
}
cout << "栈的大小" << s.size() < 
出栈 
while( !s.empty())
{
    int tmp = s.top();  //获取栈元素
    cout << tmp << " ";
    s.pop();      // 弹出栈顶元素
}   // 输出 10 9 8 7 6 5 4 3 2 1         
 
用法一
 
teacher t1, t2, t3;
t1.age = 31;
t2.age = 32;
t3.age = 33;

stack s;
s.push(t1);
s.push(t2);    
s.push(t3);    
while( !s.empty())
{
    teacher tmp = s.top();
    cout << age < 
用法二
 
teacher t1, t2, t3;
t1.age = 31;
t2.age = 32;
t3.age = 33;

stack s;
s.push(&t1);
s.push(&t2);    
s.push(&t3);    
while( !s.empty())
{
	teacher *p = s.top();
	cout << p->age < 
list 容器使用 
list的初始化操作 
#include 
#include 

list l;
cout << "list的大小" <
	l.push_back(i);   //从尾部插入元素，尾插法
}
cout << "list的大小"  <::iterator it = l.begin();
while ( it != l.end())
{
	cout << *it << " ";
	it++;
}
//输出  0   1    2    3     4    5

// list不能随机访问
it = l.begin();
it++;
it++;
it++;
it = it +5;         // 错误，不支持随机访问
 
list的插入操作 
l.insert(it, 100);           
for(list::iterator it = l.begin(); it!=l.end(); i++)
{
	cout << *it << " ";         // 输出  0  1 2 100 3 4 5
}
// 结论： 链表的节点index 序号是从0号位置开始
 
list 的删除操作 
  //  0  1  2  3  4  5
list::iterator it1 = l.begin();
list::iterator it2 = l.begin();
it2++;
it2++;
it2++;

l.erase(it1, it2);  // 删除操作的区间为 左闭右开
for(list::iterator it = l.begin(); it!=l.end(); i++)
{
	cout << *it << " ";  // 输出  3  4  5    
}

//删除第一个元素      0  1  2  3  4  5        
l.erase(l.begin());        //输出： 1 2 3 4 5

//删除元素1           0 1 1 1 2 3
l.remove(1)   //输出： 0 2 3	
 
容器在类中的值拷贝 
简介 
容器类值的插入是属于拷贝， 所以要使用 拷贝构造函数和 =运算符重载。
 
使用举例 
class teacher
{
public:
	teacher(char * name, int age)
	{
	       m_pname = new char[strlen(name) +1];
	       strcpy(m_pname, name);
	       m_age = age;
	}
	~teacher
	{
	      delete[] m_pname;
	      m_pname = NULL;
	      m_age = 0;
	}
private:
	char  *m_pname;
	int    m_age;
};

void main()
{
	teacher t1("t1", 31);
	vector v1;
	v1.push_back(t1);       // 如果不重写拷贝构造函数和赋值运算符重载，则会因为内存无法拷贝出错

}

解决：
//  拷贝构造函数
teacher(const teacher &obj)
{
	m_pname = new char[strlen(obj.m_pname) + 1];
	strcpy(m_pname, obj.m_pname);
	m_age = obj.m_age;
}

//  赋值运算符重载
teacher operator=(const teacher &obj)
{
//  1)  把旧的内存释放掉
	if(m_pname != NULL)
	{
	       delete[] m_pname;
	       m_pname = NULL;
	       m_age = 0;
	}
//  2)    分配内存
    m_pname = new char[strlen(obj.m_pname) + 1];
//  3）     拷贝数据
    strcpy(m_pname, obj.m_pname);
    m_age = obj.m_age;
	
	return *this;
}
 
deque容器使用 
deque的初始化操作 
#include 
#include 

using namespace std;

deque d1;
d1.push_back(1);
d1.push_back(3);
d1.push_back(5);

d1.push_front(-11);
d1.push_front(-33);
d1.push_front(-55);            //  -55  -33 -11 1 3 5

cout << "头部元素" << d1.front() < 
deque的查找操作 
deque::iterator it = find(d1.begin(), d1.end(), -33);
if( it != d1.end())
{
    cout << "-33数组的下标是" << distance(d1.begin(), it) <
	cout << "没有找到值为-33的元素" << endl;
}