You are on page 1of 15

Guia de Consulta Rápida

C++ STL
Joel Saade
Novatec Editora
2
Guia de Consulta Rápida C++ STL de Joel Saade
Copyright2006 da Novatec Editora Ltda.
Todos os direitos reservados. É proibida a reprodução desta
obra, mesmo parcial, por qualquer processo, sem prévia
autorização, por escrito, do autor e da Editora.
ISBN: 85-7522-082-9
Primeira impressão: Fevereiro/2006
Novatec Editora Ltda.
Rua Luís Antônio dos Santos 110
02460-000 São Paulo Brasil
Tel.: +55 11 6959-6529
Fax: +55 11 6950-8869
E-mail: novatec@novatec.com.br
Site: www.novatec.com.br
3
Convenções ............................................................. 4
Defnições ....................................................................................... 4
Introdução à STL ..................................................... 5
Containers ................................................................ 7
Tipos comuns a todos os containers ................................................ 7
Containers seqüenciais .................................................................... 7
Vetor .......................................................................................... 7
Deque ........................................................................................11
Lista ......................................................................................... 16
Métodos comuns aos containers seqüenciais .......................... 24
Containers associativos classifcados ............................................ 28
Pares ........................................................................................ 28
Set 29
Multiset .................................................................................... 36
Map .......................................................................................... 44
Multimap ................................................................................. 54
Métodos comuns a todos os containers ......................................... 62
Iteradores ............................................................... 65
Manipulação de streams ................................................................ 65
Iterador Istream ....................................................................... 65
Iterador Ostream ...................................................................... 67
Iterador Input Stream Buffer ................................................... 68
Iterador Output Stream Buffer................................................. 69
Adaptadores........................................................... 71
Adaptadores de container .............................................................. 71
Stack (pilha) ............................................................................ 71
Queue (fla) .............................................................................. 74
Priority_queue (fla com prioridade) ....................................... 78
Adaptadores de Iterador ................................................................ 81
Iterador de inserção ................................................................. 81
Iterador reverso ........................................................................ 84
Adaptadores de função .................................................................. 87
Binders ..................................................................................... 87
Negators ................................................................................... 88
Objetos-função ...................................................... 89
Functors predefnidos .................................................................... 89
Functors para os operadores aritméticos ................................. 89
Functors para os operadores relacionais .................................. 89
Functors para os operadores lógicos ....................................... 90
Predicates ...................................................................................... 90
Algoritmos .............................................................. 91
Algoritmos de não-modifcação de seqüências ............................. 91
Algoritmos de modifcação de seqüências .................................. 100
Algoritmos relacionados à ordenação ..........................................114
Operações de ordenação e intercalação ..................................114
Operações de comparação e pesquisa ................................... 120
Operações de conjunto .......................................................... 123
Operações de heap ................................................................. 126
Comparação lexicográfca ..................................................... 128
Permutações ........................................................................... 129
Algoritmos numéricos genéricos ................................................ 130
Somório
4
Convenções
Convenção Signifcado
ItInp Iteradorinput.
ItOut Iteradoroutput.
ItFwd Iteradorforward.
ItBid Iteradorbidirectional.
ItRac Iteradorrandomaccess.
método Omesmoquefunção-membro.
T Tipodosvaloresarmazenadosemumcontainer(porexemplo,int,
foat,char).
X Classe-container que contém objetos do tipo T (por exemplo,
vector<int>).
a UmobjetodaclasseX(porexemplo,vector<int> a).
Defnições
Termo Signifcado
[frst,last) Pardeiteradoresquedefneumintervaloiniciadoemfrst e
terminado,massemincluirlast:intervalofechadoemfrst e
abertoemlast.
funçãounária Funçãoquerecebeumargumento.
funçãobinária Funçãoquerecebedoisargumentos.
iteração Oatodeumiteradorpercorrerumcontainerseqüencialmente,
elementoaelemento.
métodobinário Métodoquerecebedoisargumentos.
métodounário Métodoquerecebeumargumento.
past-the-end Posição após a última em um container, assumida por um
iterador.
seqüência Umpardeiteradorespassadocomoargumentoaumalgoritmo
quedefneumintervalodeelementossobreoqualoalgoritmo
atuará.
Observações
• Para os programas-exemplo que utilizam as notações it-
>frst e it->second, caso o compilador que você esteja
usando não as aceite, utilize (*it).frst e (*it).second.
• Nos programas-exemplo, as linhas de código #include
<iostream> e using namespace std; foram suprimidas
por serem comuns a todos os programas. No site da
Novatec Editora, tais programas estão na sua forma
integral, disponíveis para download (www.novatec.com.
br/download/).
Convonçòos
5
Introdução à STL
A Standard Template Library (STL) é uma biblioteca integrada à
biblioteca padrão de C++, por meio do mecanismo de templates.
Além de programas contém outros componentes, entre eles,
destacam-se estruturas de dados e ponteiros “inteligentes”. Na
terminologia STL, as estruturas de dados são chamadas de
containers, os programas são chamados de algoritmos e os
ponteiros “inteligentes”, de iteradores.
Os containers armazenam valores de um dado tipo (int, foat
etc). Os algoritmos correspondem às ações a serem executadas
sobre os containers (ordenação, pesquisa e outras). Os iteradores
percorrem os elementos dos containers da mesma forma que um
índice percorre os elementos de um array. Esses três componentes
são básicos e o seu conhecimento é o mínimo para se usar a
STL.
A STL é uma caixa de ferramentas que auxilia, que traz
soluções para muitos problemas de programação que envolvem
estruturas de dados.
Bem, mas quais seriam essas estruturas de dados e quais
seriam esses problemas?
As estruturas de dados básicas são: vetor, lista, deque, set,
multiset, map e multimap. E mais as seguintes, criadas a partir
das estruturas básicas: pilha, fla e fla com prioridade.
Entre os problemas encontrados no desenvolvimento de
aplicações que usam estruturas de dados, destacam-se:
• ordenar os elementos de uma lista;
• efetuar uma pesquisa efciente em um vetor;
• gerenciar a memória quando da inserção ou eliminação
de elementos de uma deque.
A STL foi desenvolvida por Alexander Stepanov e Meng Lee,
nos laboratórios da Hewlett Packard, com a valiosa colaboração
de David R. Musser. Em 1994, o comitê ISO/ANSI C++ decidiu
incorporar a STL à biblioteca padrão de C++ e neste mesmo ano,
a HP disponibilizou a STL na Internet.
Para mostrar a poder da STL, veja o exemplo seguinte.
1 //Criaumvetorcomnomeseoordenaascendentemente
2 #include<algorithm> //Paraalgoritmos
3 #include<vector> //Paracontainersvector
4 #include<string> //Paraobjetosstring
5 intmain()
6 {
7 vector<string>nomes;//Vetordeobjetosstring
8 //Iteradorparavetoresdeobjetosstring
9 vector<string>::iteratorit;
10 //Inserevaloresnovetorcomométodopush_back()
11 nomes.push_back(“Ana”);
12 nomes.push_back(“Rose”);
13 nomes.push_back(“Jane”);
14 nomes.push_back(“Carla”);
15 cout<<“Vetorantesdaordenação:“;
16 for(it=nomes.begin();it!=nomes.end();++it)
17 cout<<*it<<““;
lnlroooçõo o STL
ó
18 cout<<endl;
19 sort(nomes.begin(),nomes.end());//Ordenaovetor
20 cout<<“Vetordepoisdaordenação:“;
21 for(it=nomes.begin();it!=nomes.end();++it)
22 cout<<*it<<““;
23 return0;
24 }
Resultado da execução do programa
Vetorantesdaordenação:AnaRoseJaneCarla
Vetordepoisdaordenação:AnaCarlaJaneRose
As observações seguintes aplicam-se ao programa-exemplo
recém-apresentado, sendo válidas também para a maioria dos
programas-exemplo contidos neste guia, por apresentarem
conceitos básicos importantes.
Linha Descrição
2 É necessária para a maioria dos algoritmos.
3 É necessária para o uso do container vetor,
havendo um arquivo-cabeçalho para cada
container.
7 Declara um container do tipo vetor com elementos
do tipo string, chamado nomes.
9 Declara um iterador, chamado it, para percorrer
os elementos do vetor. Este iterador poderá ser
utilizado com outros vetores desde que tenham
elementos do tipo string.
11 a 14 Utilizam o método push_back() defnido para
vetores, cuja tarefa é inserir elementos no fnal
de um vetor.
16 Acessa cada elemento do vetor, do primeiro até o
último, por meio do iterador it.
17 Exibe o valor de cada elemento do vetor por meio
do operador de de-referência *, que retorna o valor
apontado pelo iterador it.
19 Utiliza o algoritmo sort para ordenar elementos
de containers. Há de se notar que apenas uma
linha de comando foi necessária para efetuar a
ordenação do vetor.
lnlroooçõo o STL
7
Conloinors
Containers
São estruturas de dados que armazenam valores. Estão divididos
em duas categorias: seqüenciais e associativos classifcados,
com as seguintes características:
• Alocação e gerenciamento da memória, por meio de um
objeto alocador de memória próprio.
• Fornecimento de métodos para a sua manipulação.
• Reversibilidade: cada container pode ser acessado de forma
reversa, isto é, do último para o primeiro elemento.
Tipos comuns a todos os containers
Tipo Descrição
X::allocator_type Representa o alocador de memória para X.
EquivaleaoargumentoAllocator.
X::difference_type Inteirosinalizadoquerepresentaadiferençaentre
doisiteradoresdeX.
X::const_iterator Iterador constante para acessar os elementos
armazenadosemumXconstante.
X::iterator Iteradorparaacessaroselementosarmazenados
emX.
X::const_reverse_iterator Iterador constante para acessar, de forma
reversa, os elementos armazenados em um X
constante.
X::reverse_iterator Iterador para acessar, de forma reversa, os
elementosarmazenadosemX.
X::size_type Inteirosemsinalquearmazenavaloresdotipo
difference_typeouotamanhodeX.
X::value_type Tipodoselementos(T)armazenadosemX.Para
map e multimapépair<const Key,T>,emque
oprimeiro membro do par éconstpara que a
chavenãosejaalterada.
Containers seqüenciais
São containers cujos elementos estão em uma ordem linear. São
homogêneos, pois armazenam valores de um mesmo tipo. Os tipos
podem ser os básicos (int, foat etc) ou criados pelo programador
(estrutura ou classe). Um array de C++ é um exemplo de container
seqüencial. Dispõem de gerenciamento automático de memória
que permite ao tamanho do container variar dinamicamente,
aumentando ou diminuindo à medida que elementos são
inseridos ou eliminados. Os containers seqüenciais são: vetor,
deque e lista.
Container Arquivo-cabeçalho
vetor vector
deque deque
lista list
Vetor
A classe-template vector representa uma estrutura de dados
que pode ser comparada a um array dinâmico de C++, em que
os elementos são armazenados de forma contígua e podem ser
acessados aleatoriamente por meio do operador [ ].
Iterador suportado: random access.
8 Conloinors
Declaração da classe
template<typenameT,typenameAllocator=allocator<T>>classvector
Defnição de tipos
As classes-template vector, deque e list defnem os tipos:
Tipo Descrição
const_pointer Ponteiroconstparaoselementosdevetores,dequeselistas
(const T*).
pointer Ponteiroparaoselementosdevetores,dequeselistas(T*).
const_reference Referênciaconstparaoselementosdevetores,dequeselistas
(const T&).
reference Referência para os elementos de vetores, deques e listas
(T&).
Construtores
vector()
vector(constAllocator&=Allocator());
Cria um vetor vazio.
Exemplo
#include<vector>
intmain(){
vector<int>v1; //vetordeinteiros
return0;}
vector()
explicitvector(size_typen,constT&valor=T(),
constAllocator&=Allocator());
Cria um vetor com n elementos e o inicializa com valor.
/*jvcria01.cpp–Criaumvetorinicializadocomovalor9.
Éexibidocomanotaçãodearrayecomiteradores*/
#include<vector>
intmain(){
vector<int>v1(3,9);
vector<int>::iteratorit; //Iterador
cout<<“Vetorv1:“;
for(inti=0;i<3;++i)cout<<v1[i]<<““;
cout<<“Vetorv1:“;
for(it=v1.begin();it!=v1.end();++it)cout<<*it<<““;
return0;}
vector()
vector(constvector<T,Allocator>&x);
Cria um vetor e o inicializa com os elementos do vetor x.
/*jvconcop.cpp–Criaovetorv2apartirdovetorv1.
Exibeosvetorescomiteradores*/
#include<vector>
intmain(){
vector<int>v1(3);
vector<int>::iteratorit;//Iterador
//Atribuivalorescomanotaçãodearray
v1[0]=1;v1[1]=2;v1[2]=3;
cout<<“Vetorv1:“;
for(it=v1.begin();it!=v1.end();++it)cout<<*it<<““;
vector<int>v2(v1); //Criaovetorv2
cout<<“Vetorv2:“;
for(it=v2.begin();it!=v2.end();++it)cout<<*it<<““;
return0;}
º
Conloinors
vector()
template<typenameItInp>
vector(ItInp frst,ItInp last,const Allocator& = Allocator());
Cria um vetor, inicializado com os elementos do intervalo
[frst, last).
/* jvint.cpp–Criaovetorv2comintervalodovetorv1*/
#include<vector>
intmain(){
vector<int>v1(3);
v1[0]=1;v1[1]=2;v1[2]=3;
cout<<“Vetorv1:“;
for(inti=0;i<3;++i)cout<<v1[i]<<““;
vector<int>v2(v1.begin(),v1.end()); //Criav2
cout<<“Vetorv2:“;
for(inti=0;i<3;++i)cout<<v2[i]<<““;
return0;}
Operaçõesdeatribuiçãoecomparação
operator=()
vector<T,Allocator>&operator=(constvector<T,Allocator>&x);
Substitui o conteúdo do vetor corrente pelo conteúdo do
vetor x.
//jvopeq.cpp
#include<vector>
intmain(){
vector<int>v1(3),v2(4);
vector<int>::iteratorit; //Iterador
v1[0]=5;v1[1]=6;v1[2]=7;
v2[0]=1;v2[1]=1;v2[2]=1;v2[3]=1;
cout<<“v1:“;
for(it=v1.begin();it!=v1.end();++it)cout<<*it<<““;
cout<<“v2antesdasubstituição:“;
for(it=v2.begin();it!=v2.end();++it)cout<<*it<<““;
cout<<endl;
v2=v1;
cout<<“v2depoisdasubstituição:“;
for(it=v2.begin();it!=v2.end();++it)cout<<*it<<““;
return0;}
operator==()
template<typenameT,typenameAllocator>
booloperator==(constvector<T,Allocator>&x,
constvector<T,Allocator>&y);
Retornará true se os vetores x e y tiverem o mesmo tamanho e
os mesmos elementos na mesma ordem, caso contrário, false.
//jvopeqeq.cpp
#include<vector>
intmain(){
vector<int>v1(3),v2(3);
v1[0]=1;v1[1]=2;v1[2]=3;
v2[0]=1;v2[1]=2;v2[2]=3;
boolres=(v1==v2);
if(res==true)
cout<<“Vetoresiguais”;
else
cout<<“Vetoresdiferentes”;
return0;}
1C Conloinors
operator<()
template<typenameT,typenameAllocator>
booloperator<(constvector<T,Allocator>&x,
constvector<T,Allocator>&y);
Retornará true se o vetor x for lexicografcamente menor que
o vetor y, caso contrário, false.
operator!=()
template<typenameT,typenameAllocator>
booloperator!=(constvector<T,Allocator>&x,
constvector<T,Allocator>&y);
Retornará true se vetor x for diferente do vetor y, caso
contrário, false.
operator>()
template<typenameT,typenameAllocator>
booloperator>(constvector<T,Allocator>&x,
constvector<T,Allocator>&y);
Retornará true se o vetor x for maior que o vetor y, caso
contrário, false.
operator<=()
template<typenameT,typenameAllocator>
booloperator<=(constvector<T,Allocator>&x,
constvector<T,Allocator>&y);
Retornará true se o vetor x for menor que ou igual ao vetor
y, caso contrário, false.
operator>=()
template<typenameT,typenameAllocator>
booloperator>=(constvector<T,Allocator>&x,
constvector<T,Allocator>&y);
Retornará true se o vetor x for maior que ou igual ao vetor y,
caso contrário, false.
Métodos
at()
referenceat(size_typen);
const_referenceat(size_typen)const;
Retorna uma referência (ou uma referência constante para um
vetor constante) para o elemento da posição n.
/* jvat.cpp–Retornaovalordedeterminadoelementode
umvetor*/
#include<vector>
intmain(){
vector<int>v1(3);
v1[0]=1;v1[1]=2;v1[2]=3;
vector<int>::referenceval=v1.at(2);
cout<<“Valordaposição2:“<<val;
return0;}
capacity()
size_typecapacity()const;
Retorna o número máximo de elementos que o vetor pode
armazenar sem realocação de memória.
11
Conloinors
//jvcapac.cpp
#include<vector>
intmain(){
vector<int>v1(5);
vector<int>::size_typeqtd=v1.capacity();
cout<<“Máximo:“<<qtd;
return0;}
operator[]()
referenceoperator[](size_typen);
const_referenceoperator[](size_typen)const;
Retorna uma referência (ou uma referência constante para um
vetor constante) para o elemento da posição n.
//jvoparr.cpp
#include<vector>
intmain(){
vector<int>v1(3);
v1[0]=1;v1[1]=2;v1[2]=3;
vector<int>::referencevalor=v1[2];
cout<<“Valordaposição2:“<<valor;
return0;}
reserve()
voidreserve(size_typen);
Altera o tamanho do vetor de modo que a memória seja
gerenciada adequadamente. A realocação ocorrerá se a
capacidade atual do vetor for menor que n. Após a chamada
a reserve() a capacidade será maior que ou igual à n se a
realocação ocorrer, caso contrário, será igual à capacidade
anterior.
swap()
voidswap(vector<T,Allocator>&x);
Troca o conteúdo do vetor chamador pelo conteúdo do vetor
x e vice-versa.
//jvswap.cpp
#include<vector>
intmain(){
vector<int>v1(2),v2(2);
v1[0]=3;v1[1]=3;v2[0]=5;v2[1]=5;
v1.swap(v2);
cout<<“v1depoisdeswap():“;
for(inti=0;i<2;++i)cout<<v1[i]<<““;
cout<<“v2depoisdeswap():“;
for(inti=0;i<2;++i)cout<<v2[i]<<““;
return0;}
Deque
A classe-template deque representa uma estrutura de dados
do tipo double-ended queue (fla com duas extremidades). A
exemplo do vetor, a deque também suporta o operador [ ]. As
operações de inserção e eliminação podem ser feitas em ambos os
extremos e os seus elementos não são armazenados em posições
contíguas de memória.
Iterador suportado: random access.
12 Conloinors
Declaração da classe
template<typenameT,typenameAllocator=allocator<T>>classdeque
Defnição de tipos
A classe-template deque defne tipos que são iguais aos
defnidos pela classe-template vector, pág. 8.
Construtores
deque()
deque(constAllocator&=Allocator());
Cria uma deque vazia.
Exemplo
#include<deque>
intmain(){
deque<int>d1;
return0;}
deque()
explicitdeque(size_typen,constT&valor=T(),
constAllocator&=Allocator());
Cria uma deque com n elementos e a inicializa com valor.
/*jdcria01.cpp – Criaumadequeinicializadacomovalor9.
Éexibidacomanotaçãodearrayecomiteradores*/
#include<deque>
intmain(){
deque<int>d1(3,9);
deque<int>::iteratorit; //Iterador
cout<<“Dequed1:“;
for(inti=0;i<3;++i)cout<<d1[i]<<““;
cout<<“Dequed1:“;
for(it=d1.begin();it!=d1.end();++it)cout<<*it<<““;
return0;}
deque()
deque(constdeque<T,Allocator>&x);
Cria uma deque e a inicializa com os elementos da deque x.
//jdconcop.cpp–Criaumadeque(d2)apartirdeoutra(d1)
#include<deque>
intmain(){
deque<int>d1(3);
deque<int>::iteratorit; //Iterador
//Atribuivalorescomanotaçãodearray
d1[0]=1;d1[1]=2;d1[2]=3;
cout<<“Dequed1:“;
for(it=d1.begin();it!=d1.end();++it)cout<<*it<<““;
deque<int>d2(d1); //Criaadequed2
cout<<“Dequed2:“;
for(it=d2.begin();it!=d2.end();++it)cout<<*it<<““;
return0;}
deque()
template<typenameItInp>
deque(ItInp frst,ItInp last,const Allocator& = Allocator());
Cria uma deque, inicializada com os elementos do intervalo
[frst, last).
13
Conloinors
/* jdint.cpp –Criaadequed2comintervalodadequed1*/
#include<deque>
intmain(){
deque<int>d1(3);
d1[0]=1;d1[1]=2;d1[2]=3;
cout<<“Dequed1:“;
for(inti=0;i<3;++i)cout<<d1[i]<<““;
deque<int>d2(d1.begin(),d1.end()); //Criad2
cout<<“Dequed2:“;
for(inti=0;i<3;++i)cout<<d2[i]<<““;
return0;}
Operaçõesdeatribuiçãoecomparação
operator=()
deque<T,Allocator>&operator=(constdeque<T,Allocator>&x);
Substitui o conteúdo da deque corrente pelo conteúdo da
deque x.
//jdopeq.cpp
#include<deque>
intmain(){
deque<int>::iteratorit; //Iterador
deque<int>d1(3),d2(4);
d1[0]=5;d1[1]=6;d1[2]=7;
d2[0]=1;d2[1]=1;d2[2]=1;d2[3]=1;
cout<<“d1:“;
for(it=d1.begin();it!=d1.end();++it)cout<<*it<<““;
cout<<“d2antesdasubstituição:“;
for(it=d2.begin();it!=d2.end();++it)cout<<*it<<““;
cout<<endl;
d2=d1;
cout<<“d2depoisdasubstituição:“;
for(it=d2.begin();it!=d2.end();++it)cout<<*it<<““;
return0;}
operator==()
template<typenameT,typenameAllocator>
booloperator==(constdeque<T,Allocator>&x,
constdeque<T,Allocator>&y);
Retornará true se as deques x e y tiverem o mesmo tamanho e
os mesmos elementos na mesma ordem, caso contrário, false.
//jdopeqeq.cpp
#include<deque>
intmain(){
deque<int>d1(3),d2(3);
deque<int>::iteratorit; //Iterador
d1[0]=1;d1[1]=2;d1[2]=3;
d2[0]=1;d2[1]=2;d2[2]=3;
boolres=(d1==d2);
if(res==true)
cout<<“Dequesiguais”;
else
cout<<“Dequesdiferentes”;
return0;}
operator<()
template<typenameT,typenameAllocator>
booloperator<(constdeque<T,Allocator>&x,
constdeque<T,Allocator>&y);
Retornará true se a deque x for lexicografcamente menor que
a deque y, caso contrário, false.
14 Conloinors
operator!=()
template<typenameT,typenameAllocator>
booloperator!=(constdeque<T,Allocator>&x,
constdeque<T,Allocator>&y);
Retornará true se a deque x for diferente da deque y, caso
contrário, false.
operator>()
template<typenameT,typenameAllocator>
booloperator>(constdeque<T,Allocator>&x,
constdeque<T,Allocator>&y);
Retornará true se a deque x for maior que a deque y, caso
contrário, false.
operator<=()
template<typenameT,typenameAllocator>
booloperator<=(constdeque<T,Allocator>&x,
constdeque<T,Allocator>&y);
Retornará true se a deque x for menor que ou igual à deque
y, caso contrário, false.
operator>=()
template<typenameT,typenameAllocator>
booloperator>=(constdeque<T,Allocator>&x,
constdeque<T,Allocator>&y);
Retornará true se a deque x for maior que ou igual à deque
y, caso contrário, false.
Métodos
at()
referenceat(size_typen);
const_referenceat(size_typen)const;
Retorna uma referência (ou uma referência constante para uma
deque constante) para o elemento da posição n.
/* jdat.cpp–Retornaovalordedeterminadoelementode
umadeque*/
#include<deque>
intmain(){
deque<int>d1;
//Inserevalorescomométodopush_back()
d1.push_back(1);d1.push_back(2);d1.push_back(3);
deque<int>::referencevalor=d1.at(2);
cout<<“Valordaposição2:“<<valor;
return0;}
operator[]()
referenceoperator[](size_typen)const;
const_referenceoperator[](size_typen)const;
Retorna uma referência (ou uma referência constante para uma
deque constante) para o elemento da posição n.
/* jdoparr.cpp–Retornaovalordedeterminadoelementode
umadeque*/
#include<deque>
intmain(){
deque<int>d1(3);
d1[0]=1;d1[1]=2;d1[2]=3;
15
Conloinors
deque<int>::referencevalor=d1[2];
cout<<“Valordaposição2:“<<valor;
return0;}
pop_front()
voidpop_front();
Elimina o primeiro elemento da deque.
//jdpopfro.cpp
#include<deque>
#include<string> //Paraobjetosstring
intmain(){
deque<string>d1(2);
deque<string>::iteratorit; //Iterador
d1[0]=“alfa”;d1[1]=“beta”;
cout<<“Antesdepop_front():“;
for(it=d1.begin();it!=d1.end();++it)cout<<*it<<““;
d1.pop_front();
cout<<“Depoisdepop_front():“;
for(it=d1.begin();it!=d1.end();++it)cout<<*it<<““;
return0;}
push_front()
voidpush_front(constT&x);
Insere o elemento x no início da deque.
//jdpusfro.cpp
#include<deque>
#include<string> //Paraobjetosstring
intmain(){
deque<string>d1;
deque<string>::iteratorit; //Iterador
d1.push_back(“alfa”);d1.push_back(“beta”);
d1.push_back(“gama”);
cout<<“Antesdepush_front():“;
for(it=d1.begin();it!=d1.end();++it)cout<<*it<<““;
cout<<endl;
d1.push_front(“delta”);
cout<<“Depoisdepush_front():“;
for(it=d1.begin();it!=d1.end();++it)cout<<*it<<““;
return0;}
swap()
voidswap(deque<T,Allocator>&x);
Troca o conteúdo da deque chamadora pelo conteúdo da
deque x e vice-versa.
//jdswap.cpp–Trocaoconteúdodeduasdeques
#include<deque>
intmain(){
deque<int>d1,d2;
deque<int>::iteratorit; //Iterador
for(inti=1;i<5;i++)//Insere1234
d1.push_back(i);
for(inti=5;i<9;i++)//Insere5678
d2.push_back(i);
d1.swap(d2);
cout<<“d1depoisdeswap():“;
for(it=d1.begin();it!=d1.end();++it)cout<<*it<<““;
cout<<“d2depoisdeswap():“;
for(it=d2.begin();it!=d2.end();++it)cout<<*it<<““;
return0;}

