definición
Contenedor: clases de plantilla y bibliotecas de funciones que pueden manipular una variedad de estructuras de datos y algoritmos. En realidad, se pueden almacenar varios tipos de objetos como contenedores, y todos los objetos de un contenedor deben ser del mismo tipo.
Los contenedores se dividen en dos categorías: contenedores secuenciales y contenedores asociativos.
Contenedor secuencial
Hay tres tipos de contenedores secuenciales: vector , deque y list .
Se denominan contenedores secuenciales porque la posición del elemento en el contenedor no tiene nada que ver con el valor del elemento, es decir, el contenedor no está ordenado. Al insertar un elemento en un contenedor, especifique dónde insertarlo (cola, cabeza o en algún lugar en el medio) y dónde se ubicará el elemento.
1.
Estructura de almacenamiento continuo vectorial , cada elemento es continuo en la memoria,
admite el acceso aleatorio eficiente y las operaciones de inserción / eliminación al final, pero las operaciones de inserción / eliminación en otras posiciones son ineficientes;
2. Deque
estructura de almacenamiento continuo, es decir, cada elemento es continuo en la memoria, similar al vector, la diferencia es que deque proporciona una estructura de matriz de dos niveles, el primer nivel es completamente similar al vector, que representa el contenedor real; el otro La primera dirección del contenedor se mantiene en el nivel.
De esta manera, además de todas las funciones de vector, deque también admite operaciones de inserción / eliminación de primer nivel eficientes.
3. La lista es una
estructura de almacenamiento no contigua con una estructura de lista de doble enlace.Cada elemento mantiene un par de punteros hacia adelante y hacia atrás, por lo que se admite el recorrido hacia adelante / hacia atrás.
Admite operaciones de inserción / eliminación aleatorias eficientes, pero el acceso aleatorio es ineficaz y la sobrecarga es relativamente grande debido a la necesidad de mantener punteros adicionales.
La elección del contenedor secuencial:
a. Si necesita una operación de acceso aleatorio, seleccione vector;
b. Si ya conoce la cantidad de elementos que deben almacenarse, seleccione vector;
c. Si necesita insertar / eliminar aleatoriamente (no solo en ambos extremos), seleccione la lista
d.Solo seleccione deque cuando se requieran operaciones de inserción / eliminación en la cabecera; de lo contrario, seleccione el vector.
e. Si necesita insertar / eliminar aleatoriamente y acceder aleatoriamente, necesita hacer un compromiso entre vector y lista.
f. Cuando desee almacenar un objeto de clase responsable grande, la lista es mejor que el vector; por supuesto, también puede usar el vector para almacenar punteros a objetos en este momento, lo que también logrará una mayor eficiencia, pero el mantenimiento del puntero es muy erróneo. propenso No recomendado.
Nota : Los iteradores de vector y deque admiten operaciones aritméticas, y los iteradores de list solo pueden realizar operaciones ++ / - y no admiten operaciones aritméticas ordinarias.
Contenedor asociativo
Hay cuatro tipos de contenedores asociativos: set , multiset , map y multimap .
Los elementos del contenedor asociativo están ordenados. Al insertar un elemento, el contenedor colocará el elemento en una posición adecuada de acuerdo con una determinada regla de clasificación, por lo que la posición no se puede especificar al insertar un elemento.
De forma predeterminada, los elementos del contenedor asociativo se ordenan de menor a mayor (o de menor a mayor por palabra clave), y el operador <se utiliza para comparar el tamaño del elemento o de la palabra clave. Debido a que está ordenado, los contenedores asociativos tienen muy buen rendimiento al mirar hacia arriba.
Además de los dos tipos de contenedores anteriores, STL también protege algunas funciones sobre la base de los dos tipos de contenedores, resalta o agrega otra parte de las funciones e implementa tres adaptadores de contenedor: pila (pila), cola (cola), Priority_queue (cola de prioridad).
Función contenedor
Todos los contenedores tienen las siguientes dos funciones miembro:
int size (): devuelve el número de elementos en el objeto contenedor.
bool empty (): determina si el objeto contenedor está vacío.
Los contenedores de secuencia y los contenedores asociativos también tienen las siguientes funciones miembro:
begin (): devuelve un iterador que apunta al primer elemento del contenedor.
end (): Devuelve un iterador que apunta a la posición después del último elemento del contenedor.
rbegin (): Devuelve un iterador inverso que apunta al último elemento del contenedor.
rend (): Devuelve un iterador inverso que apunta a la posición antes del primer elemento en el contenedor.
borrar (...): Elimina uno o varios elementos del contenedor.
clear (): Elimina todos los elementos del contenedor.
Si un contenedor está vacío, los valores de retorno de begin () y end () son iguales, y los valores de retorno de rbegin () y rend () también son iguales.
El contenedor de secuencia también tiene las siguientes funciones miembro de uso común:
front (): Devuelve una referencia al primer elemento del contenedor.
back (): Devuelve una referencia al último elemento del contenedor.
push_back (): agrega un nuevo elemento al final del contenedor.
pop_back (): Elimina el elemento al final del contenedor.
insert (...): inserta uno o más elementos. Los parámetros de esta función son más complicados y se omiten aquí.
Ejemplo
(Aquí hay solo algunos contenedores y algunos usos de funciones)
Contenedor secuencial:
contenedor de vectores
void main() //遍历、删除、插入
{
vector<int> v1;
v1.push_back(10); //copy 到申请的容器
v1.push_back(20);
v1.push_back(30);
//访问容器，定义一个迭代器: 相当于一个指针
//正向遍历
for(vector<int>::iterator it = v1.begin();it != v1.end();it++)
{
cout<<*it<<endl;
}
//逆向遍历
for(vector<int>::reverse_iterator rit = v1.rbegin();rit != v1.rend();rit++)
{
cout<<*rit<<endl;
}
//区间删除
v1.erase(v1.begin(),v1.begin()+2);
//指定位置删除
v1.erase(v1.begin());
//遍历删除
for(vector<int>::iterator dit = v1.begin();dit != v1.end();)
{
if(*dit == 2)
{
v1.erase(dit); //当删除迭代器所指向元素时，erase让it自下移
}
else
{
dit++;
}
}
//插入元素
v1.insert (v1.begin(),100); //头部插入数值100
v1.insert (v1.end (),200); //尾部插入数值200
return;
}
contenedor deque
void printd(deque<int> &d)
{
for(deque<int>::iterator it = d.begin(); it != d.end();it++)
{
cout<<"元素"<<*it<<endl;
}
}
void main()
{
deque<int> d;
d.push_back(1); //在容器末尾增加新元素
d.push_back(2);
d.push_front(3); //在容器头尾增加新元素
d.push_front(4);
printd(d);
deque<int>::iterator it = find(d.begin(),d.end(),3); //查找指定元素3 找到时，返回该元素的迭代器；找不到时，返回end()。
if(it != d.end())
{
cout<<"3与第一个元素的距离为："<<distance(d.begin (),it)<<endl;
}
}
Contenedor asociativo:
conjunto contenedor
void main()
{
set<int> set1;
//循环插入
for(int i = 0;i < 3;i ++)
{
int tmp = rand() % 5;
set1.insert(tmp);
}
//遍历打印集合
for(set<int>::iterator it = set1.begin();it != set1.end(); it++)
{
cout<<*it<<endl;
}
//删除集合
while(!set1.empty())
{
set<int>::iterator item = set1.begin();
set1.erase(item);
}
return;
}
contenedor de mapas
//元素的添加、遍历、删除等基本操作
void main()
{
//1、创建map对象
map<int, string> map1;
//方法1 添加元素 pair是一个有两个元素的结构体，方便使用，类似map ：键值可以随意使用
//pair可以用来当做map的键值来插入 pair<T1,T2> p1 创建一个空的pair对象，有两个元素T1和T2，采用值初始化
map1.insert(pair<int, string>(1,"hehe"));
map1.insert(pair<int, string>(2,"xixi"));
//方法2 添加元素 make_pair
//make_pair
map1.insert(make_pair(3,"haha"));
map1.insert(make_pair(4,"huhu"));
//方法3 添加元素
map1.insert(map<int, string>::value_type(5,"kaka"));
map1.insert(map<int, string>::value_type(6,"yiyi"));
//方法4 数组方式插入数据
map1[7] = "yaya";
//容器遍历(迭代器)
for(map<int, string>::iterator it = map1.begin();it != map1.end(); it++)
{
cout<<it->first<<"\t"<<it->second <<endl;
}
cout<<"遍历结束"<<endl;
//容器的删除
while(!map1.empty())
{
map<int, string>::iterator it = map1.begin();
map1.erase(it);
}
//map查找
map<int, string>::iterator it1 = map1.find(2);
if(it1 != map1.end())
{
cout<<"不存在"<<endl;
}
else
{
cout<<it1->first<<"\t"<<it1->second<<endl;
}
}