prefacio
Conceptos básicos de STL
1. STL (Biblioteca de plantillas estándar, biblioteca de plantillas estándar)
2. STL se divide en términos generales en: contenedor (contenedor), algoritmo (algoritmo), iterador (iterador)
3. Conexión perfecta entre contenedores y algoritmos a través de iteradores.
4. Casi todos los códigos en STL usan clases de plantilla o funciones de plantilla.
1. Conociendo STL por primera vez
1.1 STL se divide aproximadamente en seis componentes principales
Ellos son: contenedor, algoritmo, iterador, functor, adaptador (adaptador), configurador de espacio
1. Contenedor: se utilizan varias estructuras de datos, como vector, lista, deque, conjunto, mapa, etc., para almacenar datos.
2. Algoritmos: varios algoritmos de uso común, como ordenar, buscar, copiar, for_each, etc.
3. Selector de generación: actúa como pegamento entre el contenedor y el algoritmo.
4. Functor: el comportamiento es similar a una función, que puede usarse como una determinada estrategia del algoritmo.
5. Adaptador: algo que se utiliza para modificar un contenedor, un functor o una interfaz de iterador.
6. Configurador de espacios: responsable de la configuración y gestión del espacio.
1.1.1 Contenedores
Contenedor: un lugar para el almacenamiento
Los contenedores STL son estructuras de datos de uso común que implementan algunas de las estructuras de datos más utilizadas : matrices, listas enlazadas, árboles, pilas, conjuntos de colas, tablas de mapeo, etc. Estos contenedores se dividen en dos tipos : contenedores secuenciales y contenedores asociativos :
Contenedor secuencial: enfatiza la clasificación de valores y cada elemento en el contenedor secuencial tiene una posición fija.
Contenedor asociativo: una estructura de árbol binario, no existe una relación de orden físico estricta entre los elementos.
1.1.2 Algoritmos
Algoritmos: soluciones a problemas
Pasos limitados para resolver problemas lógicos o matemáticos, a este tema lo llamamos Algoritmos (Algoritmos) Los algoritmos se dividen en: algoritmo de cambio cualitativo y algoritmo de cambio no cualitativo .
Algoritmo de cambio cualitativo: significa que el contenido de los elementos en el intervalo cambiará durante la operación . como copiar, reemplazar, eliminar, etc.
Algoritmo no cualitativo: significa que el contenido de los elementos en el intervalo no cambiará durante la operación , como buscar, contar, recorrer, encontrar valores extremos, etc.
1.1.3 Iteradores
Iteradores: el pegamento entre contenedores y algoritmos
Proporciona una forma de acceder secuencialmente a los elementos de un contenedor sin exponer la representación interna del contenedor. Cada contenedor tiene su propio iterador.
El uso de iteradores es muy similar al de los punteros . En la etapa inicial, primero podemos entender que los iteradores son punteros.
*** Los iteradores bidireccionales y los iteradores de acceso aleatorio se utilizan comúnmente .
2. Contenedores, Algoritmos, Iteradores
El contenedor más utilizado en STL es el vector, que puede entenderse como una matriz.
2.1 contenedor de vectores
Contenedor: vector
Algoritmo: para_cada uno
Iterador: vector<int>::iterador
En el siguiente ejemplo, el contenedor de vectores debe incluir el archivo de encabezado " #include <vector> " cuando se usa , y la función "push_back()" se usa para insertar datos. comenzar() apunta al primer elemento en el contenedor para el iterador inicial . end() finaliza el iterador apuntando a la siguiente posición del último elemento en el contenedor.
Los pasos para crear un contenedor de vectores se pueden dividir en tres pasos :
1. Crea un contenedor
2. Agregar datos al contenedor
3. Recorre los datos en el contenedor.
#include <iostream>
using namespace std;
#include <vector>
#include <algorithm>//标准算法头文件
//vector容器存放内置数据类型
void myprint(int val)
{
cout << val << endl;
}
void test01()
{
//1.创建了一个vector容器（可以理解为数组）
vector<int> v;//vector容器在使用时需要包含头文件
//2.向容器中插入数据
v.push_back(10);
v.push_back(20);
v.push_back(30);
v.push_back(40);
//3.通过迭代器访问容器中的数据
vector<int>::iterator itbegin = v.begin();//begin()起始迭代器 指向容器中第一个元素
vector<int>::iterator itend = v.end();//end()结束迭代器 指向容器中最后一个元素的下一个位置
//第一种遍历方式
while (itbegin != itend)
{
cout << *itbegin << endl;
itbegin++;
}
//第二种遍历方式
cout << "第二种遍历方式" << endl;
for (vector<int>::iterator it = v.begin(); it != v.end(); it++)
{
cout << *it << endl;
}
//第三种遍历方式 利用STL提供的遍历算法
cout << "第三种遍历方式" << endl;
for_each(v.begin(), v.end(), myprint);
}
int main()
{
test01();
system("pause");
return 0;
}El primer método transversal.
Utilice el bucle while para atravesar
El segundo método transversal.
// El segundo método transversal
for (vector<int>::iterador it = v.begin(); it != v.end(); it++)
{ cout << *it << endl; }
El tercer método transversal utiliza el algoritmo transversal proporcionado por STL.
Utilice la función for_each() proporcionada por STL, pero el uso de esta función debe incluir el archivo de encabezado del algoritmo estándar " #include <algoritmo> ".
void miimpresión(int val)
{ cout << val << endl; }// El tercer método transversal utiliza el algoritmo transversal proporcionado por STL
for_each(v.begin(), v.end(), miimpresión);
2.2 Poner una matriz personalizada en el contenedor de vectores
#include <iostream>
using namespace std;
#include <string>
#include <vector>
#include <algorithm>//标准算法头文件
//vector容器存放自定义数据类型
class person
{
public:
person(string name,int age)
{
this->m_name = name;
this->m_age = age;
}
string m_name;
int m_age;
};
void test01()
{
//1.创建容器
vector<person> v;
person p1("li", 18);
person p2("chen", 21);
person p3("shuo", 23);
person p4("wang", 20);
person p5("wei", 22);
//2.向容器中添加数据
v.push_back(p1);
v.push_back(p2);
v.push_back(p3);
v.push_back(p4);
v.push_back(p5);
//3.遍历容器中的数据
for (vector<person>::iterator it = v.begin(); it != v.end(); it++)
{
cout << "姓名：" << (*it).m_name << " 年龄：" << it->m_age << endl;
//it本质为一个指针，（*it）解引用后就是vector后面<>里面的数据类型，这里就是person
//it也可以像指针那样直接用 -> 指向属性
}
}
//存放自定义数据类型 指针
void test02()
{
//1.创建容器
vector<person*> v;
person p1("li", 18);
person p2("chen", 21);
person p3("shuo", 23);
person p4("wang", 20);
person p5("wei", 22);
//2.向容器中添加数据
v.push_back(&p1);
v.push_back(&p2);
v.push_back(&p3);
v.push_back(&p4);
v.push_back(&p5);
//3.遍历容器中的数据
for (vector<person*>::iterator it = v.begin(); it != v.end(); it++)
{
cout << "test2姓名：" << (*it)->m_name << " test2年龄：" << (*it)->m_age << endl;//这里的(*it)是一个指针
}
}
int main()
{
test01();
test02();
system("pause");
return 0;
}El contenedor de vectores en test01() es una clase de persona. Aquí es esencialmente un puntero. Después de desreferenciar (*it), es el tipo de datos en <> detrás del vector, aquí está la persona. También se puede utilizar directamente como puntero -> para señalar un atributo.
El contenedor de vectores en test02() es un puntero a persona*. Aquí (*it) es de tipo persona* después de la desreferenciación, que es un puntero. Necesita (*it)->m_name y (*it)->m_age para apunte a Atributos.
2.3 Contenedor anidado
Un contenedor está anidado dentro de un contenedor, lo que equivale a una matriz bidimensional. Se requieren dos bucles for para el recorrido.
#include <iostream>
using namespace std;
#include <string>
#include <vector>
//容器嵌套容器
void test01()
{
vector<vector<int>> v;
//创建小容器
vector<int> v1;
vector<int> v2;
vector<int> v3;
vector<int> v4;
//向小容器里添加数据
for (int i = 0; i < 4; i++)
{
v1.push_back(i + 1);
v2.push_back(i + 2);
v3.push_back(i + 3);
v4.push_back(i + 4);
}
//将小容器插入到大容器中
v.push_back(v1);
v.push_back(v2);
v.push_back(v3);
v.push_back(v4);
//通过大容器，把所有数据遍历一遍
for (vector<vector<int>>::iterator it = v.begin(); it != v.end(); it++)
{
//(*it)——容器vector<int>
for (vector<int>::iterator it2 = (*it).begin(); it2 != (*it).end(); it2++)
{
cout << *it2 << " ";
}
cout << endl;
}
}
int main()
{
test01();
system("pause");
return 0;
}Tres, contenedor de cuerdas
3.1 Concepto básico de contenedor de cadenas
Esencia: la cadena es una cadena de estilo C ++ y la cadena es esencialmente una clase
Características:
la clase de cadena encapsula internamente muchos métodos miembros
Por ejemplo: buscar buscar, copiar copiar, eliminar eliminar reemplazar reemplazar, insertar insertar cadena
Administre la memoria asignada por char*, no se preocupe por copiar fuera de límites y valores fuera de límites, etc., la clase es responsable de ello
3.2 constructor de cadenas
3.3 operación de asignación de cadenas
3.4 concatenación de cadenas
Los siguientes son ejemplos de las siete operaciones anteriores:
#include <iostream>
using namespace std;
#include <string>
#include <vector>
//字符串拼接
void test01()
{
string str1 = "我";
str1 += "爱学C++";//"+="可以拼接string容器内的内容
cout << "str1 = " << str1 << endl;
str1 += '!';//可以追加一个字符
cout << "str1 = " << str1 << endl;
string str2 = "还有C语言和java";
str1 += str2;
cout << "str1 = " << str1 << endl;
string str3 = "I";
str3.append(" love");//可以利用 append()拼接
cout << "str3 = " << str3 << endl;
str3.append(" python 111", 7);
cout << "str3 = " << str3 << endl;
str3.append(str2);
cout << "str3 = " << str3 << endl;
string str4;
str4 = "我爱打游戏";
str4.append(str2, 0, 9);//一个中文占两个字节，一个英文一个字节。这里截取0~9个字节为：“还有C语言”
cout << "str4 = " << str4 << endl;
}
int main()
{
test01();
system("pause");
return 0;
}El resultado de ejecutar el código anterior es:
str1 = Me encanta aprender C++
str1 = ¡Me encanta aprender C++!
str1 = ¡Me encanta aprender C++! Y C y java
str3 = Me encanta
str3 = Me encanta python
str3 = Me encanta python y C y java
str4 = Me encanta There También es lenguaje C para jugar
, presione cualquier tecla para continuar...
3.5 búsqueda y reemplazo de cadenas
Descripción de la función:
Buscar: busca si la cadena especificada existe
Reemplazar: reemplaza la cadena en la posición especificada
#include<iostream>
using namespace std;
#include<string>
//字符串的查找替换
//1.查找(find ,rfind)
void test01()
{
string str1 = "abcdefgab";
int pos = str1.find("ab");
if (pos == -1)
{
cout << "未找到字符串" << endl;
}
else
{
cout<<"找到，pos=" << pos << endl;
}
//rfind
pos=str1.rfind("ab");
cout << "pos=" << pos << endl;
//find和rfind的区别
//find从左往右查找 rfind从右往左查找
}
//2.替换(replace)
void test02()
{
string str2="abcdefg";
str2.replace(1, 3, "111");//代表下标1~3用111代替
cout << "str2=" << str2<<endl;
}
int main()
{
test01();
test02();
system("pause");
return 0;
}El resultado de la operación es
encontrado, pos=0
pos=7
str2=a111efg
Resumir:
1. buscar búsquedas de izquierda a atrás, buscar de derecha a izquierda
2. buscar devuelve la posición del primer carácter encontrado después de encontrar la cadena y devuelve -1 si no se encuentra
3. Al reemplazar, debe especificar desde qué posición, cuántos caracteres y qué tipo de cadena reemplazar
3.6 comparación de cadenas de cadenas
La comparación de cadenas (usando la función comparar()) se basa en el código ASCLI del carácter.
1. = devolver 0
2. > devolver 1
3. <regresar -1
Prototipo de función:
1. int compare(const string &s ) const; //Comparar con string s
2. int comparar( const char *s ) const;//comparar con cadena s
El siguiente es el código del caso:
#include<iostream>
using namespace std;
#include<string>
//字符串的比较
void test01()
{
string str1 = "hellow";
string str2 = "hellow";
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 main()
{
test01();
system("pause");
return 0;
}3.7 acceso a caracteres de cadena
Hay dos formas de acceder a un solo carácter en una cadena:
1. char& operator[](int n); //Obtiene caracteres por [] (equivalente a sobrecargar corchetes)
2. char& at(int n); //Obtiene caracteres a través del método at
3.8 inserción y eliminación de cadenas
Descripción de la función: insertar (insertar) y eliminar (borrar) caracteres en cadenas de caracteres
Prototipo de función:
1. cadena& insertar(int pos, const char* s); //insertar cadena
2. cadena& insertar(int pos, const cadena& cadena); //insertar cadena
3. string& insert(int pos, int n, char c); //Inserta n caracteres c en la posición especificada
4. string& erase(int pos, int n = npos); // elimina n caracteres comenzando desde pos
El siguiente es el código de ejemplo, insertar(1, "***") significa insertar " *** " del carácter cuyo subíndice es 1,
borrar (1, 3) significa eliminar los caracteres del subíndice 1 ~ 3.
#include<iostream>
using namespace std;
#include<string>
//字符串插入与删除
void test01()
{
string str = "hellow";
//插入
str.insert(1, "***");
cout << "插入后str = " <<str<< endl;
//删除
str.erase(1, 3);
cout << "删除后str = " << str << endl;
}
int main()
{
test01();
system("pause");
return 0;
}Después de ejecutar, el resultado es el siguiente
Después de insertar str = h***ellow
Después de eliminar str = hellow
Por favor presione cualquier tecla para continuar. . .
3.9 subcadena de cadena
Descripción: obtiene la subcadena deseada de una cadena
Prototipo de función:
string substr(int pos = 0, int n = npos) const; // devuelve una cadena que consta de n caracteres comenzando desde pos
El siguiente es un caso de lectura de un nombre de usuario de buzón.
#include<iostream>
using namespace std;
#include<string>
void test01()
{
string email = "[email protected]";
//从邮箱地址中获取用户名信息
int pos=email.find("@");//查找@的位置
string usename = email.substr(0, pos);//需要从0开始截取8个
cout << "用户名：" << usename << endl;
}
int main()
{
test01();
system("pause");
return 0;
}El resultado de la operación es el siguiente:
Nombre de usuario: zhangsan
Por favor presione cualquier tecla para continuar. . .
Cuatro, contenedor vectorial
4.1 Concepto básico de vector
Función: la estructura de datos vectoriales es muy similar a una matriz, también conocida como matriz de un solo extremo.
La diferencia entre vector y matriz ordinaria : La diferencia es que la matriz es un espacio estático , mientras que el vector se puede expandir dinámicamente .
Expansión dinámica: en lugar de agregar un nuevo espacio después del espacio original, busque un espacio de memoria más grande y luego copie los datos originales al nuevo espacio para liberar el espacio original.
*** El iterador del contenedor de vectores es un iterador que admite acceso aleatorio.
4.2 constructor de vectores
Prototipo de función:
1. vector<T> v;//Implementación de clase de implementación de plantilla, constructor predeterminado
2. vector(v.begin(), v.end());//Copie los elementos en el intervalo v[begin(), end()) a sí mismo.
3. vector(n, elem);//El constructor copia n elementos a sí mismo.
4. vector(const vector &vec); //copiar constructor.
El siguiente es un caso demostrativo:
#include<iostream>
using namespace std;
#include<vector>
//vector容器构造
void printvector(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);
}
printvector(v1);
//2.通过区间方式进行构造、
vector<int>v2(v1.begin(), v1.end());
printvector(v2);
//3.n个elem方式构造
vector<int>v3(10, 100);//代表10个100
printvector(v3);
//4.拷贝构造
vector<int>v4(v3);
printvector(v4);
}
int main()
{
test01();
system("pause");
return 0;
}4.3 operación de asignación de vectores
Descripción de la función: asignar valor al contenedor de vectores
Prototipo de función:
1. vector& operador=(const vector &vec); //sobrecarga el operador de signo igual
asignar(beg, end); //asignar la copia de datos en el rango [beg,end) a sí mismo
asignar(n, elem); //Asignar n copias de elem a sí mismo.
#include<iostream>
using namespace std;
#include<vector>
//vector的赋值
void printvector(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);
}
printvector(v1);
//赋值
//方法一：用“=”号赋值
vector<int>v2;
v2 = v1;
printvector(v2);
//方法二：用assign赋值
vector<int>v3;
v3.assign(v1.begin(), v1.end());
printvector(v3);
//方法三：用n个elem赋值
vector<int>v4;
v4.assign(5,100);//5个100
printvector(v4);
}
int main()
{
test01();
system("pause");
return 0;
}4.4 capacidad y tamaño del vector
Descripción de la función: operar según la capacidad y el tamaño del contenedor de vectores
Prototipo de función:
1. vacío(); //juzgar si el contenedor está vacío
2. capacidad(); //La capacidad del contenedor
3. size(); //Devuelve el número de elementos en el contenedor
resize(int num); //Vuelve a especificar la longitud del contenedor como num, si el contenedor se hace más largo, llena la nueva posición con el valor predeterminado. Si el contenedor se acorta, se eliminan los elementos al final que exceden la longitud del contenedor.
4. resize(int num, elem); // Vuelva a especificar la longitud del contenedor como num, si el contenedor se alarga, complete el nuevo { con el valor del elem . Si el contenedor se acorta, se eliminan los elementos al final que exceden la longitud del contenedor.
Los siguientes son códigos de demostración de tres funciones vacías (), capacidad (), tamaño ():
#include<iostream>
using namespace std;
#include<vector>
//vector的容量和大小
void printvector(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);
}
printvector(v1);
if (v1.empty())
{
cout << "容器为空" << endl;
}
else
{
cout << "容器不为空,容量为：" <<v1.capacity() <<endl;
cout << "容器的大小为：" << v1.size() << endl;
}
//重新指定大小
v1.resize(15,-1);//利用重载版本，可以指定默认填充值（这里改成了用-1填充）
printvector(v1);//数据不足，默认用0填充
v1.resize(5);
printvector(v1);//大小比原先小，超出的部分会默认删除
}
int main()
{
test01();
system("pause");
return 0;
}4.5 Inserción y eliminación de contenedores de vectores.
Descripción de la función: operaciones de inserción y eliminación en contenedores vectoriales
Prototipo de función:
1. push_back(ele); // inserta el elemento ele al final
2. pop_back(); //Eliminar el último elemento
3. insert(const_iterator pos,ele); //El iterador apunta a la posición pos para insertar el elemento ele
4. insert(const_iterator pos, int count,ele); //El iterador apunta a la posición pos para insertar elementos de conteo
5. eleerase(const_iterator pos);//Elimina el elemento señalado por el iterador
6. erase(const_iterator start, const_iterator end);// Elimina los elementos entre el inicio y el final del iterador
7. clear(); //Elimina todos los elementos del contenedor
El siguiente es el código de demostración para la función anterior:
#include<iostream>
using namespace std;
#include<vector>
//vector的插入和删除
void printvector(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 = 10; i <= 50; i=i+10)
{
v1.push_back(i);
}
printvector(v1);
//尾删（ pop_back() ）
v1.pop_back();
printvector(v1);
//插入（ insert() ）(第一个参数是迭代器)
v1.insert(v1.begin(), 0);//在第0个下标插入0
printvector(v1);
v1.insert(v1.begin() + 3, 2, 25);//在第3个下标插入2个25
printvector(v1);
//删除（erase()）（参数也是迭代器）
v1.erase(v1.begin());
printvector(v1);
v1.erase(v1.begin(),v1.end()-1);//删除最后一个数前的所有数字
printvector(v1);
}
int main()
{
test01();
system("pause");
return 0;
}El siguiente es el resultado de la operación:
10 20 30 40 50
10
20
30 40 0 10 20 30 40 0 10 20 25 25 30 40
10 20 25 25 30 40 40
Presione
cualquier tecla para continuar. . .
resumen:
Tapón trasero --- push_back
Eliminación de cola --- pop_back
insertar --- insertar (iterador de posición)
eliminar --- borrar (iterador de posición)
Vacío --- claro
4.6 acceso a datos vectoriales
Descripción de la función: acceso a los datos en el vector.
Prototipo de función:
at(int idx); //devuelve los datos apuntados por el índice idx
operador[ ]; //Devuelve los datos apuntados por el índice idx
front(); //devuelve el primer elemento de datos en el contenedor
back(); //devuelve el último elemento de datos en el contenedor
El siguiente es el código de demostración:
#include<iostream>
using namespace std;
#include<vector>
//vector的数据存取
void test01()
{
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()
{
test01();
system("pause");
return 0;
}resumen:
1. Además de usar iteradores para obtener elementos en el contenedor de vectores, también se pueden usar [] y at
2. front devuelve el primer elemento del contenedor
3. back devuelve el último elemento del contenedor
4.7 contenedor de intercambio de vectores
Descripción de la función: realizar el intercambio de elementos en dos contenedores.
Prototipo de función: swap(vec); //intercambia vec con sus propios elementos
El siguiente es el código de demostración:
#include<iostream>
using namespace std;
#include<vector>
//vector的插入和删除
void printvector(vector<int>& v)//自定义打印函数
{
for (vector<int>::iterator it = v.begin(); it != v.end(); it++)
{
cout << *it << " ";
}
cout << endl;
}
void test01()
{
cout << "交换前：" << endl;
vector<int>v1;
for (int i = 0; i <10; i++)
{
v1.push_back(i);
}
printvector(v1);
vector<int>v2;
for (int i = 10; i>0; i--)
{
v2.push_back(i);
}
printvector(v2);
cout << "交换后：" << endl;
v1.swap(v2);
printvector(v1);
printvector(v2);
}
//2.实际用途
//巧用swap可以收缩内存空间
void test02()
{
vector<int>v3;
for (int i = 0; i < 10000; i++)
{
v3.push_back(i);
}
cout << "v3的容量为：" << v3.capacity() << endl;
cout << "v3的大学为：" << v3.size() << endl;
//重新指定大小
v3.resize(10);
cout << "v3的容量为：" << v3.capacity() << endl;
cout << "v3的大学为：" << v3.size() << endl;
//可以发现，这里得到容量被大量浪费了
//可以巧用swap收缩内存
vector<int>(v3).swap(v3);
cout << "v3的容量为：" << v3.capacity() << endl;
cout << "v3的大学为：" << v3.size() << endl;
}
int main()
{
test01();
test02();
system("pause");
return 0;
}El siguiente es el resultado de la operación:
Antes del intercambio:
0 1 2 3 4 5 6 7 8 9
10 9 8 7 6 5 4 3 2 1
Después del intercambio:
10 9 8 7 6 5 4 3 2 1 0 1 2 3 4
5 6 7 8 9
La capacidad de v3 es: 12138
Universidad para v3: 10000
Capacidad para v3: 12138
Universidad para
v3: 10 Capacidad para v3: 10
Universidad para v3: 10
Presione cualquier tecla para continuar. . .
4.8 espacio reservado vectorial
Descripción de la función: reducir el número de expansiones del vector al expandir dinámicamente la capacidad
Prototipo de función: reserve(int len); // El contenedor reserva la longitud de los elementos len, la posición reservada no se inicializa y los elementos son inaccesibles.
Cinco, contenedor deque
5.1 Conceptos básicos
Función: matriz de dos extremos, que puede insertar y eliminar la cabecera
La diferencia entre deque y vector :
1. La eficiencia de inserción y eliminación del vector para el encabezado es baja ; cuanto mayor es el volumen de datos, menor es la eficiencia
2. En términos relativos, deque insertará y eliminará el encabezado más rápido que el vector.
3. Cuando el vector accede a los elementos, será más rápido que deque, lo que está relacionado con la implementación interna de los dos.
La imagen proviene de las notas de la conferencia en video de Dark Horse Programmer.
El principio de funcionamiento interno de deque :
Hay un controlador central dentro del deque, que mantiene el contenido de cada búfer y almacena datos reales en el búfer. El controlador central mantiene la dirección de cada búfer, lo que hace que parezca un espacio de memoria continuo cuando se usa deque.
5.2 constructor deque
Descripción de la función: construcción de contenedores deque
Prototipo de función:
1. deque<T> deqT; //Forma de construcción predeterminada
2. deque(beg, end);//El constructor copia los elementos en el rango [beg, end) a sí mismo.
3. deque(n, elem);//El constructor copia n elementos a sí mismo.
4. dequé(const deque &deq); //copiar constructor
Resumen: Los métodos de construcción de contenedores deque y contenedores vectoriales son casi los mismos.
5.3 Asignación de contenedor Deque
Prototipo de función:
1. deque& operador=(const deque &deq); //sobrecarga operador de signo igual
2. asignar (inicio, fin); // Se asigna la copia de los datos en el rango [inicio, fin) a sí mismo.
3. asignar(n, elem); //Asignar n copias de elem a sí mismo.
5.4 operación de tamaño deque
Descripción de la función: operar según el tamaño del contenedor deque
Principio de funcionamiento:
deque.empty(); //Determina si el contenedor está vacío
deque.size(); //devuelve el número de elementos en el contenedor
deque.resize(num); // Vuelva a especificar la longitud del contenedor como num, si el contenedor se alarga, complete la nueva posición con el valor predeterminado. Si el contenedor se acorta, se eliminan los elementos al final que exceden la longitud del contenedor.
deque.resize(num, elem); // Vuelva a especificar la longitud del contenedor como num, si el contenedor se hace más largo, complete la nueva posición con el valor de elem. Si el contenedor se acorta, se eliminan los elementos al final que exceden la longitud del contenedor.
5.5 Inserción y eliminación de contenedores deque
Prototipo de función:
deque.empty(); //Determina si el contenedor está vacío
deque.size(); //devuelve el número de elementos en el contenedor
deque.resize(num); // Vuelva a especificar la longitud del contenedor como num, si el contenedor se alarga, complete la nueva posición con el valor predeterminado. Si el contenedor se acorta, se eliminan los elementos al final que exceden la longitud del contenedor.
deque.resize(num, elem);// Vuelva a especificar la longitud del contenedor como num, si el contenedor se alarga, complete la nueva posición con el valor de elem. Si el contenedor se acorta, se eliminan los elementos al final que exceden la longitud del contenedor.
5.6 Acceso a datos del contenedor deque
Prototipo de función:
at(int idx); //devuelve los datos apuntados por el índice idx
operador[];I/devuelve los datos apuntados por el índice idx front(); //devuelve el primer elemento de datos en el contenedor
back(); //devuelve el último elemento de datos en el contenedor
5.6 Inserción y eliminación de contenedor deque
algoritmo:
sort(iterator beg, iterator end) //Ordena los elementos en el rango de inicio y fin.