com. por qualquer processo.com. por escrito. do autor e da Editora.br Site: www. Todos os direitos reservados. mesmo parcial. É proibida a reprodução desta obra. Guia de Consulta Rápida C++ STL de Joel Saade Copyright2006 da Novatec Editora Ltda.: +55 11 6959-6529 Fax: +55 11 6950-8869 E-mail: novatec@novatec. Rua Luís Antônio dos Santos 110 02460-000 São Paulo Brasil Tel.br . sem prévia autorização.novatec. ISBN: 85-7522-082-9 Primeira impressão: Fevereiro/2006 Novatec Editora Ltda.

................................................................................................................................................................................................................................................... 65 Adaptadores.................... 36 Map ......................................................................................... 123 Operações de heap ........................... 5 Containers .............................................................. 89 Functors para os operadores aritméticos ..................................................Sumário  Convenções .................................................................................. 87 Binders................................................................................................................................................................................................ 7 Deque.................................................................. 71 Queue (fila) .................... 71 Stack (pilha) .......................................................................................... 129 Algoritmos numéricos genéricos ................................................................................................................................................... 44 Multimap ....................... 54 Métodos comuns a todos os containers...................... 84 Adaptadores de função............................ 7 Containers seqüenciais .................................................................... 67 Iterador Input Stream Buffer ............ 128 Permutações. 100 Algoritmos relacionados à ordenação ............................................................................................................................................................................................................................................................................................................. 16 Métodos comuns aos containers seqüenciais .......... 28 Set 29 Multiset ..................................................... 65 Iterador Ostream ................................................. 65 Iterador Istream ........................ 68 Iterador Output Stream Buffer.............................................................................................................................................................................. 120 Operações de conjunto ................................................................ 81 Iterador de inserção ................................ 7 Vetor ..... 90 Predicates ....................................................................... 71 Objetos-função ................................114 Operações de ordenação e intercalação ....................... 91 Algoritmos de modificação de seqüências .............................. 89 Algoritmos................................... 78 Adaptadores de Iterador .................................................................. 89 Functors para os operadores lógicos .......................114 Operações de comparação e pesquisa ............................................................................................................... 89 Functors para os operadores relacionais ............ 74 Priority_queue (fila com prioridade) ..................................... 91 ........................................................................................................................................................................ 87 Negators................... 90 Algoritmos de não-modificação de seqüências ............ 62 Manipulação de streams..................................11 Lista ..................................... 126 Comparação lexicográfica .................... 4 Tipos comuns a todos os containers........................................................................................... 28 Pares .................... 4 Introdução à STL ... 69 Adaptadores de container..... 7 Definições .............................. 24 Containers associativos classificados.......................................................................................................................................... 81 Iterador reverso................................................................. 88 Functors predefinidos ................... 130 Iteradores ..............

