STL primer conocido de C ++ Xiaobai
No hay mucho que decir, el tiempo de limpieza diario se acabó. Lo que quiero poner en orden hoy es STL (biblioteca de plantillas estándar). Sé un poco al respecto y creo que STL es realmente fácil de usar o ( ￣ ▽ ￣ ) ブ. Hoy es mi primer contacto con STL, así que resumámoslo.
1. STL inicial: el concepto básico de
STL 1.1 El nacimiento de STL
(1) Durante mucho tiempo, la industria del software ha estado esperando construir algo reutilizable.
(2) Las ideas de programación genérica y orientada a objetos de C ++ están destinadas a mejorar la reutilización.
(3) En la mayoría de los casos, las estructuras de datos y los algoritmos no tienen un conjunto de estándares, lo que se ve obligado a realizar mucho trabajo repetitivo.
(4) Con el fin de establecer un conjunto de estándares para estructuras de datos y algoritmos, nació STL.
1.2 Conceptos básicos de STL
(1) STL (biblioteca de plantillas estándar, biblioteca de plantillas estándar)
(2) STL se puede dividir ampliamente en: contenedor (contenedor), algoritmo (algoritmo), iterador (iterador)
(3) entre contenedor y algoritmo Conexión perfecta a través de iteradores
(4) Casi todos los códigos STL usan clases de plantilla o funciones de plantilla
1.3 Los seis componentes de
STL STL se divide aproximadamente en seis componentes, a saber: contenedor, algoritmo, iterador, functor, adaptador (adaptador), adaptador de espacio
1. Contenedor: varias estructuras de datos, como vector, lista, deque, conjunto, mapa etc. Se utiliza para almacenar datos.
2. Algoritmo: varios algoritmos de uso común, como ordenar, buscar, copiar, para cada uno, etc.
3. Iterador: actúa como pegamento entre el contenedor y el algoritmo.
4. Funciones: funciones similares se pueden utilizar como estrategia para algoritmos.
5. Adaptador: una cosa que se usa para decorar la interfaz de un contenedor o functor o iterador.
6. Adaptador de espacio: responsable de la configuración y gestión del espacio.
1.4 Contenedores, algoritmos e iteradores en STL
Contenedores: el lugar de almacenamiento. Los
contenedores STL implementan la estructura de datos más utilizada. Estructuras de datos más utilizadas
: matrices, listas enlazadas, números, pilas, colas, conjuntos, tablas de mapeo, etc.
Estos contenedores se dividen en dos tipos: contenedor de secuencia y contenedor asociativo: contenedor de
secuencia: enfatiza el orden de los valores, cada elemento en el contenedor de secuencia tiene una posición fija.
Contenedor asociativo: estructura de árbol binario, no existe una relación estricta de orden físico entre los elementos.
Algoritmo: La solución del problema también tiene
pasos limitados para resolver problemas lógicos o matemáticos. A este tema lo llamamos algoritmo (Algoritmos). Los
algoritmos se dividen en algoritmos cualitativos y no cualitativos.
Algoritmo de cambio cualitativo: Significa que el contenido de los elementos en el intervalo se cambiará durante la operación, como copiar, reemplazar, eliminar, etc.
Algoritmo no cualitativo: significa que el contenido del elemento en el intervalo no cambiará durante la operación, como buscar, contar, recorrer, encontrar valores extremos, etc.
Iterador: el pegamento entre el contenedor y el algoritmo.
Proporciona una forma de buscar secuencialmente los diversos elementos contenidos en un contenedor sin exponer la representación interna del contenedor.
Cada contenedor tiene su propio
iterador. El uso de iteradores es muy similar a los punteros. En la etapa inicial, puedes entender que los iteradores son punteros.
Tipos de
iteradores : iteradores de entrada
Los tipos de iteradores que se usan comúnmente en los contenedores son los iteradores bidireccionales y los iteradores de acceso aleatorio.
1.5 Vector almacena los tipos de datos incorporados
Contenedor:
algoritmo de vector : para cada
iterador: vector :: iterador
Archivo de encabezado del algoritmo STL: #include <algorithm>
tres iteradores transversales y código de prueba:
#include<iostream>
using namespace std;
#include<vector>
#include<algorithm>
void myPrint(int val)
{
cout<<val<<endl;
}
void test01()
{
//创建了一个vector容器，数组
vector<int> v;
//向容器中插入数据
v.push_back(10);
v.push_back(11);
v.push_back(12);
v.push_back(13);
v.push_back(14);
//通过迭代器访问容器中的数据
vector<int>::iterator itBegin=v.begin();//起始迭代器 指向容器中第一个元素
vector<int>::iterator itEnd=v.end();//结束迭代器 指向容器中最后一个元素的下一个位置
//第一种遍历方式
while(itBegin!=itEnd)
{
cout<<*itBegin<<endl;
itBegin++;
}
//第二种遍历方式
for(vector<int>::iterator it=v.begin();it !=v.end();it++)
{
cout<<*it<<endl;
}
//第三种遍历方式 利用STL提高遍历算法
for_each(v.begin(),v.end(),myPrint);//需要在声明一个myPrint的函数
}
int main()
{
test01();
system("pause");
return 0;
}
1.6 El código de demostración para almacenar tipos de datos personalizados en vector es el
siguiente:
#include<iostream>
using namespace std;
#include<vector>
#include<string>
//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()
{
vector<Person>v;
Person p1("wjx",11);
Person p2("p",11);
Person p3("苏",10);
Person p4("re",11);
Person p5("tyu",11);
//向容器中添加数据
v.push_back(p1);
v.push_back(p2);
v.push_back(p3);
v.push_back(p4);
v.push_back(p5);
//遍历容器中的数据
for(vector<Person>::iterator it=v.begin();it!=v.end();it++)
{
cout<<"姓名："<<(*it).m_Name<<"年龄："<<(*it).m_Age<<endl;
cout<<"姓名："<<it->m_Name<<"年龄："<<it->m_Age<<endl;
}
}
void test02()
{
vector<Person*>v;
Person p1("wjx",11);
Person p2("py",11);
Person p3("苏",10);
Person p4("re",11);
Person p5("tyu",11);
//向容器中添加数据
v.push_back(&p1);
v.push_back(&p2);
v.push_back(&p3);
v.push_back(&p4);
v.push_back(&p5);
//遍历容器
for(vector<Person *>::iterator it=v.begin();it!=v.end();it++)
{
cout<<"姓名："<<(*it)->m_Name<<"年龄："<<(*it)->m_Age<<endl;
}
}
int main()
{
//test01();
test02();
system("pause");
return 0;
}
1.7 Contenedor contenedor anidado
Similar a la llamada de matriz bidimensional, el código de uso es el siguiente:
dividido en un contenedor grande total y un contenedor pequeño contenido en el contenedor grande.
#include<iostream>
using namespace std;
#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 vit=(*it).begin ();vit!=(*it).end();vit++)
{
cout<<*vit<<" ";
}
cout<<endl;
}
}
int main()
{
test01();
system("pause");
return 0;
}