Guia de Consulta Rpida

C++ STL
Joel Saade
Novatec Editora
2
Guia de Consulta Rpida C++ STL de Joel Saade
Copyright2006 da Novatec Editora Ltda.
Todos os direitos reservados. proibida a reproduo desta
obra, mesmo parcial, por qualquer processo, sem prvia
autorizao, por escrito, do autor e da Editora.
ISBN: 85-7522-082-9
Primeira impresso: Fevereiro/2006
Novatec Editora Ltda.
Rua Lus Antnio dos Santos 110
02460-000 So Paulo Brasil
Tel.: +55 11 6959-6529
Fax: +55 11 6950-8869
E-mail: novatec@novatec.com.br
Site: www.novatec.com.br
3
Convenes ............................................................. 4
Defnies ....................................................................................... 4
Introduo STL ..................................................... 5
Containers ................................................................ 7
Tipos comuns a todos os containers ................................................ 7
Containers seqenciais .................................................................... 7
Vetor .......................................................................................... 7
Deque ........................................................................................11
Lista ......................................................................................... 16
Mtodos comuns aos containers seqenciais .......................... 24
Containers associativos classifcados ............................................ 28
Pares ........................................................................................ 28
Set 29
Multiset .................................................................................... 36
Map .......................................................................................... 44
Multimap ................................................................................. 54
Mtodos comuns a todos os containers ......................................... 62
Iteradores ............................................................... 65
Manipulao 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 insero ................................................................. 81
Iterador reverso ........................................................................ 84
Adaptadores de funo .................................................................. 87
Binders ..................................................................................... 87
Negators ................................................................................... 88
Objetos-funo ...................................................... 89
Functors predefnidos .................................................................... 89
Functors para os operadores aritmticos ................................. 89
Functors para os operadores relacionais .................................. 89
Functors para os operadores lgicos ....................................... 90
Predicates ...................................................................................... 90
Algoritmos .............................................................. 91
Algoritmos de no-modifcao de seqncias ............................. 91
Algoritmos de modifcao de seqncias .................................. 100
Algoritmos relacionados ordenao ..........................................114
Operaes de ordenao e intercalao ..................................114
Operaes de comparao e pesquisa ................................... 120
Operaes de conjunto .......................................................... 123
Operaes de heap ................................................................. 126
Comparao lexicogrfca ..................................................... 128
Permutaes ........................................................................... 129
Algoritmos numricos genricos ................................................ 130
Somrio
4
Convenes
Conveno Signifcado
ItInp Iteradorinput.
ItOut Iteradoroutput.
ItFwd Iteradorforward.
ItBid Iteradorbidirectional.
ItRac Iteradorrandomaccess.
mtodo Omesmoquefuno-membro.
T Tipodosvaloresarmazenadosemumcontainer(porexemplo,int,
foat,char).
X Classe-container que contm objetos do tipo T (por exemplo,
vector<int>).
a UmobjetodaclasseX(porexemplo,vector<int> a).
Defnies
Termo Signifcado
[frst,last) Pardeiteradoresquedefneumintervaloiniciadoemfrst e
terminado,massemincluirlast:intervalofechadoemfrst e
abertoemlast.
funounria Funoquerecebeumargumento.
funobinria Funoquerecebedoisargumentos.
iterao Oatodeumiteradorpercorrerumcontainerseqencialmente,
elementoaelemento.
mtodobinrio Mtodoquerecebedoisargumentos.
mtodounrio Mtodoquerecebeumargumento.
past-the-end Posio aps a ltima em um container, assumida por um
iterador.
seqncia Umpardeiteradorespassadocomoargumentoaumalgoritmo
quedefneumintervalodeelementossobreoqualoalgoritmo
atuar.
Observaes
Para os programas-exemplo que utilizam as notaes it-
>frst e it->second, caso o compilador que voc esteja
usando no as aceite, utilize (*it).frst e (*it).second.
Nos programas-exemplo, as linhas de cdigo #include
<iostream> e using namespace std; foram suprimidas
por serem comuns a todos os programas. No site da
Novatec Editora, tais programas esto na sua forma
integral, disponveis para download (www.novatec.com.
br/download/).
Convonos
5
Introduo STL
A Standard Template Library (STL) uma biblioteca integrada
biblioteca padro de C++, por meio do mecanismo de templates.
Alm de programas contm outros componentes, entre eles,
destacam-se estruturas de dados e ponteiros inteligentes. Na
terminologia STL, as estruturas de dados so chamadas de
containers, os programas so chamados de algoritmos e os
ponteiros inteligentes, de iteradores.
Os containers armazenam valores de um dado tipo (int, foat
etc). Os algoritmos correspondem s aes a serem executadas
sobre os containers (ordenao, pesquisa e outras). Os iteradores
percorrem os elementos dos containers da mesma forma que um
ndice percorre os elementos de um array. Esses trs componentes
so bsicos e o seu conhecimento o mnimo para se usar a
STL.
A STL uma caixa de ferramentas que auxilia, que traz
solues para muitos problemas de programao que envolvem
estruturas de dados.
Bem, mas quais seriam essas estruturas de dados e quais
seriam esses problemas?
As estruturas de dados bsicas so: vetor, lista, deque, set,
multiset, map e multimap. E mais as seguintes, criadas a partir
das estruturas bsicas: pilha, fla e fla com prioridade.
Entre os problemas encontrados no desenvolvimento de
aplicaes que usam estruturas de dados, destacam-se:
ordenar os elementos de uma lista;
efetuar uma pesquisa efciente em um vetor;
gerenciar a memria quando da insero ou eliminao
de elementos de uma deque.
A STL foi desenvolvida por Alexander Stepanov e Meng Lee,
nos laboratrios da Hewlett Packard, com a valiosa colaborao
de David R. Musser. Em 1994, o comit ISO/ANSI C++ decidiu
incorporar a STL biblioteca padro 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 //Inserevaloresnovetorcomomtodopush_back()
11 nomes.push_back(Ana);
12 nomes.push_back(Rose);
13 nomes.push_back(Jane);
14 nomes.push_back(Carla);
15 cout<<Vetorantesdaordenao:;
16 for(it=nomes.begin();it!=nomes.end();++it)
17 cout<<*it<<;
lnlroooo o STL