foram suprimidas por serem comuns a todos os programas. disponíveis para download (www. Iterador random access. Iterador bidirectional. No site da Novatec Editora.novatec. float. as linhas de código #include <iostream> e using namespace std. assumida por um iterador. char). Função que recebe um argumento. Observações • Para os programas-exemplo que utilizam as notações it>first e it->second. Função que recebe dois argumentos.second. elemento a elemento. . br/download/). Posição após a última em um container. Tipo dos valores armazenados em um container (por exemplo. int. last) função unária função binária iteração método binário método unário past-the-end seqüência Significado Par de iteradores que define um intervalo iniciado em first e terminado. vector<int>). Definições Termo [first. Um par de iteradores passado como argumento a um algoritmo que define um intervalo de elementos sobre o qual o algoritmo atuará. • Nos programas-exemplo.first e (*it). tais programas estão na sua forma integral. caso o compilador que você esteja usando não as aceite. Convenções Convenções Convenção ItInp ItOut ItFwd ItBid ItRac método T X a Significado Iterador input. O mesmo que função-membro. Método que recebe dois argumentos. Um objeto da classe X (por exemplo. mas sem incluir last: intervalo fechado em first e aberto em last. vector<int> a). Método que recebe um argumento.com. O ato de um iterador percorrer um container seqüencialmente. utilize (*it). Iterador forward. Iterador output. Classe-container que contém objetos do tipo T (por exemplo.

. as estruturas de dados são chamadas de containers.push_back(“Rose”).push_back(“Carla”). Bem. Em 1994. 15 cout << “Vetor antes da ordenação: “.Introdução à STL  Introdução à STL A Standard Template Library (STL) é uma biblioteca integrada à biblioteca padrão de C++. Esses três componentes são básicos e o seu conhecimento é o mínimo para se usar a STL. deque. destacam-se estruturas de dados e ponteiros “inteligentes” Na .push_back(“Jane”). map e multimap. 14 nomes. A STL é uma caixa de ferramentas que auxilia. 10 // Insere valores no vetor com o método push_back() 11 nomes. nos laboratórios da Hewlett Packard. mas quais seriam essas estruturas de dados e quais seriam esses problemas? As estruturas de dados básicas são: vetor. veja o exemplo seguinte. a HP disponibilizou a STL na Internet. 13 nomes. os programas são chamados de algoritmos e os ponteiros “inteligentes” de iteradores. E mais as seguintes.++it) 17 cout << *it << “ “. Os containers armazenam valores de um dado tipo (int.push_back(“Ana”). // Vetor de objetos string 8 // Iterador para vetores de objetos string 9 vector<string>::iterator it. por meio do mecanismo de templates. Os algoritmos correspondem às ações a serem executadas sobre os containers (ordenação. Entre os problemas encontrados no desenvolvimento de aplicações que usam estruturas de dados. que traz soluções para muitos problemas de programação que envolvem estruturas de dados. com a valiosa colaboração de David R. multiset. Para mostrar a poder da STL.it != nomes. destacam-se: • • • ordenar os elementos de uma lista. set. Os iteradores percorrem os elementos dos containers da mesma forma que um índice percorre os elementos de um array. float etc). 16 for (it = nomes.begin(). entre eles.end(). 1 // Cria um vetor com nomes e o ordena ascendentemente 2 #include <algorithm> // Para algoritmos 3 #include <vector> // Para containers vector 4 #include <string> // Para objetos string 5 int main() 6 { 7 vector<string> nomes. pesquisa e outras). gerenciar a memória quando da inserção ou eliminação de elementos de uma deque. criadas a partir das estruturas básicas: pilha. terminologia STL. Além de programas contém outros componentes. fila e fila com prioridade. . lista. Musser. efetuar uma pesquisa eficiente em um vetor. A STL foi desenvolvida por Alexander Stepanov e Meng Lee. 12 nomes. o comitê ISO/ANSI C++ decidiu incorporar a STL à biblioteca padrão de C++ e neste mesmo ano.

for (it = nomes. 18 19 20 21 22 23 24 } Introdução à STL cout << endl.it != nomes. Este iterador poderá ser utilizado com outros vetores desde que tenham elementos do tipo string. Exibe o valor de cada elemento do vetor por meio do operador de de-referência *. para percorrer os elementos do vetor. // Ordena o vetor cout << “Vetor depois da ordenação: “. Resultado da execução do programa Vetor antes da ordenação: Ana Rose Jane Carla Vetor depois da ordenação: Ana Carla Jane Rose As observações seguintes aplicam-se ao programa-exemplo recém-apresentado. Declara um container do tipo vetor com elementos do tipo string. Utiliza o algoritmo sort para ordenar elementos de containers. Utilizam o método push_back() definido para vetores. Linha 2 Descrição 3 7 9 11 a 14 16 17 19 É necessária para a maioria dos algoritmos.begin().end().nomes. que retorna o valor apontado pelo iterador it. por apresentarem conceitos básicos importantes. do primeiro até o último. cuja tarefa é inserir elementos no final de um vetor. por meio do iterador it.end()). Declara um iterador. Acessa cada elemento do vetor. . return 0. sort(nomes. É necessária para o uso do container vetor. Há de se notar que apenas uma linha de comando foi necessária para efetuar a ordenação do vetor.begin().++it) cout << *it << “ “. sendo válidas também para a maioria dos programas-exemplo contidos neste guia. havendo um arquivo-cabeçalho para cada container. chamado nomes. chamado it.

em que o primeiro membro do par é const para que a chave não seja alterada. Equivale ao argumento Allocator. X::value_type Tipo dos elementos (T) armazenados em X. Para map e multimap é pair<const Key.Containers  Containers São estruturas de dados que armazenam valores. os elementos armazenados em um X constante. deque e lista. por meio de um objeto alocador de memória próprio. Iterador suportado: random access. em que os elementos são armazenados de forma contígua e podem ser acessados aleatoriamente por meio do operador [ ]. X::const_iterator Iterador constante para acessar os elementos armazenados em um X constante. X::allocator_type Containers seqüenciais São containers cujos elementos estão em uma ordem linear. de forma reversa. X::difference_type Inteiro sinalizado que representa a diferença entre dois iteradores de X. X::reverse_iterator Iterador para acessar. com as seguintes características: • Alocação e gerenciamento da memória. Os tipos podem ser os básicos (int. São homogêneos. Estão divididos em duas categorias: seqüenciais e associativos classificados. aumentando ou diminuindo à medida que elementos são inseridos ou eliminados. isto é. Os containers seqüenciais são: vetor. X::iterator Iterador para acessar os elementos armazenados em X. do último para o primeiro elemento. os elementos armazenados em X. X::size_type Inteiro sem sinal que armazena valores do tipo difference_type ou o tamanho de X. X::const_reverse_iterator Iterador constante para acessar. float etc) ou criados pelo programador (estrutura ou classe). Dispõem de gerenciamento automático de memória que permite ao tamanho do container variar dinamicamente. de forma reversa. Tipos comuns a todos os containers Tipo Descrição Representa o alocador de memória para X.T>. . • Fornecimento de métodos para a sua manipulação. pois armazenam valores de um mesmo tipo. Container vetor deque lista Arquivo-cabeçalho vector deque list Vetor A classe-template vector representa uma estrutura de dados que pode ser comparada a um array dinâmico de C++. • Reversibilidade: cada container pode ser acessado de forma reversa. Um array de C++ é um exemplo de container seqüencial.

for (it = v1.begin().end(). Cria um vetor e o inicializa com os elementos do vetor x.++it) cout << *it << “ “. } vector() vector(const vector<T. return 0.9).++it) cout << *it << “ “. reference Referência para os elementos de vetores. cout << “Vetor v1: “. vector<int>::iterator it. Exibe os vetores com iteradores */ #include <vector> int main() { vector<int> v1(3).typename Allocator = allocator<T> > class vector Definição de tipos As classes-template vector.const T& valor = T(). deques e listas (const T&). deques e listas (T&). return 0. deques e listas (T*). É exibido com a notação de array e com iteradores */ #include <vector> int main() { vector<int> v1(3. const Allocator& = Allocator()).begin().++it) cout << *it << “ “. /* jvconcop.++i) cout << v1[i] << “ “.end(). const_reference Referência const para os elementos de vetores. Cria um vetor vazio.it != v1. /* jvcria01. cout << “ Vetor v1: “. } vector() explicit vector(size_type n. Construtores vector() vector(const Allocator& = Allocator()).i < 3.cpp – Cria um vetor inicializado com o valor 9. deque e list definem os tipos: Tipo const_pointer Descrição Ponteiro const para os elementos de vetores. for (it = v1. Exemplo #include <vector> int main() { vector<int> v1. Cria um vetor com n elementos e o inicializa com valor.it != v2.it != v1. for (it = v2. vector<int>::iterator it. vector<int> v2(v1). pointer Ponteiro para os elementos de vetores. Allocator>& x). for (int i = 0. // vetor de inteiros return 0. v1[2] = 3.cpp – Cria o vetor v2 a partir do vetor v1. // Iterador // Atribui valores com a notação de array v1[0] = 1. // Iterador cout << “Vetor v1: “. deques e listas (const T*). Declaração da classe Containers template <typename T.begin(). // Cria o vetor v2 cout << “ Vetor v2: “. v1[1] = 2. } .end().

