Directorio de artículos
Visión general
STL es un subconjunto de std
- STL (biblioteca de plantillas estándar), la biblioteca de plantillas estándar
- Una característica importante de STL es la separación de la estructura de datos y el algoritmo . Por ejemplo, dado que la función sort () de STL es completamente universal, puede usarla para manipular casi cualquier colección de datos, incluidas listas vinculadas, contenedores y matrices;
- Otra característica importante de STL es que no está orientada a objetos. Para ser lo suficientemente versátil, STL se basa principalmente en plantillas .
Seis componentes principales en STL:
Contenedor (contenedor) es un tipo de estructura de datos, como lista, vector y deques, proporcionada por el método de clase de plantilla. Para acceder a los datos en el contenedor, puede usar la salida del iterador por la clase de contenedor;
Iterator proporciona una forma de acceder a los objetos del contenedor. Por ejemplo, puede usar un par de iteradores para especificar un rango de objetos en una lista o vector. Un iterador es como un puntero. De hecho, los punteros de C ++ también son un iterador. Sin embargo, los iteradores también pueden ser objetos de clase que definen el operador * () y otros operadores de tipo puntero;
Algoritmo (Algoritmo) es una función de plantilla que se utiliza para manipular datos en el contenedor. Por ejemplo, STL usa sort () para ordenar los datos en un vector y find () para buscar objetos en una lista. Las funciones en sí no tienen nada que ver con la estructura y el tipo de datos con los que operan, por lo que pueden van desde matrices simples hasta usar en cualquier estructura de datos de contenedores altamente complejos;
Functor
Adaptador
Asignador
envase
Contenedor de secuencia: Vector; Deque; List;
Contenedor asociativo: Map / Multimap; Set / Multiset
Comprensión: vector
Matriz dinámica
La lista es una lista doblemente enlazada implementada por stl. En comparación con los vectores, permite una rápida inserción y eliminación, pero el acceso aleatorio es más lento.
** La lista no admite el acceso aleatorio, por lo que la eficiencia de acceso a los elementos es baja, ** la lista no tiene operadores at y subíndice
push_back & pop_back: agregar y eliminar al final del contenedor
#include <string.h>
#include <vector>
#include <iostream>
#include <algorithm>//sort算法包含
using namespace std;
int main()
{
vector<int>obj;//创建一个向量存储容器 int
/**********push_back*****/
for(int i=0;i<10;i++) // push_back(elem)在数组最后添加数据
{
obj.push_back(i);
cout<<obj[i]<<",";
}
cout<<endl;
/**********pop_back*****/
for(int i=0;i<5;i++)//去掉数组最后一个数据
{
obj.pop_back();
}
for(int i=0;i<obj.size();i++)//size()容器中实际数据个数
{
cout<<obj[i]<<",";
}
cout<<endl;
/**********sort&reverse*****/
obj.push_back(100);obj.push_back(-9);obj.push_back(20);
sort(obj.begin(),obj.end());//默认升序,也可以改变sort的定义如：sort(begin,end,compare)
vector<int>::iterator iter;
reverse(obj.begin(),obj.end());//只是改变方向，它不是排序
for(iter=obj.begin();iter!=obj.end();iter++)
{
cout<<*iter<<",";
}
cout<<endl;
/****at形式访问*******/
cout<<obj.at(2)<<endl;//at形式访问
obj.clear();//清空
cout<<"size:"<<obj.size();//size为0；
return 0;
}
Comprensión: lista
Comprensión: mapa
El mapa en C ++ proporciona un contenedor de pares clave-valor . Los datos que contiene aparecen en pares, como se muestra en la siguiente figura: el primer valor de cada par se llama clave, y cada palabra clave solo puede Ocurrir una vez en el mapa; el segundo se llama valor correspondiente de la clave.
Dentro del mapa se construye un árbol rojo-negro (un árbol binario no estrictamente equilibrado) que tiene la función de ordenar automáticamente los datos, por lo que todos los datos del mapa están en orden .
Tanto el mapa como el multimapa necesitan #include
par
También está en std (vector, list y map también están en std) , pero hay aplicaciones en map, así que hablemos de ello primero.
El tipo de par de tipos de biblioteca estándar se define en el archivo de encabezado #include y se define de la siguiente manera:
( Parece que se pueden utilizar tanto la utilidad como iostream. ¿Por qué? )
Plantilla de clase: plantilla <clase T1, clase T2> par de estructuras
Parámetros: T1 es el tipo de datos del primer valor, T2 es el tipo de datos del segundo valor.
Función: par combina un par de valores (T1 y T2) en un valor. Este par de valores puede tener diferentes tipos de datos (T1 y T2). Se puede acceder a los dos valores mediante las dos funciones públicas de par, primero y segundo, respectivamente.
Definir el constructor
pair <T1, T2> p1; // Crea un objeto de par vacío (usando la construcción predeterminada), sus dos elementos son de tipo T1 y T2, y se inicializan por valor.
pair <T1, T2> p1 (v1, v2); // Crea un objeto de par. Sus dos elementos son de tipo T1 y T2 respectivamente. El primer miembro se inicializa a v1 y el segundo miembro se inicializa a v2.
make_pair (v1, v2); // Crea un nuevo objeto de par con los valores de v1 y v2, cuyos tipos de elementos son v1 y v2 respectivamente.
p1 <p2; // La operación menor que entre dos objetos de par se define en el orden del diccionario: como p1.first <p2.first o! (p2.first <p1.first) && (p1.second <p2.second) Devuelve verdadero.
p1 == p2; // Si el primero y el segundo de dos objetos son iguales a su vez, los dos objetos son iguales; esta operación usa el operador element ==.
p1.first; // Devuelve el miembro de datos públicos nombrado primero en el objeto p1
p1.second; // Devuelve el miembro de datos públicos nombrado segundo en el objeto p1
P.ej:
pair<string, string> anon; // 创建一个空对象anon，两个元素类型都是string
pair<string, int> word_count; // 创建一个空对象 word_count, 两个元素类型分别是string和int类型
pair<string, vector<int> > line; // 创建一个空对象line，两个元素类型分别是string和vector类型
//下面是定义的时候初始化
pair<string, string> author("James","Joy"); // 创建一个author对象，两个元素类型分别为string类型，并默认初始值为James和Joy。
pair<string, int> name_age("Tom", 18);
Código:
empate la conexión de referencia
#include<iostream>
#include <tuple>//用于包含tie，std:Ltie
using namespace std;
//std::pair std::tie
std::pair<std::string, int> getPreson() {
return std::make_pair("Sven", 25);
}//这个是函数，返回值为pair类型
int main()
{
/********访问***************/
pair<int ,double> p1;
p1.first = 1;
p1.second = 2.5;
cout<<p1.first<<' '<<p1.second<<endl;
/*****利用make_pair创建新的pair对象**/
pair<int, double> p3;
p3 = make_pair(1, 1.2);
cout << p3.first << p3.second << endl;
/*****通过std::tie获取pair元素值***/
string name;
int ages;
tie(name, ages) = getPreson();
cout << "name: " << name << ", ages: " << ages << endl;
}
mapa
Los elementos del mapa se clasifican automáticamente por clave en orden ascendente, por lo que la función de clasificación no se puede utilizar en el mapa;
Comprensión del código:
#include <map>
#include <string>
#include <iostream>
using namespace std;
int main()
{
map<int, string> mapStudent =
{
{
0,"student_zero"}
}; //初始化
std::pair<map<int, string>::iterator, bool> ret;
mapStudent[1] = "student_one";//数组插入
ret = mapStudent.insert(pair<int, string>(1, "student_two")); //pair插入,并返回是否插入成功
mapStudent.insert(map<int, string>::value_type (2, "student_two"));//value_type插入
map<int, string>::iterator iter; //迭代器访问
for(iter = mapStudent.begin(); iter != mapStudent.end(); iter++)
cout<<iter->first<<' '<<iter->second<<endl;
if(!mapStudent.empty())
{
cout<<"size:"<<mapStudent.size()<<endl;//map的大小
cout<<"max_size:"<<mapStudent.max_size()<<endl;//最多存多少，和内存有关？
cout<<"map count"<<mapStudent.count(3)<<endl;//查找key的value个数，map非0即1
}
/********find*****/
iter = mapStudent.find(1);
cout<<"find num 1:"<<iter->second<<endl;
/*****erase*****/
map<int, string>::iterator iter_1; //迭代器访问
iter_1 = mapStudent.erase(iter);
cout<<"iter："<<iter->second<<endl;//原来的迭代器还在指向
cout<<"num 1:"<<iter_1->second<<endl<<endl;
for(iter = mapStudent.begin(); iter != mapStudent.end(); iter++)
cout<<iter->first<<' '<<iter->second<<endl;
}