envase
- 1 contenedor de cuerdas
- contenedor de 2 vectores
-
- 2.0 Concepto básico de vector
- 2.1 constructor de vectores
- 2.2 operación de asignación de vectores
- 2.3 contenedor de vectores y tamaño
- 2.4 inserción y eliminación de vectores
- 2.5 acceso a datos vectoriales
- Contenedor intercambiable de 2,6 vectores, el uso inteligente del intercambio puede reducir el espacio de memoria
- 2.7 espacio reservado
- 3 contenedores deque
1 contenedor de cuerdas
1.0 Concepto básico de cadena
esencia :
- string es una cadena de estilo C++, que es esencialmente una clase encapsulada
La diferencia entre cadena y char* :
- char* es un puntero
- string es una clase que encapsula char* dentro de la clase y administra esta cadena, que es un contenedor de tipo char*.
Características :
la clase de cadena encapsula internamente muchos métodos de miembro
, como: buscar, copiar, borrar, eliminar, reemplazar, reemplazar, insertar insertar
cadena para administrar la memoria asignada por char *, no se preocupe por copiar fuera de los límites y valor. de límites, etc., y la clase es responsable de ello.
1.1 constructor de cadenas
Prototipo constructor (4 sobrecargas de funciones):
-
string();Cree una cadena vacía, por ejemplo:string str;.
string(const char* s);Inicializado con la cadena s. -
string(const string& str);Use un objeto de cadena para inicializar otro objeto de cadena -
string(int n, char c);Inicializar con n caracteres c
Ejemplo :
#include<iostream>
using namespace std;
#include<string>
void test1_01()
{
string s1; //默认构造
cout << "s1 = " << s1 << endl;
const char* str = "hello world";
string s2(str); //使用C++字符串初始化
cout << "s2 = " << s2 << endl;
string s3(s2); //拷贝构造
cout << "s3 = " << s3 << endl;
string s4(3, 'h');
cout << "s4 = " << s4 << endl;
}
int main()
{
test1_01();
system("pause");
return 0;
}
1.2 Operación de asignación de cadenas
Prototipo de función para asignación (3 sobrecargas de operador, 4 sobrecargas de función):
string& operator=(const char* s); //char*类型字符串赋值给当前的字符串
string& operator=(const string& s); //把字符串s赋给当前的字符串
string& operator=(char C); //字符赋值给当前的字符串
string& assign(const char* s); //把字符串s赋给当前的字符串
string& assign(const char* s, int n); //把字符串s的前n个字符赋给 当前的字符串
string& assign(const string& s); //把字符串s赋给当前字符串
string& assign(int n, char C); //用n个字符c赋给当前字符串
Ejemplo:
#include<iostream>
using namespace std;
#include<string>
void test2_01()
{
string str1;
str1 = "hello world"; //string& operator=(const char* s);
cout << "str1 = " << str1 << endl;
string str2;
str2 = str1; //string& operator=(const string& s);
cout << "str2 = " << str2 << endl;
string str3;
str3 = 'c'; //string& operator=(char c);
cout << "str3 = " << str3 << endl;
string str4;
str4.assign("hello C++"); //string& assign(const char* s);
cout << "str4 = " << str4 << endl;
string str5;
str5.assign("hello C++", 5); //string& assign(const char* s, int n);
cout << "str5 = " << str5 << endl;
string str6;
str6.assign(str5); //string& assign(const string& s);
cout << "str6 = " << str6 << endl;
string str7;
str7.assign(5,'c'); //string& assign(int n, char c);
cout << "str7 = " << str7 << endl;
}
int main()
{
test2_01();
system("pause");
return 0;
}
Empalme de cuerdas de 1,3 cuerdas
Prototipo de función empalmada (3 sobrecargas de operador, 4 sobrecargas de función):
string& operator+=(const char* str); //重载+=操作符
string& operator+=(const char C); //重载+=操作符
string& operator+=(const string& str); //重载+=操作符
string& append(const char* s); //把字符串s连接到当前字符串结尾
string& append(const char* S，int n); //把字符串s的前n个字符连接到当前字符串结尾
string& append(const string& s); //同operator+=(const string& str)
string & append(const string & s, int pos, int n); //字符串s中从pos开始的n个字符连接到字符串结尾
Ejemplo:
#include<iostream>
using namespace std;
#include<string>
void test3_01(){
string str1 = "我";
str1 += "爱玩游戏"; //string& operator+=(const char* str);
cout << "str1 = " << str1 << endl;
str1 += ':'; //string& operator+=(const char C);
cout << "str1 = " << str1 << endl;
string str2 = "LOL,DNF";
str1 += str2; //string& operator+=(const string & str);
cout << "str2 = " << str2 << endl;
string str3 = "I";
str3.append(" love "); //string& append(const char* s)
cout << "str3 = " << str3 << endl;
str3.append(" game , study ", 6); //string& append(const char* S，int n);
cout << "str3 = " << str3 << endl;
string str4 = str3;
str3.append(str2); //string& append(const string& s);
cout << "str3 = " << str3 << endl;
str4.append(str2, 4, 6); //string& append(const string & s, int pos, int n);
cout << "str4 = " << str4 << endl;
}
int main(){
test3_01();
system("pause");
return 0;
}
1.4 cadena buscar y reemplazar
Prototipo de función:
int find(const string& str, int pos = 0) const; //查找str第一次出现位置，从pos开始查找
int find(const char* s, int pos = 0) const; //查找s第一次出现位置从pos开始查找
int find(const char* s, int pos, int n) const; //从pos位置查找s的前n个字符第一-次位置
int find(const char C，int pos = 0) const; //查找字符c第一次出现位置
int rfind(const string& str, int pos = npos) const; //查找str最后一次位 置从pos开始查找
int rfind(const char* s，int pos = npos) const; //查找s最后一-次出现位置，从pos开始查找
int rfind(const char* s，int pos, int n) const; //从pos查找s的前n个字符最后一-次位置
int rfind(const char C，int pos = 0) const; //查找字符c最后一次出现位置
string& replace(int pos, int n, const string& str); //替换从pos开始n个字符为字符串str
string& replace(int pos, int n, const char* s); //替换从pos开始的n个字符为字符串s
Ejemplo:
#include<iostream>
using namespace std;
#include<string>
//int find(const string& str, int pos = 0) const; //查找str第一次出现位置，从pos开始查找
//int find(const char* s, int pos = 0) const; //查找s第一次出现位置从pos开始查找
//int find(const char* s, int pos, int n) const; //从pos位置查找s的前n个字符第一-次位置
//int find(const char C，int pos = 0) const; //查找字符c第一次出现位置
//int rfind(const string& str, int pos = npos) const; //查找str最后一次位 置从pos开始查找
//int rfind(const char* s，int pos = npos) const; //查找s最后一-次出现位置，从pos开始查找
//int rfind(const char* s，int pos, int n) const; //从pos查找s的前n个字符最后一-次位置
//int rfind(const char C，int pos = 0) const; //查找字符c最后一次出现位置
//string& replace(int pos, int n, const string& str); //替换从pos开始n个字符为字符串str
//string& replace(int pos, int n, const char* s); //替换从pos开始的n个字符为字符串s
//查找
void test4_01() {
string str1 = "abcdefgde";
int pos = str1.find("de"); //find是从左往右找
int pos2 = str1.find("deg");
cout << pos << endl;
cout << pos2 << endl;
int pos3 = str1.rfind("de"); //find是从右往左找
int pos4 = str1.find("deg");
cout << pos3 << endl;
cout << pos4 << endl;
}
//替换
void test4_02() {
string str1 = "abcdefg";
str1.replace(1, 3, "123456");
cout << "str1 = " << str1 << endl;
}
int main() {
test4_01();
test4_02();
system("pause");
return 0;
}
Resumir:
- find búsquedas de izquierda a derecha y rfind búsquedas de derecha a izquierda.
- La búsqueda siempre devuelve la posición del primer carácter encontrado, o -1 si no se encuentra.
- Al reemplazar, debe especificar desde qué posición, cuántos caracteres y qué tipo de cadena reemplazar (y la longitud de la cadena reemplazada puede ser diferente de la cantidad de caracteres que se reemplazarán ).
Comparación de cadenas de 1.5 cuerdas
Método de comparación :
la comparación de cadenas se basa en el código ASCII del carácter
- = devolver 0;
- > devolver 1;
- < volver -1;
Prototipo de función:
int compare(const string& s) const; //与字符串s比 较
int compare(const char* s) const; //与字符串s比较
Ejemplo:
#include<iostream>
using namespace std;
#include<string>
//int compare(const string& s) const; //与字符串s比 较
//int compare(const char* s) const; //与字符串s比较
void test5_01()
{
string str1 = "xello";
string str2 = "hello";
if (str1.compare(str2) == 0){
cout << "str1 == str2" << endl;
}
else if (str1.compare(str2) > 0) {
cout << "str1 > str2" << endl;
}
else
{
cout << "str1 < str2" << endl;
}
}
int main5() {
test5_01();
system("pasue");
return 0;
}
Acceso a caracteres de 1.6 cadenas
Hay dos formas de acceder a un solo carácter en una cadena:
char& operator[](int n); //通过[]方式获取字符
char& at(int n); //通过at方式获取字符
Ejemplo:
#include<iostream>
using namespace std;
#include<string>
//char& operator[](int n); //通过[]方式获取字符
//char& at(int n); //通过at方式获取字符
void test6_01()
{
string str = "hello";
cout << "str = " << str << endl;
//通过[]访问单个字符
for (int i = 0; i < str.size(); i++)
{
cout << str[i] << ' ';
}
cout << endl;
//通过at访问单个字符
for (int i = 0; i < str.size(); i++)
{
cout << str.at(i) << ' ';
}
cout << endl;
//修改
str[0] = 'x';
cout << "str = " << str << endl;
str[1] = 'z';
cout << "str = " << str << endl;
}
int main() {
test6_01();
system("pause");
return 0;
}
1.7 inserción y eliminación de cadenas
Prototipo de función:
string& insert(int pos, const char* s); //插入字符串
string& insert(int pos, const string& str); //插入字符串
string& insert(int pos, int n, char C); //在指定位置插入n个字符c
string& erase(int pos, int n = npos); //删除从Pos开始的n个字符
Ejemplo:
#include<iostream>
using namespace std;
#include<string>
//string& insert(int pos, const char* s); //插入字符串
//string& insert(int pos, const string& str); //插入字符串
//string& insert(int pos, int n, char C); //在指定位置插入n个字符c
//string& erase(int pos, int n = npos); //删除从Pos开始的n个字符
void test7_01(){
string str = "hello";
str.insert(1, "111"); //string& insert(int pos, const string& str);
cout << "str = " << str << endl;
str.insert(0, 3, 'a'); //string& insert(int pos, int n, char C);
cout << "str = " << str << endl;
//删除
str.erase(0, 3); //string& erase(int pos, int n = npos);
str.erase(1, 3);
cout << "str = " << str << endl;
}
int main(){
test7_01();
system("pause");
return 0;
}
Resumen:
la inserción y la eliminación se cuentan desde el índice 0.
subcadena de 1.8 cadenas
Prototipo de función:
string substr(int pos = 0, int n = npos) const; //返回由pos开始的n个字符组成的字符串
Ejemplo:
#include<iostream>
using namespace std;
#include<string>
void test8_01(){
string str = "abcdef";
string subStr = str.substr(1, 3);
cout << "subStr = " << subStr << endl;
//实用操作
string email = "[email protected]";
//从邮件地址中获取用户名信息
int pos = email.find('@');
cout << pos << endl;
string usrName = email.substr(0, pos);
cout << "usrName = " << usrName << endl;
}
int main() {
test8_01();
system("pause");
return 0;
}
contenedor de 2 vectores
2.0 Concepto básico de vector
función :
- La estructura de datos vectoriales es muy similar a una matriz y también se convierte en una matriz de un solo extremo .
La diferencia entre el vector y la matriz ordinaria :
- La diferencia es que la matriz es un espacio estático y el vector puede expandirse dinámicamente .
Expansión dinámica :
- No es para continuar el nuevo espacio detrás del espacio original, sino para encontrar un espacio de memoria más grande y luego copiar los datos originales al nuevo espacio para liberar el espacio original.
- El iterador del contenedor de vectores es un iterador que admite el acceso aleatorio.
/
2.1 constructor de vectores
Función: crear contenedor de vectores
prototipo de función
vector<T> v; //采用模板实现类实现,默认构造函数
vector(v.begin(), v.end()); //将v[begin,end())区间的元素拷贝给本身
vector(n, elem); //构造函数将n个elem拷贝给本身
vector(const vector& vec); //拷贝构造函数
Ejemplo:
#include<iostream>
using namespace std;
#include<vector>
//vector<T> v; //采用模板实现类实现,默认构造函数
//vector(v.begin(), v.end()); //将v[begin,end())区间的元素拷贝给本身
//vector(n, elem); //构造函数将n个elem拷贝给本身
//vector(const vector& vec); //拷贝构造函数
void printVector1(vector<int>& v){
for (vector<int>::iterator it = v.begin(); it != v.end(); it++)
{
cout << *it << " ";
}
cout << endl;
}
void test01(){
vector<int> v1;
for (int i = 0; i < 10; i++)
{
v1.push_back(i + 1);
}
printVector1(v1);
//通过区间方式进行构造
vector<int> v2(v1.begin(), v1.end());
printVector1(v2);
vector<int> v3(10, 100);
printVector1(v3);
vector<int> v4(v3);
printVector1(v4);
}
int main() {
test01();
system("pause");
return 0;
}
/
2.2 operación de asignación de vectores
Prototipo de función:
vector operator=(const vector& vec); //重载等号操作符
assign(begin, end); //将[beg,end)区间中的数据拷贝赋值给本身
assign(n, elem); //将n个elem拷贝赋值给本身
Ejemplo:
#include<iostream>
using namespace std;
#include<vector>
//vector operator=(const vector& vec); //重载等号操作符
//assign(begin, end); //将[beg,end)区间中的数据拷贝赋值给本身
//assign(n, elem); //将n个elem拷贝赋值给本身
void printVector2(vector<int>& v)
{
for (vector<int>::iterator it = v.begin(); it != v.end(); it++) {
cout << *it << " ";
}
cout << endl;
}
void test2_01(){
vector<int> v1;
for (int i = 0; i < 10; i++)
{
v1.push_back(i);
}
printVector2(v1);
//赋值
vector<int> v2;
v2 = v1;
printVector2(v2);
//assign
vector<int> v3;
v3.assign(v1.begin(), v1.end());
printVector2(v3);
//n个elem
vector<int> v4;
v4.assign(10, 100);
printVector2(v4);
}
int main(){
test2_01();
system("pause");
return 0;
}
Resumen: use = o asigne para la tarea.
2.3 contenedor de vectores y tamaño
Prototipo de función:
empty(); //判断容器是否为空
capacity(); //容器的容量
size(); //返回容器中元素的个数
resize(int num); //重新指定容器的长度为num,若容器变长，则以默认值填充新位置。
//如果容器变短，则末尾超出容器长度的元素被删除。
resize(int num, elem); ] //重新指定容器的长度为num,若容器变长，则以elem值填充新位置。
//如果容器变短，则末尾超出容器长度的元素被删除
caso:
#include<iostream>
using namespace std;
#include<vector>
//empty(); //判断容器是否为空
//capacity(); //容器的容量
//size(); //返回容器中元素的个数
//resize(int num); //重新指定容器的长度为num,若容器变长，则以默认值填充新位置。
// //如果容器变短，则末尾超出容器长度的元素被删除。
//resize(int num, elem); ] //重新指定容器的长度为num,若容器变长，则以elem值填充新位置。
// //如果容器变短，则末尾超出容器长度的元素被删除
void printVector3(vector<int> v) {
for (vector<int>::iterator it = v.begin(); it != v.end(); it++) {
cout << *it << " ";
}
cout << endl;
}
void test3_01(){
vector<int> v1;
for (int i = 0; i < 10; i++) {
v1.push_back(i);
}
printVector3(v1);
if (v1.empty()) {
//为真
cout << "v1为空" << endl;
}
else {
cout << "v1不为空" << endl;
cout << "v1容量为: " << v1.capacity() << endl;
cout << "v1大小为: " << v1.size() << endl;
}
//重新指定大小
v1.resize(15);
printVector3(v1);
cout << "reize为15后v1的容量为: " << v1.capacity() << endl;
v1.resize(15, 100);
printVector3(v1);
//如果大小变小,会删除
v1.resize(5);
printVector3(v1);
cout << "reize为5后v1的容量为: " << v1.capacity() << endl;
}
int main() {
test3_01();
system("pause");
return 0;
}
2.4 inserción y eliminación de vectores
Prototipo de función:
push_back(ele); //尾部插入元素ele
pop_back(); //删除最后一个元素
insert(const_iterator pos, ele); //迭代器指向位置pos插入元素ele
insert(const_iterator pos, int count, ele); //迭代器指向位置pos插入count个元素ele
erase(const_ iterator pos); //删除迭代器指向的元素
erase(const_ iterator start, const_ iterator end); //删除迭代器从start到end之间的元素
clear(); //删除容器中所有元素
Ejemplo:
#include<iostream>
using namespace std;
#include<vector>
//push_back(ele); //尾部插入元素ele
//pop_back(); //删除最后一个元素
//insert(const_iterator pos, ele); //迭代器指向位置pos插入元素ele
//insert(const_iterator pos, int count, ele); //迭代器指向位置pos插入count个元素ele
//erase(const_ iterator pos); //删除迭代器指向的元素
//erase(const_ iterator start, const_ iterator end); //删除迭代器从start到end之间的元素
//clear(); //删除容器中所有元素
void printVector4(vector<int> v) {
for (vector<int>::iterator it = v.begin(); it != v.end(); it++) {
cout << *it << " ";
}
cout << endl;
}
void test4_01() {
vector<int> v1;
for (int i = 0; i < 10; i++) {
v1.push_back(i * 10);
}
printVector4(v1);
//删除尾部元素
v1.pop_back();
printVector4(v1);
//插入元素,参数是迭代器
v1.insert(v1.begin() + 2, 100); //在第三个位置插入元素
printVector4(v1);
v1.insert(v1.begin(), 2, 1000); //在首位置插入依次2个1000
printVector4(v1);
//删除,参数也是迭代器
v1.erase(v1.begin());
printVector4(v1);
v1.erase(v1.begin(), v1.end() - 5); //删除指定区间的元素,留下后5个元素
printVector4(v1);
//清空容器
v1.clear();
printVector4(v1);
}
int main() {
test4_01();
system("pause");
return 0;
}
2.5 acceso a datos vectoriales
Prototipo de función:
at(int idx); //返回索引idx所指的数据
operator[]; //返回索引idx所指的数据
front(); //返回容器中第一个数据元素
back(); //返回容器中最后一个数据元素
Ejemplo:
#include<iostream>
using namespace std;
#include<vector>
//at(int idx); //返回索引idx所指的数据
//operator[]; //返回索引idx所指的数据
//front(); //返回容器中第一个数据元素
//back(); //返回容器中最后一个数据元素
void test5_01() {
vector<int> v1;
for (int i = 0; i < 10; i++) {
v1.push_back(i);
}
//利用 []
for (int i = 0; i < v1.size(); i++) {
cout << v1[i] << " ";
}
cout << endl;
//利用 at()
for (int i = 0; i < v1.size(); i++) {
cout << v1.at(i) << " ";
}
cout << endl;
//返回第一个元素
cout << v1.front() << endl;
//返回最后一个元素
cout << v1.back() << endl;
}
int main() {
test5_01();
system("pause");
return 0;
}
Contenedor intercambiable de 2,6 vectores, el uso inteligente del intercambio puede reducir el espacio de memoria
Vector admite el intercambio directo de elementos en dos contenedores.
Prototipo de función:
swap(vec); //将vec与本身的元素互换
Y el espacio de memoria del objeto vectorial se puede reducir a través de la función swap().
Ejemplo:
#include<iostream>
using namespace std;
#include<vector>
//swap(vec); //将vec与本身的元素互换
void printVector6(vector<int>& v) {
for (vector<int>::iterator it = v.begin(); it != v.end(); it++) {
cout << *it << " ";
}
cout << endl;
}
void test6_01() {
vector<int> v1,v2;
for (int i = 0; i < 10; i++) {
v1.push_back(i);
v2.push_back(9-i);
}
cout << "交换前" << endl;
printVector6(v1);
printVector6(v2);
//v1.swap(v2);
swap(v1, v2); //两种都可以
cout << "交换后" << endl;
printVector6(v1);
printVector6(v2);
}
//巧用swap可以收缩内存空间
void test6_02() {
vector<int> v;
for (int i = 0; i < 10000; i++) {
v.push_back(i);
}
cout << "v的容量为: " << v.capacity() << endl;
cout << "v的大小为: " << v.size() << endl;
v.resize(3);
cout << "v的容量为: " << v.capacity() << endl; //容量不会收缩
cout << "v的大小为: " << v.size() << endl;
//用swap
//使用匿名对象方法vector<int>(v),这是有参构造将v作为参数传入,因为只穿入元素,所以生成的对象容量和大小都是v的元素个数
//经过交换,使得v的容量被收缩
vector<int>(v).swap(v);
cout << "v的容量为: " << v.capacity() << endl;
cout << "v的大小为: " << v.size() << endl;
//同理也可以用此方法指定v的容量和大小
vector<int>(10).swap(v);
cout << "v的容量为: " << v.capacity() << endl;
cout << "v的大小为: " << v.size() << endl;
}
int main() {
test6_01();
test6_02();
system("pause");
return 0;
}
2.7 espacio reservado
El propósito del espacio reservado en el vector es reducir el número de expansiones cuando se expande dinámicamente la capacidad.
Prototipo de función:
reserve(int len); //容器预留len个元素长度,预留位置不会初始化,元素不可访问
Ejemplo:
#include<iostream>
using namespace std;
#include<vector>
//reserve(int len); //容器预留len个元素长度,预留位置不会初始化,元素不可访问
void test7_01() {
vector<int> v;
int num=0; //统计开辟次数
int* p = NULL;
for (int i = 0; i < 100000; i++) {
v.push_back(i);
if (p != &v[0]) {
//每次开辟内存都会改变地址
p = &v[0];
num++;
}
}
cout << "开辟了: " << num << "次" << endl;
}
void test7_02() {
vector<int> v;
v.reserve(100000);
int num = 0; //统计开辟次数
int* p = NULL;
for (int i = 0; i < 100000; i++) {
v.push_back(i);
if (p != &v[0]) {
//每次开辟内存都会改变地址
p = &v[0];
num++;
}
}
cout << "开辟了: " << num << "次" << endl;
}
int main() {
test7_01();
test7_02();
system("pause");
return 0;
}
3 contenedores deque
2.0 deque concepto básico
función :
- Matriz de dos extremos, que puede realizar operaciones de inserción y eliminación en la cabecera
La diferencia entre deque y vector :
- La inserción y eliminación de la cabeza del vector es ineficiente y cuanto mayor es el volumen de datos, menor es la eficiencia. En términos relativos, deque inserta y elimina la cabeza más rápido que vector.
- La velocidad de los elementos de acceso vectorial es más rápida que la de deque (necesidad de usar la búsqueda de direcciones), lo que está relacionado con la implementación interna de los dos.
El principio de funcionamiento interno de deque: hay un controlador central
dentro de deque , que mantiene el contenido en cada búfer y almacena datos reales en el búfer. El controlador mantiene la dirección de cada búfer, haciéndolo parecer un espacio de memoria continuo cuando se usa deque.
- El iterador del contenedor deque también admite acceso aleatorio.
3.1 constructor de deque
Prototipo de función:
deque<T> deqT; //默认构造形式
deque(beg, end); //构造函数将[beg, end)区间中的元素拷贝给本身。
deque(n, elem); //构造函数将n个elem拷贝给本身。
deque(const deque& deq); //拷贝构造函数
Ejemplo:
#include<iostream>
#include<deque>
using namespace std;
void printDeque(deque<int>& d) {
for (deque<int>::const_iterator it = d.begin(); it != d.end(); it++) {
//*it = 100; #使用const_iterator时不能改变它的值
cout << *it << " ";
}
cout << endl;
}
void test1_01() {
deque<int> d1;
for (int i = 0; i < 10; i++) {
d1.push_back(i);
}
printDeque(d1);
deque<int> d2(d1.begin(),d1.end());
printDeque(d2);
deque<int> d3(10, 100);
printDeque(d3);
deque<int> d4(d3);
printDeque(d4);
}
int main() {
test1_01();
system("pause");
return 0;
}
3.2 Operación de asignación
Prototipo de función (igual que vector):
deque& operator=(const deque& deq);
assign(beg, end);
assign(n, elem); //将n个elem赋值给deque
Ejemplo:
#include<iostream>
#include<deque>
using namespace std;
void printDeque3(const deque<int>&d) {
for (deque<int>::const_iterator it = d.begin(); it != d.end(); it++)
{
cout << *it << " ";
}
cout << endl;
}
void test3_01()
{
deque<int> d1;
for (int i = 0; i < 10; i++) {
d1.push_back(i);
}
printDeque3(d1);
deque<int>d2;
d2 = d1;
printDeque3(d2);
deque<int>d3;
d3.assign(d1.begin(), d1.end());
printDeque3(d3);
deque<int>d4;
d4.assign(10, 100);
printDeque3(d4);
}
int main()
{
test3_01();
system("pause");
return 0;
}
3.3 Operación de tamaño
Prototipo de función:
deque.empty(); 判断容器是否为空
deque.size(); 返回容器中元素的个数
deque.resize(num); 重新指定容器的长度为num, 若容器变长，则以默认值0填充新位置。如果容器变短，则末尾超出容器长度的元素被删除。
deque.resize(num，elem); 重新指定容器的长度为num,若容器变长，则以elem值填充新位置。如果容器变短，则末尾超出容器长度的元素被删除。
Ejemplo:
#include<iostream>
#include<deque>
using namespace std;
void printDeque3(const deque<int>& d)
{
for (deque<int>::const_iterator it = d.begin(); it != d.end(); it++)
{
cout << *it << " ";
}
cout << endl;
}
void test3_01()
{
deque<int> d1;
cout << d1.empty() << endl;
for (int i = 0; i < 10; i++)
{
d1.push_back(i);
}
cout << d1.empty() << endl;
printDeque3(d1);
cout << "d1的大小:" << d1.size() << endl;
//deque没有容量大小,可以一直插入数据
d1.resize(20);
printDeque3(d1);
d1.resize(25, 1);
printDeque3(d1);
d1.resize(5);
printDeque3(d1);
}
int main()
{
test3_01();
system("pause");
return 0;
}
3.4 Inserción y eliminación
Prototipo de función:
Insertar operación en ambos extremos:
push_back(elem) ; 在容器尾部添加一个数据
push_front(elem ); 在容器头部插入一个数据
pop_back(); 删除容器最后一个数据
pop_front( ) ; 删除容器第一个数据
Operación de posición especificada:
insert(pos,elem); 在pos位置插入一个elem元素的拷贝，返回新数据的位置。
insert(pos,n,elem); 在pos位置插入n个elem数据，无返回值。
insert(pos,beg,end); 在pos位置插入[beg,end)区间的数据，无返回值。
clear(); 清空容器的所有数据
erase(beg,end); 删除[beg,end)区间的数据，返回下一个数据的位置。
erase(pos) ; 删除pos位置的数据，返回下一个数据的位置。
Ejemplo:
#include<iostream>
using namespace std;
#include<deque>
void printDeque4(const deque<int>& d)
{
for (deque<int>::const_iterator it = d.begin(); it != d.end(); it++)
{
cout << *it << " ";
}
cout << endl;
}
void test4_01()
{
deque<int> d1;
//尾插
d1.push_back(10);
d1.push_back(20);
//头插
d1.push_front(100);
d1.push_front(200);
printDeque4(d1);
//尾删
d1.pop_back();
printDeque4(d1);
//头删
d1.pop_front();
cout << "d1" << endl;
printDeque4(d1);
deque<int> d2;
d2.push_back(10);
d2.push_back(20);
d2.push_front(100);
d2.push_front(200);
cout << "d2" << endl;
printDeque4(d2);
d2.insert(d2.begin(), 1000);
printDeque4(d2);
d2.insert(d2.begin(), 5,10000);
printDeque4(d2);
//按照区间插入
deque<int> d3;
d3.push_back(1);
d3.push_back(2);
d3.push_back(3);
cout << "d3" << endl;
printDeque4(d3);
d3.insert(d3.begin(), d1.begin(), d1.end()); //(pos,[begin,end))
printDeque4(d3);
//删除
deque<int>::iterator it = d3.begin();
it++;
d3.erase(it);
printDeque4(d3);
//按区间方式删除
d3.erase(d3.begin(), d3.end()); //和d3.clear()效果一样
printDeque4(d3);
}
int main()
{
test4_01();
system("pause");
return 0;
}
3.5 Acceso a datos
Prototipo de función:
at(int idx); //返回索引idx所指的数据
operator[]; //返回索引idx所指的数据
front(); //饭回容器中第一个数据元素
back(); //返回容器中最后一个数据元素
Ejemplo:
#include<iostream>
#include<deque>
using namespace std;
void test5_01()
{
deque<int> d;
d.push_back(1);
d.push_back(2);
d.push_back(3);
d.push_front(100);
d.push_front(200);
d.push_front(300);
for (int i = 0; i < d.size(); i++)
{
cout << d[i] << " ";
}
cout << endl;
for (int i = 0; i < d.size(); i++)
{
cout << d.at((d.size()-1) - i) << " ";
}
cout << endl;
cout << "第一个元素为：" << d.front() << endl;
cout << "最后的元素为：" << d.back() << endl;
}
int main()
{
test5_01();
system("pause");
return 0;
}
3.6 clasificación de deque
Prototipo de función:
#include<algorithm>
sort(iterator beg, iterator end) ll对beg和end区间内元素进行排序
sort se puede usar con cualquier contenedor que admita iteradores de acceso aleatorio.
Un iterador de acceso aleatorio significa que la posición a la que apunta el iterador se puede mover hacia adelante o hacia atrás n posiciones, y también se pueden obtener los datos del contenedor.
Al juzgar, podemos juzgar si el iterador del contenedor es un iterador de acceso aleatorio al juzgar si el iterador del contenedor admite la operación "+n". Los iteradores de vector, deque y cadena admiten el acceso aleatorio, pero los iteradores de lista no.
Ejemplo:
#include<iostream>
#include<deque>
#include<algorithm>
using namespace std;
void printDeque6(deque<int>& d)
{
for (deque<int>::iterator it = d.begin(); it != d.end(); it++)
{
cout << *it << " ";
}
cout << endl;
}
void test6_01()
{
deque<int> d;
d.push_back(10);
d.push_back(20);
d.push_back(3);
d.push_front(200);
d.push_front(500);
d.push_front(300);
printDeque6(d);
//默认升序
//对于支持随机访问迭代器的容器都可以使用sort.
//deque,vector,
sort(d.begin(), d.end());
printDeque6(d);
}
int main()
{
test6_01();
system("pause");
return 0;
}