vector<int> v2(v1.++it) cout << *it << “ “. const vector<T. v1[1] = 6. v1[2] = 3. cout << “Vetor v1: “. if (res == true) cout << “Vetores iguais”. return 0.v1. inicializado com os elementos do intervalo [first.cpp #include <vector> int main() { vector<int> v1(3).++i) cout << v2[i] << “ “.++it) cout << *it << “ “.i < 3. last). // Cria v2 cout << “ Vetor v2: “. v1[0] = 1. } operator==() template <typename T.end().begin(). caso contrário. for (int i = 0. v2[2] = 1.++i) cout << v1[i] << “ “. v1[2] = 3.  Cria um vetor. cout << “v2 depois da substituição: “. // Iterador v1[0] = 5.Allocator>& x. false. v1[1] = 2. Substitui o conteúdo do vetor corrente pelo conteúdo do vetor x. cout << “ v2 antes da substituição: “. return 0. /* jvint.cpp #include <vector> int main() { vector<int> v1(3).const Allocator& = Allocator()). cout << endl.it != v2.Allocator>& x). v2[1] = 2. // jvopeq.v2(4). for (int i = 0.end()). vector<int>::iterator it. return 0.Containers vector() template <typename ItInp> vector(ItInp first. for (it = v2.Allocator>& y). else cout << “Vetores diferentes”. v2[1] = 1.end().cpp – Cria o vetor v2 com intervalo do vetor v1 */ #include <vector> int main() { vector<int> v1(3).it != v1. } . v2[0] = 1.begin(). } Operações de atribuição e comparação operator=() vector<T.begin(). v2[3] = 1.begin(). for (it = v2. v2[0] = 1.i < 3. bool res = (v1 == v2). v1[1] = 2.Allocator>& operator=(const vector<T.ItInp last.it != v2. v1[0] = 1. v2 = v1.typename Allocator> bool operator==(const vector<T.end().++it) cout << *it << “ “.v2(3). Retornará true se os vetores x e y tiverem o mesmo tamanho e os mesmos elementos na mesma ordem. // jvopeqeq. v2[2] = 3. cout << “v1: “. v1[2] = 7. for (it = v1.

operator>=() template <typename T.10 operator<() template <typename T. false.typename Allocator> bool operator>(const vector<T. false.Allocator>& x. Retornará true se o vetor x for menor que ou igual ao vetor y.Allocator>& x. vector<int>::reference val = v1.Allocator>& x. cout << “Valor da posição 2: “ << val.typename Allocator> bool operator>=(const vector<T. caso contrário. Retornará true se o vetor x for maior que o vetor y. operator!=() template <typename T. Retornará true se vetor x for diferente do vetor y. false. Retorna o número máximo de elementos que o vetor pode armazenar sem realocação de memória.Allocator>& y). /* jvat. false. Containers Retornará true se o vetor x for lexicograficamente menor que o vetor y.at(2). const vector<T.typename Allocator> bool operator<=(const vector<T. v1[0] = 1. v1[1] = 2.Allocator>& x. caso contrário. caso contrário.Allocator>& y). v1[2] = 3.typename Allocator> bool operator<(const vector<T.cpp – Retorna o valor de determinado elemento de um vetor */ #include <vector> int main() { vector<int> v1(3).typename Allocator> bool operator!=(const vector<T. const vector<T. operator>() template <typename T. Métodos at() reference at(size_type n). const vector<T. Retorna uma referência (ou uma referência constante para um vetor constante) para o elemento da posição n. false. const_reference at(size_type n) const.Allocator>& y). const vector<T. return 0. caso contrário. const vector<T.Allocator>& y). . operator<=() template <typename T.Allocator>& x. Retornará true se o vetor x for maior que ou igual ao vetor y.Allocator>& y). } capacity() size_type capacity() const. caso contrário.

vector<int>::reference valor = v1[2]. v1[0] = 1. return 0. v1[1] = 2. // jvoparr. vector<int>::size_type qtd = v1. } 11 operator[]() reference operator[](size_type n). A exemplo do vetor.++i) cout << v1[i] << “ “. Retorna uma referência (ou uma referência constante para um vetor constante) para o elemento da posição n. Altera o tamanho do vetor de modo que a memória seja gerenciada adequadamente. for (int i = 0. a deque também suporta o operador [ ]. v1. A realocação ocorrerá se a capacidade atual do vetor for menor que n. return 0.Containers // jvcapac. } Deque A classe-template deque representa uma estrutura de dados do tipo double-ended queue (fila com duas extremidades).cpp #include <vector> int main() { vector<int> v1(5). v1[0] = 3. cout << “v1 depois de swap(): “.cpp #include <vector> int main() { vector<int> v1(3). v1[1] = 3.i < 2. const_reference operator[](size_type n) const. cout << “Valor da posição 2: “ << valor. Após a chamada a reserve() a capacidade será maior que ou igual à n se a realocação ocorrer. caso contrário. return 0. v2[0] = 5. cout << “ v2 depois de swap(): “.Allocator>& x).cpp #include <vector> int main() { vector<int> v1(2). for (int i = 0.capacity(). será igual à capacidade anterior. Iterador suportado: random access.v2(2).swap(v2). Troca o conteúdo do vetor chamador pelo conteúdo do vetor x e vice-versa. cout << “Máximo: “ << qtd. v1[2] = 3. // jvswap. As operações de inserção e eliminação podem ser feitas em ambos os extremos e os seus elementos não são armazenados em posições contíguas de memória.i < 2. swap() void swap(vector<T. } reserve() void reserve(size_type n).++i) cout << v2[i] << “ “. v2[1] = 5. .

begin(). d1[2] = 3.begin(). return 0.++it) cout << *it << “ “.it != d2. cout << “ Deque d1: “. pág.ItInp last.end(). Cria uma deque e a inicializa com os elementos da deque x.const Allocator& = Allocator()).cpp – Cria uma deque inicializada com o valor 9.typename Allocator = allocator<T> > class deque Definição de tipos A classe-template deque define tipos que são iguais aos definidos pela classe-template vector. É exibida com a notação de array e com iteradores */ #include <deque> int main() { deque<int> d1(3.it != d1.++it) cout << *it << “ “.begin(). } deque() template <typename ItInp> deque(ItInp first. Cria uma deque.end().end().const T& valor = T().it != d1. } deque() explicit deque(size_type n. } deque() deque(const deque<T.Allocator>& x). last). // Iterador cout << “Deque d1: “. for (it = d1. Exemplo #include <deque> int main() { deque<int> d1. . /* jdcria01. // jdconcop. deque<int> d2(d1). d1[1] = 2. Construtores deque() deque(const Allocator& = Allocator()). cout << “Deque d1: “. // Iterador // Atribui valores com a notação de array d1[0] = 1.++it) cout << *it << “ “. Cria uma deque com n elementos e a inicializa com valor. for (it = d1.9).cpp – Cria uma deque (d2) a partir de outra (d1) #include <deque> int main() { deque<int> d1(3). Cria uma deque vazia. const Allocator& = Allocator()). deque<int>::iterator it. inicializada com os elementos do intervalo [first. return 0. return 0.++i) cout << d1[i] << “ “. deque<int>::iterator it. for (int i = 0.i < 3. for (it = d2.1 Declaração da classe Containers template <typename T. // Cria a deque d2 cout << “ Deque d2: “. 8.