18 cout<<endl;
19 sort(nomes.begin(),nomes.end());//Ordenaovetor
20 cout<<Vetordepoisdaordenao:;
21 for(it=nomes.begin();it!=nomes.end();++it)
22 cout<<*it<<;
23 return0;
24 }
Resultado da execuo do programa
Vetorantesdaordenao:AnaRoseJaneCarla
Vetordepoisdaordenao:AnaCarlaJaneRose
As observaes seguintes aplicam-se ao programa-exemplo
recm-apresentado, sendo vlidas tambm para a maioria dos
programas-exemplo contidos neste guia, por apresentarem
conceitos bsicos importantes.
Linha Descrio
2 necessria para a maioria dos algoritmos.
3 necessria para o uso do container vetor,
havendo um arquivo-cabealho 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 mtodo 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-referncia *, 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 necessria para efetuar a
ordenao do vetor.
lnlroooo o STL
7
Conloinors
Containers
So estruturas de dados que armazenam valores. Esto divididos
em duas categorias: seqenciais e associativos classifcados,
com as seguintes caractersticas:
Alocao e gerenciamento da memria, por meio de um
objeto alocador de memria prprio.
Fornecimento de mtodos para a sua manipulao.
Reversibilidade: cada container pode ser acessado de forma
reversa, isto , do ltimo para o primeiro elemento.
Tipos comuns a todos os containers
Tipo Descrio
X::allocator_type Representa o alocador de memria para X.
EquivaleaoargumentoAllocator.
X::difference_type Inteirosinalizadoquerepresentaadiferenaentre
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 multimappair<const Key,T>,emque
oprimeiro membro do par constpara que a
chavenosejaalterada.
Containers seqenciais
So containers cujos elementos esto em uma ordem linear. So
homogneos, pois armazenam valores de um mesmo tipo. Os tipos
podem ser os bsicos (int, foat etc) ou criados pelo programador
(estrutura ou classe). Um array de C++ um exemplo de container
seqencial. Dispem de gerenciamento automtico de memria
que permite ao tamanho do container variar dinamicamente,
aumentando ou diminuindo medida que elementos so
inseridos ou eliminados. Os containers seqenciais so: vetor,
deque e lista.
Container Arquivo-cabealho
vetor vector
deque deque
lista list
Vetor
A classe-template vector representa uma estrutura de dados
que pode ser comparada a um array dinmico de C++, em que
os elementos so armazenados de forma contgua e podem ser
acessados aleatoriamente por meio do operador [ ].
Iterador suportado: random access.
8 Conloinors
Declarao da classe
template<typenameT,typenameAllocator=allocator<T>>classvector
Defnio de tipos
As classes-template vector, deque e list defnem os tipos:
Tipo Descrio
const_pointer Ponteiroconstparaoselementosdevetores,dequeselistas
(const T*).
pointer Ponteiroparaoselementosdevetores,dequeselistas(T*).
const_reference Refernciaconstparaoselementosdevetores,dequeselistas
(const T&).
reference Referncia 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.cppCriaumvetorinicializadocomovalor9.
exibidocomanotaodearrayecomiteradores*/
#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.cppCriaovetorv2apartirdovetorv1.
Exibeosvetorescomiteradores*/
#include<vector>
intmain(){
vector<int>v1(3);
vector<int>::iteratorit;//Iterador
//Atribuivalorescomanotaodearray
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.cppCriaovetorv2comintervalodovetorv1*/
#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;}
Operaesdeatribuioecomparao
operator=()
vector<T,Allocator>&operator=(constvector<T,Allocator>&x);
Substitui o contedo do vetor corrente pelo contedo 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<<v2antesdasubstituio:;
for(it=v2.begin();it!=v2.end();++it)cout<<*it<<;
cout<<endl;
v2=v1;
cout<<v2depoisdasubstituio:;
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 contrrio, 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 contrrio, 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
contrrio, 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
contrrio, 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 contrrio, 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 contrrio, false.
Mtodos
at()
referenceat(size_typen);
const_referenceat(size_typen)const;
Retorna uma referncia (ou uma referncia constante para um
vetor constante) para o elemento da posio n.
/* jvat.cppRetornaovalordedeterminadoelementode
umvetor*/
#include<vector>
intmain(){
vector<int>v1(3);
v1[0]=1;v1[1]=2;v1[2]=3;
vector<int>::referenceval=v1.at(2);
cout<<Valordaposio2:<<val;
return0;}
capacity()
size_typecapacity()const;
Retorna o nmero mximo de elementos que o vetor pode
armazenar sem realocao de memria.
11
Conloinors
//jvcapac.cpp
#include<vector>
intmain(){
vector<int>v1(5);
vector<int>::size_typeqtd=v1.capacity();
cout<<Mximo:<<qtd;
return0;}
operator[]()
referenceoperator[](size_typen);
const_referenceoperator[](size_typen)const;
Retorna uma referncia (ou uma referncia constante para um
vetor constante) para o elemento da posio 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<<Valordaposio2:<<valor;
return0;}
reserve()
voidreserve(size_typen);
Altera o tamanho do vetor de modo que a memria seja
gerenciada adequadamente. A realocao ocorrer se a
capacidade atual do vetor for menor que n. Aps a chamada
a reserve() a capacidade ser maior que ou igual n se a
realocao ocorrer, caso contrrio, ser igual capacidade
anterior.
swap()
voidswap(vector<T,Allocator>&x);
Troca o contedo do vetor chamador pelo contedo 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 tambm suporta o operador [ ]. As
operaes de insero e eliminao podem ser feitas em ambos os
extremos e os seus elementos no so armazenados em posies
contguas de memria.
Iterador suportado: random access.
12 Conloinors
Declarao da classe
template<typenameT,typenameAllocator=allocator<T>>classdeque
Defnio de tipos
A classe-template deque defne tipos que so iguais aos
defnidos pela classe-template vector, pg. 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.
exibidacomanotaodearrayecomiteradores*/
#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.cppCriaumadeque(d2)apartirdeoutra(d1)
#include<deque>
intmain(){
deque<int>d1(3);
deque<int>::iteratorit; //Iterador
//Atribuivalorescomanotaodearray
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;}
Operaesdeatribuioecomparao
operator=()
deque<T,Allocator>&operator=(constdeque<T,Allocator>&x);
Substitui o contedo da deque corrente pelo contedo 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<<d2antesdasubstituio:;
for(it=d2.begin();it!=d2.end();++it)cout<<*it<<;
cout<<endl;
d2=d1;
cout<<d2depoisdasubstituio:;
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 contrrio, 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 contrrio, 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
contrrio, 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
contrrio, 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 contrrio, 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 contrrio, false.
Mtodos
at()
referenceat(size_typen);
const_referenceat(size_typen)const;
Retorna uma referncia (ou uma referncia constante para uma
deque constante) para o elemento da posio n.
/* jdat.cppRetornaovalordedeterminadoelementode
umadeque*/
#include<deque>
intmain(){
deque<int>d1;
//Inserevalorescomomtodopush_back()
d1.push_back(1);d1.push_back(2);d1.push_back(3);
deque<int>::referencevalor=d1.at(2);
cout<<Valordaposio2:<<valor;
return0;}
operator[]()
referenceoperator[](size_typen)const;
const_referenceoperator[](size_typen)const;
Retorna uma referncia (ou uma referncia constante para uma
deque constante) para o elemento da posio n.
/* jdoparr.cppRetornaovalordedeterminadoelementode
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<<Valordaposio2:<<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 incio 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 contedo da deque chamadora pelo contedo da
deque x e vice-versa.
//jdswap.cppTrocaocontedodeduasdeques
#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;}