C ++ Xiaobai's STL primeiro conhecido
Não há muito a dizer, o tempo de arrumação diária acabou. O que eu quero arrumar hoje é a STL (biblioteca de modelos padrão). Eu sei um pouco sobre ela, e acho que a STL é muito fácil de usar o ( ￣ ￣ ) ブ. Hoje é meu primeiro contato com STL, então vamos resumir.
1. STL inicial - o conceito básico de
STL 1.1 O nascimento de STL
(1) Por muito tempo, a indústria de software esperava construir algo reutilizável.
(2) As idéias de programação genérica e orientada a objetos do C ++ visam melhorar a capacidade de reutilização.
(3) Na maioria dos casos, as estruturas de dados e algoritmos falham em ter um conjunto de padrões, resultando em forçados a se envolver em muito trabalho repetitivo.
(4) Para estabelecer um conjunto de padrões para estruturas de dados e algoritmos, nasceu o STL.
1.2 Conceitos básicos de STL
(1) STL (biblioteca de modelos padrão, biblioteca de modelos padrão)
(2) STL pode ser amplamente dividido em: contêiner (contêiner), algoritmo (algoritmo), iterador (iterador)
(3) entre contêiner e algoritmo Conexão contínua por meio de iteradores
(4) Quase todos os códigos STL usam classes de modelo ou funções de modelo
1.3 Os seis componentes de
STL STL é aproximadamente dividido em seis componentes, a saber: contêiner, algoritmo, iterador, functor, adaptador (adaptador), adaptador de espaço
1. Contêiner: várias estruturas de dados, como vetor, lista, deque, Conjunto, mapa etc. Usado para armazenar dados.
2. Algoritmo: vários algoritmos comumente usados, como classificar, localizar, copiar, for_each, etc.
3. Iterador: atua como a cola entre o contêiner e o algoritmo.
4. Funções: funções semelhantes podem ser usadas como estratégia para algoritmos.
5. Adaptador: algo usado para decorar a interface de um contêiner ou functor ou iterador.
6. Adaptador de espaço: responsável pela configuração e gerenciamento do espaço.
1.4 Contêineres, algoritmos e iteradores em
contêineres
STL : o local de armazenamento. Os contêineres STL implementam a estrutura de dados mais amplamente usada. Estruturas de dados
comumente usadas: matrizes, listas vinculadas, números, pilhas, filas, conjuntos, tabelas de mapeamento, etc.
Esses containers são divididos em dois tipos: container de seqüência e container associativo: container de
seqüência: enfatiza a ordenação dos valores, cada elemento no container de seqüência tem uma posição fixa.
Contêiner associativo: estrutura de árvore binária, não há relação de ordem física estrita entre os elementos.
Algoritmo: A solução do problema também tem
etapas limitadas para resolver problemas lógicos ou matemáticos. Chamamos este algoritmo sujeito (Algoritmos)
.Os algoritmos são divididos em algoritmos qualitativos e não qualitativos.
Algoritmo de mudança qualitativa: significa que o conteúdo dos elementos no intervalo será alterado durante a operação, como cópia, substituição, exclusão, etc.
Algoritmo não qualitativo: significa que o conteúdo do elemento no intervalo não será alterado durante a operação, como pesquisa, contagem, passagem, localização de valores extremos e assim por diante.
Iterador: a cola entre o contêiner e o algoritmo
Fornece uma maneira de pesquisar sequencialmente os vários elementos contidos em um contêiner sem expor a representação interna do contêiner.
Cada contêiner tem seu próprio
iterador. O uso de iteradores é muito semelhante aos ponteiros. No estágio inicial, você pode entender que os iteradores são ponteiros.
Tipos de
iteradores : iteradores de entrada
Os tipos de iteradores comumente usados em contêineres são iteradores bidirecionais e iteradores de acesso aleatório.
1.5 Vector armazena tipos de dados integrados
Container:
algoritmo de vetor : for_each
iterator: vector :: iterator
Arquivo de cabeçalho de algoritmo STL: #include <algorithm>
três iteradores de passagem e código de teste:
#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 O código de demonstração para armazenar tipos de dados personalizados em vetor é
o seguinte:
#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 Contêiner aninhado contêiner
Semelhante à chamada de array bidimensional, o código de uso é o seguinte:
dividido em um contêiner grande total e um contêiner pequeno contido no contêiner 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;
}