d2[2] = 1. } operator<() template <typename T.Allocator>& x. } Operações de atribuição e comparação operator=() deque<T.++it) cout << *it << “ “.cpp – Cria a deque d2 com intervalo da deque d1 */ #include <deque> int main() { deque<int> d1(3). d1[2] = 3. for (it = d1.cpp #include <deque> int main() { deque<int>::iterator it. return 0. return 0. // Iterador deque<int> d1(3). cout << “Deque d1: “. for (int i = 0. d1[1] = 2. for (it = d2.d2(3).Allocator>& y).end().begin(). d2[3] = 1. return 0.Allocator>& operator=(const deque<T. false.end()). // jdopeqeq.Allocator>& y). Retornará true se as deques x e y tiverem o mesmo tamanho e os mesmos elementos na mesma ordem.Allocator>& x. . d2[0] = 1. d2[1] = 1.i < 3.begin(). cout << “d2 depois da substituição: “.++it) cout << *it << “ “. // Iterador d1[0] = 1. if (res == true) cout << “Deques iguais”. d2[0] = 1. for (it = d2. for (int i = 0.it != d1. d1[2] = 7.i < 3. d1[2] = 3. // Cria d2 cout << “ Deque d2: “.begin(). d1[1] = 2.end(). bool res = (d1 == d2).d1. const deque<T.cpp #include <deque> int main() { deque<int> d1(3). d1[1] = 6. Substitui o conteúdo da deque corrente pelo conteúdo da deque x. const deque<T.d2(4).it != d2.++i) cout << d2[i] << “ “. Retornará true se a deque x for lexicograficamente menor que a deque y.typename Allocator> bool operator<(const deque<T.Containers 1 /* jdint. d2[2] = 3. cout << “ d2 antes da substituição: “. deque<int> d2(d1. d2[1] = 2. d2 = d1. else cout << “Deques diferentes”.Allocator>& x).begin(). cout << endl. cout << “d1: “.end(). } operator==() template <typename T. caso contrário. d1[0] = 1.it != d2.++i) cout << d1[i] << “ “.++it) cout << *it << “ “.typename Allocator> bool operator==(const deque<T. caso contrário. // jdopeq. deque<int>::iterator it. false. d1[0] = 5.

