目录
1, 什么是deque
C++中一种容器数据类型, 也叫双端数组, 可以在deque的头尾进行插入删除操作
deque通过中控器控制缓冲区, 缓冲区存放的是真实的数据
需要在导入头文件#include <deque>, 才能使用deque
2, 创建deque
通过deque<数据类型> 对象名, 可创建deque, 数据类型可以是标准数据类型, 也可以是自定义类型
#include <iostream>
#include <string>
#include <deque>
using namespace std;
class Myclass
{
public:
Myclass(string name, int age) :m_name(name), m_age(age) {};
string m_name;
int m_age;
};
int main()
{
Myclass m1("aaa", 1);
Myclass m2("bbb", 2);
Myclass m3("ccc", 3);
//内置数据类型
deque<string> d1; //仅创建
deque<string> d2 = {"a", "b", "c"}; //创建并赋值
deque<string> d3(d2); //拷贝构造创建
deque<string> d4(d2.begin(), d2.end());//迭代器区间方式创建赋值
deque<string> d5(5, "a"); //指定长度创建
deque<deque<string>> dd1 = { d2, d3, d4, d5 }; //嵌套
//自定义数据类型
deque<Myclass> d6; //仅创建
deque<Myclass> d7 = {m1, m2, m3}; //创建并赋值
deque<Myclass> d8(d7); //拷贝构造创建
deque<Myclass> d9(d7.begin(), d7.end());//迭代器区间方式创建赋值
deque<Myclass> d10(5, m1); //指定长度创建
deque<deque<Myclass>> dd2 = { d7, d8, d9, d10 };//嵌套
system("pause");
return 0;
}
3, 替换(assign)
assign是用新的元素替换原来deque的元素
#include <iostream>
#include <string>
#include <deque>
using namespace std;
class Myclass
{
public:
Myclass(string name, int age) :m_name(name), m_age(age) {};
string m_name;
int m_age;
};
int main()
{
Myclass m1("aaa", 1);
Myclass m2("bbb", 2);
Myclass m3("ccc", 3);
//内置数据类型
deque<string> d1 = { "a", "b", "c" };
//d1数据被替换为5个a
d1.assign(5, "a");
//自定义数据类型
deque<Myclass> d2 = { m1, m2, m3 };
//d2数据被替换为5个m1
d2.assign(5, m1);
system("pause");
return 0;
}
4, 插入元素(insert)
insert是向vector指定位置, 插入元素, 支持一次添加多个元素, 插入多个元素时,元素范围通过迭代器指定
#include <iostream>
#include <string>
#include <deque>
using namespace std;
class Myclass
{
public:
Myclass(string name, int age) :m_name(name), m_age(age) {};
string m_name;
int m_age;
};
int main()
{
Myclass m1("aaa", 1);
Myclass m2("bbb", 2);
Myclass m3("ccc", 3);
//内置数据类型
deque<string> d1 = { "a", "b", "c" };
//在d1的索引0处插入a1, d1 = { "a1", "a", "b", "c" }
d1.insert(d1.begin(), "a1");
deque<string>::iterator it = d1.begin();
it++;
//在d1的索引1处插入a2, d1 = { "a1", "a2", "a", "b", "c" }
d1.insert(it, "a2");
deque<string>::iterator it1 = d1.begin();
it1++;
it1++;
//在d1的索引2处插入a3, d1 = { "a1", "a2", "a3", "a", "b", "c" }
d1.insert(it1, "a3");
//在d1的索引0处插入多个元素, d2= { "a1", "a2", "a3", "a", "b", "c", "a1", "a2", "a3", "a", "b", "c" }
d1.insert(d1.begin(), d1.begin(), d1.end());
//自定义数据类型
deque<Myclass> d2 = { m1, m2, m3 };
//在d2的索引0处插入m2, d2 = { m2, m1, m2, m3 }
d2.insert(d2.begin(), m2);
deque<Myclass>::iterator it2 = d2.begin();
it2++;
//在d2的索引1处插入m3, d2 = { m2, m3, m1, m2, m3 }
d2.insert(it2, m3);
deque<Myclass>::iterator it3 = d2.begin();
it3++;
it3++;
//在d2的索引2处插入m1, d2= { m2, m3, m1, m1, m2, m3 }
d2.insert(it3, m1);
//在d2的索引0处插入多个元素, d2= { m2, m3, m1, m1, m2, m3, m2, m3, m1, m1, m2, m3 }
d2.insert(d2.begin(), d2.begin(), d2.end());
system("pause");
return 0;
}
5, 头插( push_front)
push_front是在头部插入元素, 只能单个添加
#include <iostream>
#include <string>
#include <deque>
using namespace std;
class Myclass
{
public:
Myclass(string name, int age) :m_name(name), m_age(age) {};
string m_name;
int m_age;
};
int main()
{
Myclass m1("aaa", 1);
Myclass m2("bbb", 2);
Myclass m3("ccc", 3);
//内置数据类型
deque<string> d1 = { "a", "b", "c" };
//d1 = { "a1", "a", "b", "c" }
d1.push_front("a1");
//自定义数据类型
deque<Myclass> d2 = { m1, m2, m3 };
//d2 = {m3, m1, m2, m3 }
d2.push_front(m3);
system("pause");
return 0;
}
6, 尾插( push_back)
push_back是在尾部插入元素, 只能单个添加
#include <iostream>
#include <string>
#include <deque>
using namespace std;
class Myclass
{
public:
Myclass(string name, int age) :m_name(name), m_age(age) {};
string m_name;
int m_age;
};
int main()
{
Myclass m1("aaa", 1);
Myclass m2("bbb", 2);
Myclass m3("ccc", 3);
//内置数据类型
deque<string> d1 = { "a", "b", "c" };
//d1 = { "a", "b", "c", "a1" }
d1.push_back("a1");
//自定义数据类型
deque<Myclass> d2 = { m1, m2, m3 };
//d2 = { m1, m2, m3, m3 }
d2.push_back(m3);
system("pause");
return 0;
}
7, 查询(at)
通过对象名[索引]或者对象名.at(索引), 获取deque中的元素
#include <iostream>
#include <string>
#include <deque>
using namespace std;
class Myclass
{
public:
Myclass(string name, int age) :m_name(name), m_age(age) {};
string m_name;
int m_age;
};
int main()
{
Myclass m1("aaa", 1);
Myclass m2("bbb", 2);
Myclass m3("ccc", 3);
//内置数据类型
deque<string> d1 = { "a", "b", "c" };
//打印b
cout << d1.at(1) << endl;
//打印c
cout << d1[2] << endl;
//自定义数据类型
deque<Myclass> d2 = { m1, m2, m3 };
//打印bbb 2
cout << d2.at(1).m_name << " " << d2.at(1).m_age << endl;
//打印ccc 3
cout << d2[2].m_name << " " << d2[2].m_age << endl;
system("pause");
return 0;
}
8, 头元素(front)
通过对象.front(),获取deque的头元素
#include <iostream>
#include <string>
#include <deque>
using namespace std;
class Myclass
{
public:
Myclass(string name, int age) :m_name(name), m_age(age) {};
string m_name;
int m_age;
};
int main()
{
Myclass m1("aaa", 1);
Myclass m2("bbb", 2);
Myclass m3("ccc", 3);
//内置数据类型
deque<string> d1 = { "a", "b", "c" };
//打印a
cout << d1.front() << endl;
//自定义数据类型
deque<Myclass> d2 = { m1, m2, m3 };
//打印aaa 1
cout << d2.front().m_name << " " << d2.front().m_age << endl;
system("pause");
return 0;
}
9, 尾元素(back)
通过对象.back(),获取deque的尾元素
#include <iostream>
#include <string>
#include <deque>
using namespace std;
class Myclass
{
public:
Myclass(string name, int age) :m_name(name), m_age(age) {};
string m_name;
int m_age;
};
int main()
{
Myclass m1("aaa", 1);
Myclass m2("bbb", 2);
Myclass m3("ccc", 3);
//内置数据类型
deque<string> d1 = { "a", "b", "c" };
//打印c
cout << d1.back() << endl;
//自定义数据类型
deque<Myclass> d2 = { m1, m2, m3 };
//打印ccc 3
cout << d2.back().m_name << " " << d2.back().m_age << endl;
system("pause");
return 0;
}
10, 头删(pop_front)
通过对象.pop_front(),删除deque的头元素
#include <iostream>
#include <string>
#include <deque>
using namespace std;
class Myclass
{
public:
Myclass(string name, int age) :m_name(name), m_age(age) {};
string m_name;
int m_age;
};
int main()
{
Myclass m1("aaa", 1);
Myclass m2("bbb", 2);
Myclass m3("ccc", 3);
//内置数据类型
deque<string> d1 = { "a", "b", "c" };
//d1 = { "b", "c" }
d1.pop_front();
//自定义数据类型
deque<Myclass> d2 = { m1, m2, m3 };
//d2 = { m2, m3 }
d2.pop_front();
system("pause");
return 0;
}
11, 尾删(pop_back)
通过对象.pop_back(),删除deque的尾元素
#include <iostream>
#include <string>
#include <deque>
using namespace std;
class Myclass
{
public:
Myclass(string name, int age) :m_name(name), m_age(age) {};
string m_name;
int m_age;
};
int main()
{
Myclass m1("aaa", 1);
Myclass m2("bbb", 2);
Myclass m3("ccc", 3);
//内置数据类型
deque<string> d1 = { "a", "b", "c" };
//d1 = { "a", "b" }
d1.pop_back();
//自定义数据类型
deque<Myclass> d2 = { m1, m2, m3 };
//d2 = { m1, m2 }
d2.pop_back();
system("pause");
return 0;
}
12, 获取长度(size)
通过对象名.size(), 获取deque的长度
#include <iostream>
#include <string>
#include <deque>
using namespace std;
class Myclass
{
public:
Myclass(string name, int age) :m_name(name), m_age(age) {};
string m_name;
int m_age;
};
int main()
{
Myclass m1("aaa", 1);
Myclass m2("bbb", 2);
Myclass m3("ccc", 3);
//内置数据类型
deque<string> d1 = { "a", "b", "c" };
//打印3
cout << d1.size() << endl;
//自定义数据类型
deque<Myclass> d2 = { m1, m2, m3 };
//打印3
cout << d2.size() << endl;
system("pause");
return 0;
};
13, 设置长度(resize)
通过对象名.resize(), 设置deque的长度
#include <iostream>
#include <string>
#include <deque>
using namespace std;
class Myclass
{
public:
Myclass() {};
Myclass(string name, int age) :m_name(name), m_age(age) {};
string m_name;
int m_age;
};
int main()
{
Myclass m1("aaa", 1);
Myclass m2("bbb", 2);
Myclass m3("ccc", 3);
//内置数据类型
deque<string> d1 = { "a", "b", "c" };
//设置长度为10
d1.resize(10);
//打印10
cout << d1.size() << endl;
//自定义数据类型
deque<Myclass> d2 = { m1, m2, m3 };
//自定义数据类型设置长度时,自定义类需要提供默认构造函数
d2.resize(10);
//打印10
cout << d2.size() << endl;
system("pause");
return 0;
}
14, 判断是否为空(empty)
通过对象名.empty(), 判断deque是否为空, 为空返回1, 不为空返回0;
#include <iostream>
#include <string>
#include <deque>
using namespace std;
class Myclass
{
public:
Myclass() {};
Myclass(string name, int age) :m_name(name), m_age(age) {};
string m_name;
int m_age;
};
int main()
{
Myclass m1("aaa", 1);
Myclass m2("bbb", 2);
Myclass m3("ccc", 3);
//内置数据类型
deque<string> d1 = { "a", "b", "c" };
//打印0
cout << d1.empty() << endl;
//自定义数据类型
deque<Myclass> d2 = { m1, m2, m3 };
//打印0
cout << d2.empty() << endl;
system("pause");
return 0;
}
15, 指定元素删除(erase)
通过对象名.erase(迭代器名称), 删除迭代器指向的元素, 可指定迭代器区间删除多个元素
#include <iostream>
#include <string>
#include <deque>
using namespace std;
class Myclass
{
public:
Myclass() {};
Myclass(string name, int age) :m_name(name), m_age(age) {};
string m_name;
int m_age;
};
int main()
{
Myclass m1("aaa", 1);
Myclass m2("bbb", 2);
Myclass m3("ccc", 3);
//内置数据类型
deque<string> d1 = { "a", "b", "c" };
//删除单个元素, d1 = { "b", "c" }
d1.erase(d1.begin());
//指定迭代器区间删除元素, d1 = {}
d1.erase(d1.begin(), d1.end());
//自定义数据类型
deque<Myclass> d2 = { m1, m2, m3 };
//删除单个元素, d2 = { m2, m3 }
d2.erase(d2.begin());
//指定迭代器区间删除元素, d2 = {}
d2.erase(d2.begin(), d2.end());
system("pause");
return 0;
}
16, 清空(clear)
通过对象.clear(), 清空对象中的元素
#include <iostream>
#include <string>
#include <deque>
using namespace std;
class Myclass
{
public:
Myclass() {};
Myclass(string name, int age) :m_name(name), m_age(age) {};
string m_name;
int m_age;
};
int main()
{
Myclass m1("aaa", 1);
Myclass m2("bbb", 2);
Myclass m3("ccc", 3);
//内置数据类型
deque<string> d1 = { "a", "b", "c" };
//清空元素, d1 = { }
d1.clear();
//自定义数据类型
deque<Myclass> d2 = { m1, m2, m3 };
//清空元素, d2 = { }
d2.clear();
system("pause");
return 0;
}
17, 交换元素(swap)
通过对象名1.swap(对象名2), 可交换两个deque中的元素, 元素类型需要一致
#include <iostream>
#include <string>
#include <deque>
using namespace std;
class Myclass
{
public:
Myclass() {};
Myclass(string name, int age) :m_name(name), m_age(age) {};
string m_name;
int m_age;
};
int main()
{
Myclass m1("aaa", 1);
Myclass m2("bbb", 2);
Myclass m3("ccc", 3);
//内置数据类型
deque<string> d1 = { "a", "b", "c" };
deque<string> d2 = { "1", "2", "3" };
//d1 = { "1", "2", "3" }, d2 = { "a", "b", "c" }
d1.swap(d2);
//自定义数据类型
deque<Myclass> d3 = { m1, m2, m3 };
deque<Myclass> d4 = { m3, m2, m1 };
//d3 = { m3, m2, m1 }, d4 = { m1, m2, m3 }
d3.swap(d4);
system("pause");
return 0;
}