prefácio
Conceitos básicos de STL
1. STL (Biblioteca de Modelos Padrão, biblioteca de modelos padrão)
2. STL é amplamente dividido em: contêiner (contêiner), algoritmo (algoritmo), iterador (iterador)
3. Conexão perfeita entre contêineres e algoritmos por meio de iteradores
4. Quase todos os códigos em STL usam classes de modelo ou funções de modelo
1. Conhecendo STL pela primeira vez
1.1 STL é dividido em seis componentes principais
São eles: container, algoritmo, iterador, functor, adaptador (adaptador), configurador de espaço
1. Contêiner: Várias estruturas de dados, como vetor, lista, deque, conjunto, mapa, etc., são usadas para armazenar dados
2. Algoritmos: vários algoritmos comumente usados, como classificar, localizar, copiar, for_each, etc.
3. Seletor de geração: atua como cola entre o contêiner e o algoritmo
4. Functor: O comportamento é semelhante a uma função, que pode ser usada como uma determinada estratégia do algoritmo
5. Adaptador: algo usado para modificar um contêiner ou functor ou interface de iterador
6. Configurador de espaço: responsável pela configuração e gerenciamento do espaço
1.1.1 Contêineres
Recipiente: um local para armazenamento
Os contêineres STL são estruturas de dados comumente usadas que implementam algumas das estruturas de dados mais utilizadas : arrays, listas vinculadas, árvores, pilhas, conjuntos de filas, tabelas de mapeamento, etc. Esses contêineres são divididos em dois tipos : contêineres sequenciais e contêineres associativos :
Contêiner sequencial: enfatiza a classificação de valores e cada elemento no contêiner sequencial possui uma posição fixa.
Recipiente associativo: uma estrutura de árvore binária, não existe uma relação estrita de ordem física entre os elementos.
1.1.2 Algoritmos
Algoritmos: soluções para problemas
Etapas limitadas para resolver problemas lógicos ou matemáticos, este assunto chamamos de Algoritmos (Algoritmos). Os algoritmos são divididos em: algoritmo de mudança qualitativa e algoritmo de mudança não qualitativa .
Algoritmo de mudança qualitativa: significa que o conteúdo dos elementos no intervalo será alterado durante a operação . como copiar, substituir, excluir, etc.
Algoritmo não qualitativo: significa que o conteúdo dos elementos do intervalo não será alterado durante a operação , como busca, contagem, percurso, localização de valores extremos, etc.
1.1.3 Iteradores
Iteradores: a cola entre contêineres e algoritmos
Fornece uma maneira de acessar sequencialmente os elementos de um contêiner sem expor a representação interna do contêiner Cada contêiner possui seu próprio iterador
O uso de iteradores é muito semelhante ao de ponteiros.No estágio inicial, podemos primeiro entender que iteradores são ponteiros.
*** Comumente usados são iteradores bidirecionais e iteradores de acesso aleatório .
2. Contêineres, Algoritmos, Iteradores
O contêiner mais comumente usado em STL é o vetor, que pode ser entendido como um array
2.1 contêineres de vetores
Recipiente: vetor
Algoritmo: for_each
Iterador: vector<int>::iterador
No exemplo a seguir, o contêiner de vetor precisa incluir o arquivo de cabeçalho " #include <vector> " quando usado , e a função "push_back()" é usada para inserir dados. Begin() aponta para o primeiro elemento no contêiner para o iterador inicial . end() encerra o iterador apontando para a próxima posição do último elemento no contêiner.
As etapas para criar um contêiner vetorial podem ser divididas em três etapas :
1. Crie um contêiner
2. Adicione dados ao contêiner
3. Percorra os dados no contêiner
#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;
}O primeiro método de travessia
Use o loop while para percorrer
O segundo método de travessia
//O segundo método de travessia
for (vector<int>::iterador it = v.begin(); it != v.end(); it++)
{ cout << *it << endl; }
O terceiro método de travessia usa o algoritmo de travessia fornecido pelo STL
Use a função for_each() fornecida pelo STL, mas o uso desta função precisa incluir o arquivo de cabeçalho do algoritmo padrão " #include <algorithm> ".
void minhaimpressão(int val)
{ cout << val << endl; }//O terceiro método de travessia usa o algoritmo de travessia fornecido pelo STL
for_each(v.begin(), v.end(), minhaimpressão);
2.2 Coloque um array personalizado no contêiner de vetor
#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;
}O contêiner de vetor em test01() é uma classe de pessoa. O it aqui é essencialmente um ponteiro. Depois que (*it) é desreferenciado, é o tipo de dados no <> atrás do vetor, aqui está a pessoa. Também pode ser usado diretamente como um ponteiro -> para apontar para um atributo.
O contêiner de vetor em test02() é um ponteiro para pessoa*. Aqui (*it) é do tipo pessoa* após a desreferenciação, que é um ponteiro. Ele precisa de (*it)->m_name e (*it)->m_age para aponte para Atributos.
2.3 Contêiner aninhado
Um contêiner está aninhado dentro de um contêiner, o que equivale a uma matriz bidimensional. Dois loops for são necessários para a travessia.
#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;
}Três, contêiner de string
3.1 Conceito básico de contêiner de string
Essência: string é uma string no estilo C++ e string é essencialmente uma classe
Recursos:
A classe string encapsula internamente muitos métodos de membro
Por exemplo: localizar localizar, copiar copiar, excluir excluir substituir substituir, inserir inserir string
Gerencie a memória alocada por char*, não se preocupe em copiar fora dos limites e valor fora dos limites, etc., a classe é responsável por isso
3.2 construtor de string
3.3 operação de atribuição de string
3.4 concatenação de strings
A seguir estão exemplos das sete operações acima:
#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;
}O resultado da execução do código acima é:
str1 = Adoro aprender C++
str1 = Adoro aprender C++!
str1 = Adoro aprender C++! E C e java
str3 = Adoro
str3 = Adoro python
str3 = Adoro python e C e java
str4 = Adoro Lá também é linguagem C para jogos
, pressione qualquer tecla para continuar. . .
3.5 busca e substituição de string
Descrição da função:
Find: descobre se a string especificada existe
Substituir: substitui a string na posição 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;
}O resultado da operação é
encontrado, pos=0
pos=7
str2=a111efg
Resumir:
1. encontre pesquisas da esquerda para trás, encontre da direita para a esquerda
2. find retorna a posição do primeiro caractere encontrado após encontrar a string e retorna -1 se não for encontrado
3. Ao substituir, você precisa especificar de qual posição, quantos caracteres e que tipo de string substituir
3.6 comparação de strings
A comparação de strings (usando a função compare()) é baseada no código ASClI do caractere
1. = retorno 0
2. > retornar 1
3. < retorno -1
Protótipo de função:
1. int compare(const string &s ) const; //Compara com string s
2. int compare( const char *s ) const;//compara com string s
A seguir está o código do 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 acesso a caracteres de string
Existem duas maneiras de acessar um único caractere em string:
1. char& operador[](int n); //Obter caracteres por [] (equivalente a sobrecarregar colchetes)
2. char& at(int n); //Obtém caracteres através do método at
3.8 inserção e exclusão de string
Descrição da função: Inserir (inserir) e excluir (apagar) caracteres em strings
Protótipo de função:
1. string& insert(int pos, const char* s); //inserir string
2. string& insert(int pos, const string& str); //inserir string
3. string& insert(int pos, int n, char c); //Insere n caracteres c na posição especificada
4. string& erase(int pos, int n = npos); // exclui n caracteres começando em pos
A seguir está o código de exemplo, insert(1, "***") significa inserir " *** " do caractere cujo subscrito é 1,
apagar(1, 3) significa excluir os caracteres do subscrito 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;
}Após a execução, o resultado é o seguinte
Depois de inserir str = h***ellow
Depois de excluir str = hellow
Por favor, pressione qualquer tecla para continuar. . .
3.9 substring de string
Descrição: Obtenha a substring desejada de uma string
Protótipo de função:
string substr(int pos = 0, int n = npos) const; // retorna uma string consistindo de n caracteres começando em pos
O seguinte é um caso de leitura de um nome de usuário de caixa de correio
#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;
}O resultado da operação é o seguinte:
Nome de usuário: zhangsan
Por favor, pressione qualquer tecla para continuar. . .
Quatro, contêiner de vetor
4.1 Conceito básico de vetor
Função: A estrutura de dados vetoriais é muito semelhante a um array, também conhecido como array de extremidade única
A diferença entre vetor e array comum : A diferença é que o array é um espaço estático , enquanto o vetor pode ser expandido dinamicamente
Expansão dinâmica: em vez de adicionar um novo espaço após o espaço original, encontre um espaço de memória maior e copie os dados originais para o novo espaço para liberar o espaço original
*** O iterador do contêiner vetorial é um iterador que suporta acesso aleatório
4.2 construtor de vetor
Protótipo da função:
1. vector<T> v; //Implementação da classe de implementação do modelo, construtor padrão
2. vector(v.begin(), v.end() ); //Copia os elementos no intervalo v[begin(), end()) para si mesmo.
3. vector(n, elem); //O construtor copia n elementos para si mesmo.
4. vector(const vector &vec); //copia o construtor.
O seguinte é um caso de demonstraçã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);
//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 operação de atribuição de vetores
Descrição da função: atribuir valor ao contêiner de vetor
Protótipo da função:
1. vector& operador=(const vector &vec);//sobrecarrega o operador de sinal de igual
atribuir(beg, end);//atribuir a cópia de dados no intervalo [beg,end) para si mesmo
atribuir(n, elem ); //Atribuir n cópias de elem a si mesmo.
#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 capacidade e tamanho do vetor
Descrição da função: operar na capacidade e tamanho do contêiner vetorial
Protótipo de função:
1. vazio(); //julgando se o contêiner está vazio
2.capacidade(); //A capacidade do contêiner
3. size(); //Retorna o número de elementos no contêiner
resize(int num); //Reespecifique o comprimento do contêiner como num, se o contêiner ficar mais longo, preencha a nova posição com o valor padrão. Se o contêiner ficar mais curto, os elementos no final que excedem o comprimento do contêiner serão removidos.
4. resize(int num, elem); //Reespecifique o comprimento do contêiner como num, se o contêiner ficar mais longo, preencha o novo { com elem value . Se o contêiner ficar mais curto, os elementos no final que excedem o comprimento do contêiner serão removidos
A seguir estão os códigos de demonstração de três funções vazia(), capacidade(), tamanho():
#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 Inserção e exclusão de contêineres de vetores
Descrição da função: operações de inserção e exclusão em contêineres de vetores
Protótipo de função:
1. push_back(ele); // insere o elemento ele no final
2. pop_back(); //Exclui o último elemento
3. insert(const_iterator pos,ele); //O iterador aponta para a posição pos para inserir o elemento ele
4. insert(const_iterator pos, int count,ele); //O iterador aponta para a posição pos para inserir elementos de contagem
5. eleerase(const_iterator pos ); //Exclui o elemento apontado pelo iterador
6. erase(const_iterator start, const_iterator end);//Exclui os elementos entre o início e o fim do iterador
7. clear(); //Exclui todos os elementos do contêiner
A seguir está o código de demonstração para a função acima:
#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;
}O seguinte é o resultado da operação:
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
Pressione
qualquer tecla para continuar. . .
resumo:
Plugue traseiro --- push_back
Exclusão final --- pop_back
inserir --- inserir (iterador de posição)
excluir --- apagar (iterador de posição)
Vazio --- claro
4.6 acesso a dados vetoriais
Descrição da função: acesso aos dados do vetor
Protótipo de função:
at(int idx); //retorna os dados apontados pelo índice idx
operador[ ]; //Retorna os dados apontados pelo índice idx
front(); //retorna o primeiro elemento de dados no contêiner
back(); //retorna o último elemento de dados no contêiner
A seguir está o código de demonstração:
#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;
}resumo:
1. Além de usar iteradores para obter elementos no contêiner vetorial, [] e at também podem ser usados
2. front retorna o primeiro elemento do contêiner
3. back retorna o último elemento do contêiner
4.7 contêiner de troca de vetor
Descrição da função: realizar a troca de elementos em dois containers
Protótipo da função: swap(vec); //troca vec com seus próprios elementos
A seguir está o código de demonstraçã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()
{
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;
}O seguinte é o resultado da operação:
Antes da troca:
0 1 2 3 4 5 6 7 8 9
10 9 8 7 6 5 4 3 2 1
Após a troca:
10 9 8 7 6 5 4 3 2 1 0 1 2 3 4
5 6 7 8 9
A capacidade da v3 é: 12138
Universidade para v3: 10000
Capacidade para v3: 12138
Universidade para
v3: 10 Capacidade para v3: 10
Universidade para v3: 10
Pressione qualquer tecla para continuar. . .
4.8 espaço reservado vetorial
Descrição da função: reduz o número de expansões do vetor ao expandir dinamicamente a capacidade
Protótipo da função: reserve(int len); //O contêiner reserva o comprimento dos elementos len, a posição reservada não é inicializada e os elementos ficam inacessíveis.
Cinco, contêiner deque
5.1 Conceitos básicos
Função: matriz dupla, que pode inserir e excluir o head end
A diferença entre deque e vetor :
1. A eficiência de inserção e exclusão do vetor é baixa para o cabeçalho , quanto maior o volume de dados, menor a eficiência
2. Relativamente falando, o deque irá inserir e excluir o cabeçalho mais rápido do que o vetor
3. Quando o vetor acessa os elementos, será mais rápido que o deque, que está relacionado à implementação interna dos dois
A imagem vem das notas da aula em vídeo do Dark Horse Programmer
O princípio de funcionamento interno do deque :
Existe um controlador central dentro do deque, que mantém o conteúdo de cada buffer e armazena dados reais no buffer. O controlador central mantém o endereço de cada buffer, fazendo com que pareça um espaço de memória contínuo ao usar o deque.
5.2 construtor deque
Descrição da função: construção de contêiner deque
Protótipo de função:
1. deque<T> deqT; //Formulário de construção padrão
2. deque(beg, end); //O construtor copia os elementos do intervalo [beg, end) para si mesmo.
3. deque(n, elem); //O construtor copia n elementos para si mesmo.
4. dequé(const deque &deq); //copia o construtor
Resumo: Os métodos de construção de contêineres deque e contêineres vetoriais são quase os mesmos.
5.3 Atribuição de contêiner Deque
Protótipo de função:
1. deque& operador=(const deque &deq); //sobrecarrega o operador de sinal de igual
2. atribuir(beg, end); //Atribuir a cópia dos dados no intervalo [beg, end) para si mesmo.
3. atribuir(n, elem); //Atribuir n cópias de elem a si mesmo.
5.4 operação de tamanho deque
Descrição da função: opera no tamanho do contêiner deque
Princípio de funcionamento:
deque.empty(); //Determina se o contêiner está vazio
deque.size(); //retorna o número de elementos no contêiner
deque.resize(num); //Especifique novamente o comprimento do contêiner como num, se o contêiner ficar mais longo, preencha a nova posição com o valor padrão. Se o contêiner ficar mais curto, os elementos no final que excedem o comprimento do contêiner serão removidos.
deque.resize(num, elem); //Especifique novamente o comprimento do container como num, se o container ficar mais longo, preencha a nova posição com o valor de elem. Se o contêiner ficar mais curto, os elementos no final que excedem o comprimento do contêiner serão removidos.
5.5 Inserção e exclusão de contêineres deque
Protótipo de função:
deque.empty(); //Determina se o contêiner está vazio
deque.size(); //retorna o número de elementos no contêiner
deque.resize(num); //Especifique novamente o comprimento do contêiner como num, se o contêiner ficar mais longo, preencha a nova posição com o valor padrão. Se o contêiner ficar mais curto, os elementos no final que excedem o comprimento do contêiner serão removidos.
deque.resize(num, elem);//Especifique novamente o comprimento do contêiner como num, se o contêiner ficar mais longo, preencha a nova posição com o valor de elem. Se o contêiner ficar mais curto, os elementos no final que excedem o comprimento do contêiner serão removidos.
5.6 Acesso a dados do contêiner deque
Protótipo de função:
at(int idx); //retorna os dados apontados pelo índice idx
operador[];I/retorna os dados apontados pelo índice idx front(); //retorna o primeiro elemento de dados no contêiner
back(); //retorna o último elemento de dados no contêiner
5.6 Inserção e exclusão do contêiner deque
algoritmo:
sort(iterator beg, iterator end) //Classifica os elementos no intervalo de início e fim.