Allocator>& x. operator>() template <typename T. /* jdat. operator<=() template <typename T.Allocator>& y). false. const_reference at(size_type n) const. false.push_back(1). operator>=() template <typename T.typename Allocator> bool operator>(const deque<T.cpp – Retorna o valor de determinado elemento de uma deque */ #include <deque> int main() { deque<int> d1. } operator[]() reference operator[](size_type n) const.cpp – Retorna o valor de determinado elemento de uma deque */ #include <deque> int main() { deque<int> d1(3).Allocator>& y). false.Allocator>& y). Containers Retornará true se a deque x for diferente da deque y. . caso contrário.typename Allocator> bool operator!=(const deque<T.at(2).push_back(3). Retornará true se a deque x for maior que ou igual à deque y. d1. Métodos at() reference at(size_type n). Retornará true se a deque x for menor que ou igual à deque y.1 operator!=() template <typename T. caso contrário.typename Allocator> bool operator<=(const deque<T. // Insere valores com o método push_back() d1. d1[2] = 3. d1[0] = 1.Allocator>& x.Allocator>& x. d1. const deque<T. const_reference operator[] (size_type n) const. const deque<T.push_back(2). caso contrário.Allocator>& y).Allocator>& x. Retorna uma referência (ou uma referência constante para uma deque constante) para o elemento da posição n. Retorna uma referência (ou uma referência constante para uma deque constante) para o elemento da posição n. /* jdoparr. d1[1] = 2. const deque<T. Retornará true se a deque x for maior que a deque y. false. caso contrário. cout << “Valor da posição 2: “ << valor. deque<int>::reference valor = d1. return 0. const deque<T.typename Allocator> bool operator>=(const deque<T.

d1.it != d1.push_back(i).begin(). for (it = d1. return 0. } 1 pop_front() void pop_front().push_front(“delta”).i < 5.i++) // Insere 1 2 3 4 d1.++it) cout << *it << “ “. } swap() void swap(deque<T.i < 9.cpp #include <deque> #include <string> // Para objetos string int main() { deque<string> d1(2). // jdswap. deque<string>::iterator it. d1.++it) cout << *it << “ “. return 0. d1.swap(d2).cpp #include <deque> #include <string> // Para objetos string int main() { deque<string> d1. Insere o elemento x no início da deque.pop_front(). deque<int>::iterator it. for (it = d1. for (int i = 5.it != d1.begin().it != d1. for (it = d2. for (it = d1. cout << “d1 depois de swap(): “. for (it = d1.begin(). // jdpopfro.++it) cout << *it << “ “.it != d1. d1.cpp – Troca o conteúdo de duas deques #include <deque> int main() { deque<int> d1. Troca o conteúdo da deque chamadora pelo conteúdo da deque x e vice-versa. cout << “Antes de pop_front(): “. cout << “ Depois de pop_front(): “. } . cout << “Depois de push_front(): “.Containers deque<int>::reference valor = d1[2].begin().end(). d1[1] = “beta”.begin().end().end().push_back(“gama”). deque<string>::iterator it. for (it = d1. return 0.i++) // Insere 5 6 7 8 d2.d2.push_back(i). cout << “Antes de push_front(): “. cout << “ d2 depois de swap(): “.Allocator>& x). // Iterador d1[0] = “alfa”. return 0. // Iterador for (int i = 1. } push_front() void push_front(const T& x).++it) cout << *it << “ “.end().it != d2. // Iterador d1. d1.end().it != d1.++it) cout << *it << “ “.push_back(“alfa”).end().push_back(“beta”).begin(). Elimina o primeiro elemento da deque. // jdpusfro.++it) cout << *it << “ “. cout << “Valor da posição 2: “ << valor. cout << endl.