Logo Passei Direto
Buscar
Material
páginas com resultados encontrados.
páginas com resultados encontrados.

Escolha uma das opções e acesse esse e outros materiais sem bloqueio. 🤩

Cadastre-se ou realize login

Ao continuar, você aceita os Termos de Uso e Política de Privacidade

Escolha uma das opções e acesse esse e outros materiais sem bloqueio. 🤩

Cadastre-se ou realize login

Ao continuar, você aceita os Termos de Uso e Política de Privacidade

Escolha uma das opções e acesse esse e outros materiais sem bloqueio. 🤩

Cadastre-se ou realize login

Ao continuar, você aceita os Termos de Uso e Política de Privacidade

Escolha uma das opções e acesse esse e outros materiais sem bloqueio. 🤩

Cadastre-se ou realize login

Ao continuar, você aceita os Termos de Uso e Política de Privacidade

Escolha uma das opções e acesse esse e outros materiais sem bloqueio. 🤩

Cadastre-se ou realize login

Ao continuar, você aceita os Termos de Uso e Política de Privacidade

Escolha uma das opções e acesse esse e outros materiais sem bloqueio. 🤩

Cadastre-se ou realize login

Ao continuar, você aceita os Termos de Uso e Política de Privacidade

Escolha uma das opções e acesse esse e outros materiais sem bloqueio. 🤩

Cadastre-se ou realize login

Ao continuar, você aceita os Termos de Uso e Política de Privacidade

Escolha uma das opções e acesse esse e outros materiais sem bloqueio. 🤩

Cadastre-se ou realize login

Ao continuar, você aceita os Termos de Uso e Política de Privacidade

Escolha uma das opções e acesse esse e outros materiais sem bloqueio. 🤩

Cadastre-se ou realize login

Ao continuar, você aceita os Termos de Uso e Política de Privacidade

Escolha uma das opções e acesse esse e outros materiais sem bloqueio. 🤩

Cadastre-se ou realize login

Ao continuar, você aceita os Termos de Uso e Política de Privacidade

Prévia do material em texto

C++ 
moderno 
eficaz 
42 MANEIRAS ESPECÍFICAS DE MELHORAR SEU USO DE C++11 E C++14 
 
 
Scott 
Meyers 
 
 
C++ moderno eficaz 
Conhecer o C++ 11 e o C++ 14 é mais do que uma questão de se 
familiarizar com os recursos que eles apresentam (por exemplo, 
declarações de tipo automático , semântica de movimentação, 
expressões lambda e suporte à simultaneidade). O desafio é 
aprender a usar esses recursos de maneira eficaz — para que seu 
software seja correto, eficiente, fácil de manter e portátil. É aí que 
entra este livro prático. Ele descreve como escrever software 
realmente excelente usando C++ 11 e C++ 14 — ou seja, usando 
C++ moderno . Os tópicos incluem: 
■ Os prós e contras da inicialização reforçada, especificações 
noexcept , encaminhamento perfeito e ponteiro inteligente 
tornam 
funções 
■ As relações entre std::move , std::forward , referências 
rvalue e referências universais 
■ Técnicas para escrever expressões lambda claras, corretas e 
eficazes 
■ Como std::atomic difere de volátil , como cada um deve ser 
usado e como eles se relacionam com a API de 
simultaneidade do C++ ■ Como as melhores práticas na 
programação C++ "antiga" (ou seja, C++ 98) exigem revisão 
para desenvolvimento de software em C++ moderno 
Effective Modern C++ segue o formato comprovado baseado em 
diretrizes e baseado em exemplos dos livros anteriores de Scott 
Meyers, mas cobre material inteiramente novo. É uma leitura 
essencial para todo desenvolvedor de software C++ moderno. 
 
Por mais de 20 anos, os livros 
Effective C++ de Scott Meyers ( 
Effective C++ , More Effective C++ 
e Effective STL ) definiram o padrão 
para orientação de programação 
em C++. Suas explicações claras e 
envolventes sobre materiais 
técnicos complexos lhe renderam 
seguidores em todo o mundo, 
mantendo-o requisitado como 
instrutor, consultor e apresentador 
de conferências. Ele tem um Ph.D. 
em Ciência da Computação pela 
Brown University. 
“ Depois de 
 aprender os 
fundamentos do C++, 
aprendi como usar o 
C++ no código de 
produção da série de 
 livros sobre C++ 
Efetivo de Meyers . 
 C++ moderno 
eficaz é 
 o mais 
importante como 
reservar para obter 
conselhos sobre as 
 
 
US $49.99 CAN $52.99 
 
 
 
 
principais diretrizes, estilos e expressões para 
usar o C++ moderno de maneira eficaz e 
adequada. ” 
—Herb Sutter 
Presidente do Comitê de Padrões ISO C++ e 
Arquiteto de software C++ na Microsoft 
 
 
Elogios ao C++ moderno e eficaz 
Então, ainda está interessado em C++? Você deveria estar! O C++ 
moderno (ou seja, C++11/C++14) é muito mais do que apenas uma 
reformulação. Considerando as novidades, parece que é mais uma 
reinvenção. Procurando orientações e assistência? Então este livro é 
certamente o que você está procurando. No que diz respeito ao C++, 
Scott Meyers foi e ainda é sinônimo de precisão, qualidade e prazer. 
—Gerhard Kreuzer 
Engenheiro de Pesquisa e Desenvolvimento, Siemens AG 
Encontrar o máximo de experiência já é bastante difícil. Encontrando o ensino do 
perfeccionismo - 
a obsessão de um autor em criar estratégias e simplificar as explicações – 
também é difícil. 
Você sabe que terá uma surpresa quando encontrar os dois incorporados na 
mesma pessoa. 
Effective Modern C++ é uma grande conquista de um escritor técnico consumado. 
Ele sobrepõe esclarecimentos lúcidos, significativos e bem sequenciados 
sobre tópicos complexos e interconectados, tudo em um estilo literário nítido. 
É igualmente improvável que você encontre um erro técnico, um momento de 
tédio ou uma frase preguiçosa em Effective Modern C++ . —Andrei 
Alexandrescu 
Ph.D., cientista pesquisador, Facebook e autor de Modern C++ Design 
Como alguém com mais de duas décadas de experiência em C++, para 
aproveitar ao máximo o C++ moderno (tanto as melhores práticas quanto 
as armadilhas a serem evitadas), recomendo fortemente que você compre 
este livro, leia-o completamente e consulte-o com frequência! 
Certamente aprendi coisas novas passando por 
isso! —Nevin Liber 
Engenheiro de software sênior, DRW Trading Group 
Bjarne Stroustrup — o criador do C++ — disse: “C++ 11 parece uma nova 
linguagem”. 
Effective Modern C++ nos faz compartilhar esse mesmo sentimento, 
explicando claramente como os programadores comuns podem se 
beneficiar dos novos recursos e idiomas do C++ 11 e C++ 14. Outro 
 
 
ótimo livro de Scott Meyers. —Cassio Neri Analista Quantitativo de 
FX, Lloyds Banking Group 
Scott tem o dom de reduzir a complexidade técnica a um núcleo compreensível. 
Seus livros Effective C++ ajudaram a elevar o estilo de codificação de uma 
geração anterior de programadores C++; o novo livro parece posicionado para 
fazer o mesmo para aqueles que usam C++ moderno. —Roger Orr 
OR/2 Limited, membro do comitê de padrões ISO C++ 
Effective Modern C++ é uma ótima ferramenta para melhorar suas habilidades 
modernas em C++. Ele não apenas ensina como, quando e onde usar o C++ 
moderno e ser eficaz, mas também explica por quê . 
Sem dúvida, a escrita clara e perspicaz de Scott, distribuída em 42 itens bem 
elaborados, dá aos programadores uma compreensão muito melhor da 
linguagem. —Bart Vandewoestyne 
Engenheiro de Pesquisa e Desenvolvimento e entusiasta de C++ 
Eu adoro C++, tem sido meu veículo de trabalho há muitas décadas. 
E com a mais recente série de recursos, é ainda mais poderoso e 
expressivo do que eu teria imaginado anteriormente. Mas com toda 
essa escolha vem a questão 
“quando e como aplico esses recursos?” Como sempre foi o caso, 
Effective C++ de Scott são a resposta definitiva para essa pergunta. 
—Damien Watkins 
Líder da equipe de engenharia de software de computação, CSIRO 
Ótima leitura para fazer a transição para o C++ moderno: os 
novos recursos da linguagem C++ 11/14 são descritos junto 
com o C++ 98, os itens do assunto são fáceis de consultar e 
os conselhos são resumidos no final de cada seção. 
Divertido e útil para desenvolvedores C++ casuais e avançados. 
—Rachel Cheng 
Redes F5 
Se você estiver migrando do C++ 98/03 para o C++ 11/14, precisará das 
informações eminentemente práticas e claras que Scott fornece em Effective 
Modern C++. Se você já está escrevendo 
C++ 11, você provavelmente descobrirá problemas com os novos recursos por 
meio da discussão completa de Scott sobre os novos recursos importantes da 
 
 
linguagem. De qualquer forma, este livro vale seu tempo. —Rob Stewart, 
membro do Comitê Diretor do Boost ( boost.org ) 
 
C++ moderno 
eficaz 
Scott Meyers 
C++ moderno 
eficaz por Scott 
Meyers 
Direitos autorais © 2015 Scott Meyers. Todos os direitos reservados. 
Impresso no Canadá. 
Publicado por O'Reilly Media, Inc., 1005 Gravenstein Highway North, Sebastopol, CA 95472. 
Os livros da O'Reilly podem ser adquiridos para uso educacional, comercial ou promocional de 
vendas. Edições online também estão disponíveis para a maioria dos títulos ( 
http://safaribooksonline.com ) . Para obter mais informações, entre em contato com nosso 
departamento de vendas corporativas/institucionais: 800-998-9938 ou corporate@oreilly.com. 
Editor: Rachel Roumeliotis Revisor: Charles Roumeliotis Editor de 
Produção: Melanie Yarbrough Indexador: Scott Meyers 
Editor de texto: Jasmine Kwityn Designer de interiores: David Futato 
Designer da capa: Ellie Volkhausen 
Ilustradora: Rebecca Demarest 
Novembro de 2014: Primeira Edição 
http://safaribooksonline.com/
http://safaribooksonline.com/
 
 
Histórico de revisões da primeira 
edição 07/11/2014: primeiro 
lançamento 
Consulte http://oreilly.com/catalog/errata.csp?isbn=9781491903995 para obter detalhes da 
versão. 
O logotipo O'Reilly é uma marca registrada da O'Reilly Media, Inc. Effective Modern C++ , a 
imagem da capa de uma pomba de frutas coroada de rosa e a imagem comercial relacionada 
são marcas registradas da O'Reilly Media, Inc. 
Embora a editora e o autor tenham envidado esforços de boaa regra, e isso significa 
que você deve lembrar que se você declarar uma variável usando auto e 
inicializá-la com um inicializador entre chaves, o tipo deduzido será sempre 
std::initializer_list . É especialmente importante ter isso em mente se você 
adotar a filosofia da inicialização uniforme – de colocar valores de inicialização 
entre colchetes como algo natural. Um erro clássico 
Item 2 
na programação C++ 11 está declarando acidentalmente uma variável 
std::initializer_list quando você pretende declarar outra coisa. Essa armadilha 
é uma das razões pelas quais alguns desenvolvedores colocam colchetes em 
seus inicializadores apenas quando necessário. (Quando for necessário, é 
discutido no Item 7. ) 
Para o C++ 11, esta é a história completa, mas para o C++ 14, a história 
continua. O C++ 14 permite que auto indique que o tipo de retorno de uma 
função deve ser deduzido (consulte o Item 3 ), e os lambdas do C++ 14 podem 
usar auto nas declarações de parâmetros. No entanto, esses usos de auto 
empregam dedução de tipo de modelo , não dedução de tipo automático . 
Portanto, uma função com um tipo de retorno automático que retorna um 
inicializador entre chaves não será compilada: 
automáticaInitList () 
{ 
retornar {1, 2, 3} ; // erro: não é possível deduzir o tipo } // para { 
1, 2, 3 } 
O mesmo acontece quando auto é usado em uma especificação de tipo de 
parâmetro em um lambda C++ 14: 
std::vetor v; … 
auto resetV = [&v](const auto & newValue) { v = newValue; }; 
//C++14 … 
resetV( { 1, 2, 3 } ); //erro! não consigo deduzir o tipo 
// para { 1, 2, 3 } 
 
26 | 
Coisas para lembrar 
• automático geralmente é igual à dedução de tipo de modelo, mas a 
dedução de tipo automático assume que um inicializador entre chaves 
representa um std::initial izer_list e a dedução de tipo de modelo não. 
• auto em um tipo de retorno de função ou um parâmetro lambda implica 
dedução de tipo de modelo, não dedução de tipo automático . 
Item 3: Entenda o decltype . 
decltype é uma criatura estranha. Dado um nome ou expressão, decltype 
informa o nome ou o tipo da expressão. Normalmente, o que ele diz é 
exatamente o que você 
 
 Ponto 3 | 27 
prever. Ocasionalmente, porém, ele fornece resultados que deixam você 
coçando a cabeça e recorrendo a obras de referência ou sites de perguntas e 
respostas on-line para obter revelação. 
Começaremos com os casos típicos – aqueles que não trazem surpresas. Em 
contraste com o que acontece durante a dedução de tipo para templates e 
auto (veja os itens 1 e 2 ), decltype normalmente reproduz o tipo exato do 
nome ou expressão que você atribui a ele: 
const int i = 0; // decltype(i) é const int 
bool f(const Widget&w); // decltype(w) é const Widget& 
// decltype(f) é bool(const Widget&) 
estrutura Ponto { 
interno x, y; // decltype(Ponto::x) é int }; // decltype(Point::y) é 
int Widget w; // decltype(w) é Widget if (f(w)) … // 
decltype(f(w)) é bool 
template // versão simplificada de std::vector 
vetor de classe { 
público: 
… 
Operador T&[](índice std::size_t); 
… 
}; 
vetor v; // decltype(v) é vetor 
… 
if (v[0] == 0) … // decltype(v[0]) é int& Veja? Sem surpresas. 
No C++ 11, talvez o uso principal de decltype seja declarar modelos de função 
onde o tipo de retorno da função depende de seus tipos de parâmetro. Por 
exemplo, suponha que gostaríamos de escrever uma função que receba um 
contêiner que suporte indexação por meio de colchetes (ou seja, o uso de “ [] 
”) mais um índice e, em seguida, autentique o usuário antes de retornar o 
resultado da operação de indexação. O tipo de retorno da função deve ser 
igual ao tipo retornado pela operação de indexação. 
operador[] em um contêiner de objetos do tipo T normalmente retorna um T& 
. Este é o caso de std::deque , por exemplo, e quase sempre é o caso de 
std::vector . Para std::vector , entretanto, operator[] não retorna um 
 
28 | Artigo 3 
bool& . Em vez disso, ele retorna um objeto totalmente novo. Os porquês e 
comos dessa situação são explorados no Item 6 , mas o que é importante aqui 
é que o tipo retornado pelo operador[] de um contêiner depende do contêiner. 
decltype facilita expressar isso. Aqui está um primeiro corte no modelo que 
gostaríamos de escrever, mostrando o uso de decltype para calcular o tipo de 
retorno. O modelo precisa de um pouco de refinamento, mas vamos adiar isso 
por enquanto: 
template // funciona, mas 
auto authAndAccess(Container& c, Index i) // requer -> 
decltype(c[i]) // refinamento 
{ 
autenticaUsuário(); 
retornar c[i]; } 
O uso de auto antes do nome da função não tem nada a ver com dedução de 
tipo. Em vez disso, indica que a sintaxe do tipo de retorno final do C++ 11 está 
sendo usada, ou seja, que o tipo de retorno da função será declarado seguindo 
a lista de parâmetros (após o “ -> ”). Um tipo de retorno final tem a vantagem 
de que os parâmetros da função podem ser usados na especificação do tipo 
de retorno. Em authAndAccess , por exemplo, especificamos o tipo de retorno 
usando c e i . Se tivéssemos que o tipo de retorno precedesse o nome da 
função da maneira convencional, c e i não estariam disponíveis, porque ainda 
não teriam sido declarados. 
Com esta declaração, authAndAccess retorna qualquer tipo que o operador[] 
retorne quando aplicado ao contêiner passado, exatamente como desejamos. 
O C++ 11 permite que tipos de retorno para lambdas de instrução única sejam 
deduzidos, e o C++ 14 estende isso para todos os lambdas e todas as 
funções, incluindo aquelas com múltiplas instruções. No caso de 
authAndAccess , isso significa que em C++ 14 podemos omitir o tipo de 
retorno final, deixando apenas o auto inicial . Com essa forma de declaração, 
auto significa que a dedução do tipo ocorrerá. Em particular, significa que os 
compiladores deduzirão o tipo de retorno da função a partir da implementação 
da função: 
template // C++14; auto 
authAndAccess(Container& c, Index i) // não exatamente { // correto 
autenticaUsuário(); 
 retornar c[i] ; // tipo de retorno deduzido de c[i] } 
 
 Ponto 3 | 29 
O item 2 explica que para funções com especificação de tipo de retorno 
automático , os compiladores empregam dedução de tipo de modelo. Neste 
caso, isso é problemático. Como discutimos, o operador[] para a maioria dos 
contêineres de T retorna um T& , mas o Item 1 explica que durante a dedução 
do tipo de modelo, a referência de uma expressão de inicialização é ignorada. 
Considere o que isso significa para este código de cliente: 
std::dequed; 
… 
authAndAccess(d, 5) = 10; //autentica o usuário, retorna d[5], 
// então atribua 10 a ele; // isso não será compilado! 
Aqui, d[5] retorna um int& , mas a dedução do tipo de retorno automático para 
authAndAccess removerá a referência, produzindo assim um tipo de retorno 
de int . Esse int , sendo o valor de retorno de uma função, é um rvalue, e o 
código acima tenta atribuir 10 a um rvalue int . Isso é proibido em C++, então 
o código não será compilado. 
Para que authAndAccess funcione como gostaríamos, precisamos usar a 
dedução do tipo decltype para seu tipo de retorno, ou seja, especificar que 
authAndAccess deve retornar exatamente o mesmo tipo que a expressão c[i] 
retorna. Os guardiões do C++, antecipando a necessidade de usar regras de 
dedução de tipo decltype em alguns casos em que os tipos são inferidos, 
tornam isso possível no C++ 14 por meio do especificador decltype(auto) . O 
que inicialmente pode parecer contraditório ( decltype e auto ?) na verdade 
faz todo o sentido: auto especifica que o tipo deve ser deduzido e decltype diz 
que as regras decltype devem ser usadas durante a dedução. Podemos, 
portanto, escreverauthAndAccess assim: 
template // C++14; funciona, 
decltype(auto) // mas ainda 
authAndAccess(Container& c, Index i) // requer { // refinamento 
autenticaUsuário(); 
retornar c[i]; } 
Agora authAndAccess realmente retornará tudo o que c[i] retornar. Em 
particular, para o caso comum em que c[i] retorna um T& , authAndAccess 
também retornará um T& , e no caso incomum em que c[i] retorna um objeto, 
authAndAccess retornará um objeto também. 
O uso de decltype(auto) não está limitado aos tipos de retorno de função. 
Também pode ser conveniente para declarar variáveis quando você deseja 
 
30 | Artigo 3 
aplicar as regras de dedução do tipo decltype à expressão de inicialização: 
Widget w; widget const& cw = w; auto meuWidget1 = cw; // dedução de tipo 
automático: 
 // O tipo do myWidget1 é Widget 
decltype(auto) meuWidget2 = cw; // decltype tipo dedução: 
 // o tipo do myWidget2 é 
 // const Widget& 
Mas duas coisas estão incomodando você, eu sei. Um deles é o refinamento 
do authAndAccess que mencionei, mas ainda não descrevi. Vamos abordar 
isso agora. 
Veja novamente a declaração da versão C++14 de authAndAccess : 
template decltype(auto) 
authAndAccess(Container& c, Index i); 
O contêiner é passado por lvalue-reference-to-non- const , porque retornar 
uma referência a um elemento do contêiner permite que os clientes 
modifiquem esse contêiner. Mas isso significa que não é possível passar 
contêineres de valor para esta função. Rvalues não podem ser vinculados a 
referências lvalue (a menos que sejam lvalue-references-to- const , o que não 
é o caso 
aqui). 
É certo que passar um contêiner rvalue para authAndAccess é um caso 
extremo. Um contêiner rvalue, sendo um objeto temporário, normalmente 
seria destruído no final da instrução que contém a chamada para 
authAndAccess , e isso significa que uma referência a um elemento nesse 
contêiner (que normalmente é o que authAndAccess retornaria) ficaria 
pendurada no final da declaração que o criou. Ainda assim, poderia fazer 
sentido passar um objeto temporário para authAndAccess . Um cliente pode 
simplesmente querer fazer uma cópia de um elemento no contêiner 
temporário, por exemplo: 
std::deque makeStringDeque(); //função de fábrica 
// faz cópia do 5º elemento do deque retornado 
// de makeStringDeque 
auto s = authAndAccess(makeStringDeque(), 5); 
 
 Ponto 3 | 31 
Apoiar esse uso significa que precisamos revisar a declaração de 
authAndAccess para aceitar lvalues e rvalues. A sobrecarga funcionaria (uma 
sobrecarga declararia um parâmetro de referência lvalue, a outra um 
parâmetro de referência rvalue), mas teríamos duas funções para manter. 
Uma maneira de evitar isso é fazer com que authAndAccess empregue um 
parâmetro de referência que possa ser vinculado a lvalues e rvalues, e o Item 
24 explica que é exatamente isso que as referências universais fazem. 
authAndAccess pode, portanto, ser declarado assim: 
template // c agora é um 
decltype(auto) authAndAccess(Container && c, // universal Index i); // 
referência 
Neste modelo, não sabemos em que tipo de contêiner estamos operando, e 
isso significa que ignoramos igualmente o tipo de objetos de índice que ele 
usa. Empregar passagem por valor para objetos de um tipo desconhecido 
geralmente corre o risco de prejudicar o desempenho devido à cópia 
desnecessária, os problemas comportamentais do fatiamento de objetos 
(consulte o Item 41 ) e a dor do escárnio de nossos colegas de trabalho, mas 
no caso de índices de contêiner, seguindo o exemplo da Biblioteca Padrão 
para valores de índice (por exemplo, em operator[] para std::string , std::vector 
e std::deque ) parece razoável, então vamos nos ater à passagem por valor 
para eles. 
No entanto, precisamos atualizar a implementação do modelo para deixá-lo 
de acordo com a advertência do Item 25 para aplicar std::forward a referências 
universais: 
template // final decltype(auto) // 
C++14 authAndAccess(Container&& c, Index i) // versão 
{ 
autenticaUsuário(); 
return std::forward( c ) [i]; } 
Isso deve fazer tudo o que queremos, mas requer um compilador C++14. Se 
não tiver um, você precisará usar a versão C++11 do modelo. É o mesmo que 
sua contraparte C++ 14, exceto que você mesmo deve especificar o tipo de 
retorno: 
template // auto final 
// C++11 authAndAccess(Container&& c, Index i) // versão 
-> decltype(std::forward(c)[i]) 
{ 
autenticaUsuário(); 
 
32 | Artigo 3 
return std::forward(c)[i]; } 
A outra questão que provavelmente o incomodará é minha observação no 
início deste item de que decltype quase sempre produz o tipo que você espera, 
e que raramente surpreende. Verdade seja dita, é improvável que você 
encontre essas exceções à regra, a menos que seja um implementador de 
bibliotecas pesado. 
Para entender completamente o comportamento de decltype , você terá que 
se familiarizar com alguns casos especiais. A maioria deles é muito obscura 
para merecer discussão em um livro como este, mas olhar para um deles 
fornece uma visão sobre o decltype, bem como seu uso. 
A aplicação decltype a um nome produz o tipo declarado para esse nome. Os 
nomes são expressões lvalue, mas isso não afeta o comportamento de 
decltype . Entretanto, para expressões lvalue mais complicadas que nomes, 
decltype garante que o tipo relatado seja sempre uma referência lvalue. Ou 
seja, se uma expressão lvalue diferente de um nome tiver o tipo T , decltype 
reportará esse tipo como T& . Isso raramente tem algum impacto, porque o 
tipo da maioria das expressões lvalue inclui inerentemente um qualificador de 
referência lvalue. Funções que retornam lvalues, por exemplo, sempre 
retornam referências de lvalue. 
No entanto, há uma implicação desse comportamento da qual vale a pena 
estar ciente. Em 
interno x = 0; 
x é o nome de uma variável, então decltype(x) é int . Mas colocar o nome x 
entre parênteses – “ (x) ” – produz uma expressão mais complicada do que 
um nome. Sendo um nome, x é um lvalue, e C++ define a expressão (x) como 
um lvalue também. decltype( (x) ) é portanto int& . Colocar parênteses em 
torno de um nome pode alterar o tipo que o decltype reporta para ele! 
No C++ 11, isso é pouco mais que uma curiosidade, mas em conjunto com o 
suporte do C++ 14 para decltype(auto) , significa que uma mudança 
aparentemente trivial na maneira como você escreve uma instrução return 
pode afetar o tipo deduzido para uma função: 
decltype(automático) f1() 
{ 
interno x = 0; 
… 
 retornar x ; // decltype( x ) é int , então f1 retorna int } 
 
 Ponto 3 | 33 
decltype(automático) f2() 
{ 
interno x = 0; 
… 
 retornar (x) ; // decltype( (x) ) é int& , então f2 retorna int& } 
Observe que f2 não apenas possui um tipo de retorno diferente de f1 , mas 
também retorna uma referência a uma variável local! Esse é o tipo de código 
que coloca você no trem expresso para um comportamento indefinido – um 
trem no qual você certamente não quer estar. 
A lição principal é prestar muita atenção ao usar decltype(auto) . Detalhes 
aparentemente insignificantes na expressão cujo tipo está sendo deduzido 
podem afetar o tipo que decltype(auto) relata. Para garantir que o tipo que 
está sendo deduzido é o tipo esperado, use as técnicas descritas no Item 4 . 
Ao mesmo tempo, não perca de vista o panorama geral. Claro, decltype 
(sozinho e em conjunto com auto ) pode ocasionalmente gerar surpresas na 
dedução de tipo, mas essa não é a situação normal. Normalmente, decltype 
produz o tipo que você espera. 
Isto é especialmente verdadeiroquando decltype é aplicado a nomes, porque 
nesse caso, decltype faz exatamente o que parece: relata o tipo declarado 
daquele nome. 
 
Coisas para lembrar 
• decltype quase sempre produz o tipo de uma variável ou expressão sem 
quaisquer modificações. 
• Para expressões lvalue do tipo T diferentes de nomes, decltype sempre 
reporta um 
tipo de T& . 
• C++14 suporta decltype(auto) , que, como auto , deduz um tipo de seu 
inicializador, mas executa a dedução de tipo usando as regras decltype 
. 
Item 4: Saiba como visualizar os tipos 
deduzidos. 
 
34 | Artigo 3 
A escolha das ferramentas para visualização dos resultados da dedução de 
tipo depende da fase do processo de desenvolvimento de software onde se 
deseja a informação. Exploraremos três possibilidades: obter informações de 
dedução de tipo à medida que você edita seu código, obtê-las durante a 
compilação e obtê-las em tempo de execução. Editores IDE 
Os editores de código em IDEs geralmente mostram os tipos de entidades do 
programa (por exemplo, variáveis, parâmetros, funções, etc.) quando você faz 
algo como passar o cursor sobre a entidade. Por exemplo, dado este código, 
const int a resposta = 42; 
auto x = a resposta; auto 
y = &aResposta; 
um editor IDE provavelmente mostraria que o tipo deduzido de x era int e o de 
y era const int* . 
Para que isso funcione, seu código deve estar em um estado mais ou menos 
compilável, pois o que torna possível ao IDE oferecer esse tipo de informação 
é um compilador C++ (ou pelo menos o front end de um) rodando dentro do 
IDE. Se esse compilador não conseguir entender seu código o suficiente para 
analisá-lo e realizar a dedução de tipo, ele não poderá mostrar quais tipos ele 
deduziu. 
Para tipos simples como int , as informações dos IDEs geralmente são 
adequadas. Porém, como veremos em breve, quando tipos mais complicados 
estão envolvidos, as informações exibidas pelos IDEs podem não ser 
particularmente úteis. 
 
 Ponto 4 | 35 
Diagnóstico do compilador 
Uma maneira eficaz de fazer com que um compilador mostre um tipo que 
deduziu é usar esse tipo de uma forma que leve a problemas de compilação. 
A mensagem de erro que relata o problema quase certamente menciona o tipo 
que o está causando. 
Suponha, por exemplo, que gostaríamos de ver os tipos que foram deduzidos 
para x e y no exemplo anterior. Primeiro declaramos um modelo de classe que 
não definimos . Algo assim funciona bem: 
template // declaração apenas para TD; classe DT; 
// TD == "Exibidor de tipo" 
As tentativas de instanciar este modelo gerarão uma mensagem de erro, 
porque não há definição de modelo para instanciar. Para ver os tipos de x e y 
, basta tentar instanciar o TD com seus tipos: 
TD xType; // elicita erros contendo 
TD yType; // tipos de x e y 
Eu uso nomes de variáveis no formato variableName Type , porque eles 
tendem a gerar mensagens de erro que me ajudam a encontrar as 
informações que procuro. Para o código acima, um dos meus compiladores 
emite a leitura de diagnóstico, em parte, da seguinte forma (destaquei as 
informações de tipo que procuramos): 
erro: agregado 'TD xType ' tem tipo incompleto e 
não pode ser definido 
erro: agregado 'TD yType' tem tipo incompleto e não 
pode ser definido 
Um compilador diferente fornece as mesmas informações, mas de uma forma 
diferente: 
erro: 'xType' usa classe indefinida 'TD ' erro: 'yType' 
usa classe indefinida 'TD' 
Deixando de lado as diferenças de formatação, todos os compiladores que 
testei produzem mensagens de erro com informações úteis sobre o tipo 
quando essa técnica é empregada. 
Saída de tempo de execução 
A abordagem printf para exibir informações de tipo (não que eu recomende 
que você use printf ) não pode ser empregada até o tempo de execução, mas 
oferece controle total sobre a formatação da saída. O desafio é criar uma 
 
36 | 
representação textual do tipo de seu interesse que seja adequada para 
exibição. “Não se preocupe”, você está pensando, “é typeid e 
std::type_info::name para o resgate”. Em nossa busca contínua para ver os 
tipos deduzidos para x e y , você pode imaginar que podemos escrever isto: 
std::cout // função de modelo para void f(const T& 
param); // ser chamado std::vector createVec(); //função de 
fábrica const auto vw = createVec(); //inicia vw com retorno de fábrica 
se (!vw.empty()) { 
 f(&vw[0]); //chama f 
… 
} 
Este código, que envolve um tipo definido pelo usuário ( Widget ), um contêiner 
STL ( std::vec tor ) e uma variável automática ( vw ), é mais representativo das 
situações em que você pode querer alguma visibilidade dos tipos que seus 
compiladores estão deduzindo. Por exemplo, seria bom saber quais tipos são 
inferidos para o parâmetro de tipo de modelo T e o parâmetro de função param 
em f . 
Perder o typeid no problema é simples. Basta adicionar algum código a f para 
exibir os tipos que você gostaria de ver: 
 
 Ponto 4 | 37 
modelo 
void f(const T& param) 
{usando std::cout; 
Item 4 
coutignorada. É por isso que o tipo de param - que é const Ferramenta * const & 
—é relatado como const Ferramenta* . Primeiro, a referência do tipo é 
removida e, em seguida, a constância do ponteiro resultante é eliminada. 
 
38 | 
Igualmente triste é que as informações de tipo exibidas pelos editores do IDE 
também não são confiáveis — ou pelo menos não são úteis de maneira 
confiável. Para este mesmo exemplo, um editor IDE que conheço relata o tipo 
de T como (não estou inventando isso): 
const 
std::_Simple_types >::_Alloc>::value_type>::value_type * O mesmo 
editor IDE mostra o tipo de param como: 
const std::_Simple_types::value_type *const & 
Isso é menos intimidante do que o tipo para T , mas o “ ... ” no meio é confuso 
até você perceber que é a maneira do editor IDE dizer “Estou omitindo todas 
as coisas que fazem parte do tipo de T ”. Com alguma sorte, seu ambiente de 
desenvolvimento fará um trabalho melhor em códigos como este. 
Se você está mais inclinado a confiar em bibliotecas do que na sorte, ficará 
satisfeito em saber que onde std::type_info::name e IDEs podem falhar, a 
biblioteca Boost TypeIndex (geralmente escrita como Boost.TypeIndex ) foi 
projetada para ter sucesso . A biblioteca não faz parte 
C++ padrão, mas também não são IDEs ou modelos como TD . Além disso, o 
fato de as bibliotecas Boost (disponíveis em boost.com ) serem 
multiplataforma, de código aberto e disponíveis sob uma licença projetada 
para ser palatável até mesmo para a equipe jurídica corporativa mais 
paranóica significa que o código que usa as bibliotecas Boost é quase tão 
portátil quanto código que depende da Biblioteca Padrão. 
Veja como nossa função f pode produzir informações de tipo precisas usando 
Boost.TypeIndex: 
#include 
modelo 
void f(const T& param) 
{ 
usando std::cout; 
 usando boost::typeindex::type_id_with_cvr; 
 //mostra T cout ().pretty_name() 
().pretty_name() 
 createVec(); //função de fábrica const auto vw = 
createVec(); //inicia vw com retorno de fábrica 
if (!vw.empty()) { 
 f(&vw[0]); //chama f 
… 
} 
Nos compiladores GNU e Clang, Boost.TypeIndex produz esta saída (precisa): 
T = Widget const* param = 
Widget const* const& 
Os resultados no compilador da Microsoft são essencialmente os mesmos: 
T = classe Widget const * param = 
classe Widget const * const & 
Essa quase uniformidade é boa, mas é importante lembrar que editores IDE, 
mensagens de erro do compilador e bibliotecas como Boost.TypeIndex são 
apenas ferramentas que você pode usar para ajudá-lo a descobrir quais tipos 
seus compiladores estão deduzindo. Tudo pode ser útil, mas no final das 
contas, não há substituto para a compreensão das informações sobre o tipo 
de dedução nos Itens 1 – 3 . 
 
40 | 
Coisas para lembrar 
• Os tipos deduzidos geralmente podem ser vistos usando editores IDE, 
mensagens de erro do compilador e a biblioteca Boost TypeIndex. 
• Os resultados de algumas ferramentas podem não ser úteis nem 
precisos, portanto, uma compreensão das regras de dedução de tipo do 
C++ permanece essencial. 
 
 
 
 
42 
CAPÍTULO 2 
 
auto 
Em conceito, auto é tão simples quanto possível, mas é mais sutil do que 
parece. Usá-lo economiza digitação, claro, mas também evita problemas de 
correção e desempenho que podem atrapalhar as declarações manuais de 
tipo. Além disso, alguns dos resultados de dedução do tipo auto , embora 
estejam em conformidade com o algoritmo prescrito, são, da perspectiva de 
um programador, simplesmente errados. Quando for esse o caso, é 
importante saber como guiar automaticamente a resposta certa, porque 
recorrer a declarações manuais de tipo é uma alternativa que geralmente é 
melhor evitar. Este breve capítulo cobre todos os prós e contras do setor 
automotivo . 
Item 5: Prefira declarações de tipo 
automáticas a explícitas. 
Ah, a simples alegria de 
interno x; 
Espere. Droga. Esqueci de inicializar x , então seu valor é indeterminado. 
Talvez. Na verdade, pode ser inicializado em zero. Depende do contexto. 
Suspirar. 
Deixa para lá. Vamos passar para a simples alegria de declarar uma variável 
local para ser inicializada desreferenciando um iterador: 
template // algoritmo para dwim ("faça o que eu quero 
dizer") void dwim(It b, It e) // para todos os elementos no intervalo de 
{ // b para e 
enquanto (b! = e) { 
 nome do tipo std::iterator_traits::value_type 
 
 | 43 
valorcurr = *b; 
… 
} 
} 
Eca. " Digite o nome std::iterator_traits::value_type ” para expressar o tipo 
de valor apontado por um iterador? Realmente? Devo ter bloqueado a 
memória de como isso é divertido. Droga. Espere, eu já não disse isso? 
Ok, alegria simples (leve três): a delícia de declarar uma variável local cujo 
tipo é o de um encerramento. Oh, certo. O tipo de encerramento é conhecido 
apenas pelo compilador e, portanto, não pode ser escrito. Suspirar. Droga. 
Droga droga droga! Programar em C++ não é a experiência alegre que deveria 
ser! 
Bem, não costumava ser. Mas a partir do C++ 11, todos esses problemas 
desaparecem, cortesia de auto . variáveis automáticas têm seu tipo deduzido 
de seu inicializador, portanto devem ser inicializadas. Isso significa que você 
pode dar adeus a uma série de problemas de variáveis não inicializadas 
enquanto acelera na moderna superestrada C++: int x1; // auto x2 
potencialmente não inicializado ; //erro! inicializador necessário 
automático x3 = 0 ; // tudo bem, o valor de x está bem definido A referida 
rodovia não possui os buracos associados à declaração de uma variável local 
cujo valor é o de um iterador desreferenciado: 
template // como antes 
vazio dwim (It b, It e) 
{ 
while (b != e) { auto 
currValue = *b; 
… 
} 
} 
E como auto usa dedução de tipos (veja o Item 2 ), ele pode representar tipos 
conhecidos apenas pelos compiladores: 
auto derefUPLess = // comparação func. 
[](const std::unique_ptr& p1, // para Widgets const 
std::unique_ptr& p2) // apontado por { return *p1podem se referir a qualquer 
objeto que possa ser chamado, ou seja, a qualquer coisa que possa ser 
invocada como uma função. Assim como você deve especificar o tipo de 
função para a qual apontar ao criar um ponteiro de função (ou seja, a 
assinatura das funções para as quais deseja apontar), você deve especificar 
o tipo de função à qual se referir ao criar um std:: objeto de função . Você faz 
isso através do parâmetro de modelo de std::function . Por exemplo, para 
declarar um objeto std::function chamado func que poderia se referir a 
qualquer objeto que pode ser chamado agindo como se tivesse esta 
assinatura, 
bool(const std::unique_ptr&, // Assinatura C++11 para const 
std::unique_ptr&) // std::unique_ptr // 
função de comparação você escreveria isto: 
std::function&, 
const std::unique_ptr&) > func; 
Como as expressões lambda geram objetos que podem ser chamados, os 
fechamentos podem ser armazenados em objetos std::function . Isso significa 
que poderíamos declarar a versão C++ 11 de derefUP Less sem usar auto da 
seguinte forma: 
std::function&, 
const std::unique_ptr&)> derefUPLess = [](const 
std::unique_ptr& p1, const 
std::unique_ptr& p2) { return *p1 v; 
… 
não assinado = v.size(); 
O tipo de retorno oficial de v.size() é std::vector::size_type , mas poucos 
desenvolvedores estão cientes disso. std::vector::size_type é 
especificado como um tipo integral não assinado, portanto, muitos 
programadores acham que unsigned é bom o suficiente e escrevem códigos 
como o acima. Isto pode ter algumas consequências interessantes. Sobre 
Windows de 32 bits, por exemplo, unsigned e s td::vector::size_type são 
do mesmo tamanho, mas no Windows de 64 bits, unsigned tem 32 bits, 
 
46 | Artigo 5 
enquanto std::vec tor:: size_type é de 64 bits. Isso significa que o código 
que funciona no Windows de 32 bits pode se comportar incorretamente no 
Windows de 64 bits e, ao portar seu aplicativo de 32 para 64 bits, quem quer 
perder tempo com questões como essa? Usar auto garante que você não 
precise fazer isso: auto sz = v.size(); // o tipo de sz é std::vector::size_type 
Ainda não tem certeza sobre a sabedoria de usar auto ? Então considere este 
código: 
std::unordered_map m; … 
for (const std::pair& p : m) 
{ 
… // faça algo com p 
} 
Isso parece perfeitamente razoável, mas há um problema. Você vê? 
Reconhecer o que está errado requer lembrar que a parte principal de um 
std::unor dered_map é const , portanto, o tipo de std::pair na tabela hash (que 
é o que é um std::unordered_map ) não é std::pair , é std::pair 
 . Mas esse não é o tipo declarado para a variável p no 
loop acima. Como resultado, os compiladores se esforçarão para encontrar 
uma maneira de converter std::pair objetos (ou seja, o 
que está na tabela hash) para std::pair objetos (o tipo 
declarado para p ). Eles terão sucesso criando um objeto temporário do tipo 
ao qual p deseja vincular, copiando cada objeto em m e vinculando a 
referência p a esse objeto temporário. Ao final de cada iteração do loop, o 
objeto temporário será destruído. Se você escreveu esse loop, provavelmente 
ficaria surpreso com esse comportamento, porque quase certamente 
pretenderia simplesmente vincular a referência p a cada elemento em m . 
Essas incompatibilidades de tipo não intencionais podem ser eliminadas 
automaticamente : 
para (const auto & p: m) 
{ 
… // como antes 
} 
Isso não é apenas mais eficiente, mas também mais fácil de digitar. Além 
disso, esse código tem a característica muito atraente de que, se você usar o 
endereço de p , certamente obterá um ponteiro para um elemento dentro de 
m . No código que não usa auto , você obteria um ponteiro para um objeto 
temporário – um objeto que seria destruído no final da iteração do loop. 
 
 | 47 
Os dois últimos exemplos - escrever unsigned quando você deveria ter escrito 
std::vec tor::size_type e escrever std::pair quando você 
deveria ter escrito std::pair —demonstra como a 
especificação explícita de tipos pode levar a conversões implícitas que você 
não deseja nem espera. Se você usar auto como o tipo da variável de destino, 
não precisará se preocupar com incompatibilidades entre o tipo de variável 
que está declarando e o tipo de expressão usada para inicializá-la. 
Existem, portanto, vários motivos para preferir auto a declarações de tipo 
explícitas. No entanto, o automóvel não é perfeito. O tipo de cada variável 
automática é deduzido de sua expressão de inicialização, e algumas 
expressões de inicialização possuem tipos que não são antecipados nem 
desejados. As condições sob as quais tais casos surgem e o que você pode 
fazer a respeito são discutidas nos Itens 2 e 6 , portanto não irei abordá-las 
aqui. Em vez disso, voltarei minha atenção para uma preocupação diferente 
que você pode ter sobre o uso de auto no lugar das declarações de tipo 
tradicionais: a legibilidade do código-fonte resultante. 
Artigo 5 
Primeiro, respire fundo e relaxe. auto é uma opção, não um mandato. Se, no 
seu julgamento profissional, seu código for mais claro ou mais sustentável ou 
de alguma outra forma melhor usando declarações de tipo explícitas, você 
estará livre para continuar a usá-los. Mas tenha em mente que C++ não inova 
ao adotar o que é geralmente conhecido no mundo das linguagens de 
programação como inferência de tipos . Outras linguagens procedurais de tipo 
estaticamente(por exemplo, C#, D, Scala, Visual Basic) têm um recurso mais 
ou menos equivalente, para não falar de uma variedade de linguagens 
funcionais de tipo estaticamente (por exemplo, ML, Haskell, OCaml, F#, etc.) 
. Em parte, isso se deve ao sucesso de linguagens de tipo dinâmico, como 
Perl, Python e Ruby, onde as variáveis raramente são digitadas 
explicitamente. A comunidade de desenvolvimento de software tem ampla 
experiência com inferência de tipos e demonstrou que não há nada de 
contraditório nessa tecnologia e na criação e manutenção de grandes bases 
de código de força industrial. 
Alguns desenvolvedores ficam incomodados com o fato de que o uso de auto 
elimina a capacidade de determinar o tipo de um objeto com uma rápida 
olhada no código-fonte. No entanto, a capacidade dos IDEs de mostrar tipos 
de objetos muitas vezes atenua esse problema (mesmo levando em conta os 
problemas de exibição de tipos do IDE mencionados no Item 4 ) e, em muitos 
 
48 | Artigo 5 
casos, uma visão um tanto abstrata do tipo de objeto é tão útil quanto a tipo 
exato. Muitas vezes é suficiente, por exemplo, saber que um objeto é um 
contêiner, um contador ou um ponteiro inteligente, sem saber exatamente que 
tipo de contêiner, contador ou ponteiro inteligente é. Assumindo nomes de 
variáveis bem escolhidos, essas informações de tipo abstrato quase sempre 
devem estar disponíveis. 
O fato é que escrever tipos explicitamente muitas vezes faz pouco mais do 
que introduzir oportunidades para erros sutis, seja na correção, na eficiência 
ou em ambos. Além disso, os tipos automáticos mudam automaticamente se 
o tipo de sua expressão de inicialização mudar, e isso significa que algumas 
refatorações são facilitadas pelo uso de auto . Por exemplo, se uma função 
for declarada para retornar um int , mas mais tarde você decidir que long seria 
melhor, o código de chamada se atualizará automaticamente na próxima vez 
que você compilar se os resultados da chamada da função forem 
armazenados em variáveis automáticas . Se os resultados forem 
armazenados em variáveis declaradas explicitamente como int , você 
precisará encontrar todos os sites de chamada para poder revisá-los. 
Coisas para lembrar 
• automáticas devem ser inicializadas, geralmente são imunes a 
incompatibilidades de tipos que podem levar a problemas de 
portabilidade ou eficiência, podem facilitar o processo de refatoração e 
normalmente exigem menos digitação do que variáveis com tipos 
explicitamente especificados. 
• automaticamente estão sujeitas às armadilhas descritas nos itens 2 e 6 
. 
 
 Ponto 6 | 49 
Item 6: Use o idioma do inicializador 
digitado explicitamente ao 
deduzir automaticamente tipos 
indesejados. 
O item 5 explica que usar auto para declarar variáveis oferece uma série de 
vantagens técnicas em relação à especificação explícita de tipos, mas às 
vezes a dedução de tipo de auto ziguezagueia quando você deseja que ela 
faça zag. Por exemplo, suponha que eu tenha uma função que pega um 
Widget e retorna um std::vector , onde cada bool indica se o Widget 
oferece um recurso específico: 
std::vector recursos(const Widget& w); 
Suponha ainda que o bit 5 indique se o Widget tem alta prioridade. Podemos, 
portanto, escrever código como este: 
Widget com; 
… 
bool altaPrioridade = recursos (w)[5]; // w é de alta prioridade? … 
processWidget(w, altaPrioridade); //processa w de acordo 
//com sua prioridade 
Não há nada de errado com este código. Vai funcionar bem. Mas se fizermos 
a mudança aparentemente inócua de substituir o tipo explícito de highPriority 
por auto , 
auto altaPrioridade = recursos(w)[5]; // w é de alta prioridade? 
a situação muda. Todo o código continuará a ser compilado, mas seu 
comportamento não será mais previsível: processWidget(w, highPriority); // 
comportamento indefinido! 
Como indica o comentário, a chamada para processWidget agora tem 
comportamento indefinido. Mas por que? A resposta provavelmente será 
surpreendente. No código que usa auto , o tipo de highPriority não é mais bool 
. Embora std::vector contenha conceitualmente bool s, operator[] para 
std::vector não retorna uma referência a um elemento do contêiner (que 
é o que std::vector::operator[] retorna para todos os tipos, exceto bool ). Em 
 
50 | Artigo 6 
vez disso, ele retorna um objeto do tipo std::vector::reference (uma 
classe aninhada dentro de std::vector ). 
std::vector::reference existe porque std::vector é especificado 
para representar seus bool s em formato compactado, um bit por bool . Isso 
cria um problema para std::vector operador [] , porque operador[] para 
std::vector deve retornar um T& , mas C++ proíbe referências a bits. Não 
sendo capaz de retornar um bool& , operator[] para std::vector retorna 
um objeto que age como um bool& . Para que este ato seja bem-sucedido, os 
objetos std::vector::reference devem ser utilizáveis em essencialmente 
todos os contextos onde bool& s podem ser. Entre os recursos em std::vec 
tor::reference que fazem isso funcionar está uma conversão implícita 
para bool . (Não para bool& , para bool . Explicar o conjunto completo de 
técnicas usadas por std::vec tor::reference para emular o 
comportamento de um bool& nos levaria muito longe, então vou simplesmente 
observar que isso a conversão implícita é apenas uma pedra num mosaico 
maior.) 
Com essas informações em mente, observe novamente esta parte do código 
original: 
bool altaPrioridade = recursos (w)[5]; //declara highPriority's 
//digita explicitamente 
Aqui, features retorna um objeto std::vector , no qual operator[] é 
invocado. operador[] retorna um objeto std::vector::reference , que é 
então convertido implicitamente no bool necessário para inicializar highPriority 
. alta Prioridade , portanto, termina com o valor do bit 5 no std::vector 
retornado por features , exatamente como deveria. 
Compare isso com o que acontece na declaração automática para highPriority 
: 
auto altaPrioridade = recursos(w)[5]; // deduz alta prioridade 
// tipo 
Novamente, features retorna um objeto std::vector e, novamente, 
operator[] é invocado nele. operator[] continua retornando um objeto 
std::vector::reference , mas agora há uma mudança, porque auto deduz 
isso como o tipo de highPrior ity . highPriority não possui o valor do bit 5 do 
std::vector retornado pelos recursos . 
O valor que ele possui depende de como std::vector::reference é 
implementado. Uma implementação é que tais objetos contenham um ponteiro 
 
 Ponto 6 | 51 
para a palavra de máquina que contém o bit referenciado, mais o 
deslocamento nessa palavra para esse bit. Considere o que isso significa para 
a inicialização de highPriority , assumindo que tal std::vector::reference 
implementação esteja em vigor. 
A chamada para recursos retorna um objeto std::vector temporário . 
Este objeto não tem nome, mas para fins desta discussão, vou chamá-lo de 
temp . operador[] é invocado em temp , e o std::vector::reference que 
ele retorna contém um ponteiro para uma palavra na estrutura de dados que 
contém os bits que são gerenciados por temp , mais o deslocamento nessa 
palavra correspondente ao bit 5. highPriority é uma cópia deste objeto 
std::vector::reference , então highPriority , também contém um ponteiro 
para uma palavra em temp , mais o deslocamento correspondente ao bit 5. No 
final da instrução, temp é destruído, porque é um objeto temporário. Portanto, 
highPriority contém um ponteiro pendente e essa é a causa do comportamento 
indefinido na chamada para proc essWidget : 
processWidget(w, altaPrioridade); // comportamento indefinido! 
// altaPrioridade contém//ponteiro pendurado! 
std::vector::reference é um exemplo de classe proxy : uma classe que 
existe com o propósito de emular e aumentar o comportamento de algum outro 
tipo. As classes proxy são empregadas para diversos propósitos. 
std::vector::reference existe para oferecer a ilusão de que operator[] 
para std::vector retorna uma referência a um bit, por exemplo, e os tipos 
de ponteiro inteligente da Biblioteca Padrão (consulte o Capítulo 4 ) são 
classes proxy que enxertam o gerenciamento de recursos em ponteiros 
brutos. A utilidade das classes proxy está bem estabelecida. Na verdade, o 
padrão de design “Proxy” é um dos membros mais antigos do Pantheon de 
padrões de design de software. 
Algumas classes de proxy são projetadas para serem aparentes aos clientes. 
Esse é o caso de std::shared_ptr e std::unique_ptr , por exemplo. Outras 
classes de proxy são projetadas para agir de forma mais ou menos invisível. 
std::vector::reference é um exemplo de tais proxies “invisíveis”, assim 
como seu compatriota std::bitset , std::bitset::ref erence . 
Também nesse campo estão algumas classes em bibliotecas C++ que 
empregam uma técnica conhecida como modelos de expressão . Essas 
bibliotecas foram originalmente desenvolvidas para melhorar a eficiência do 
 
52 | Artigo 6 
código numérico. Dada uma classe Matrix e objetos Matrix m1 , m2 , m3 e m4 
, por exemplo, a expressão 
Soma da matriz = m1 + m2 + m3 + m4; pode ser calculado com muito mais 
eficiência se o operador + para objetos Matrix retornar um proxy para o 
resultado em vez do próprio resultado. Ou seja, o operador+ para dois objetos 
Matrix retornaria um objeto de uma classe proxy como Sum 
em vez de um objeto Matrix . Como foi o caso de std::vector::reference 
e bool , haveria uma conversão implícita da classe proxy para Matrix , o que 
permitiria a inicialização de sum do objeto proxy produzido pela expressão à 
direita lado de “ = ”. (O tipo desse objeto tradicionalmente codificaria toda a 
expressão de inicialização, ou seja, seria algo como Sum, Matriz>, Matriz> . Esse é definitivamente um tipo do qual os clientes 
devem ser protegidos.) Como regra geral, classes de proxy “invisíveis” não 
funcionam bem com auto . Os objetos dessas classes geralmente não são 
projetados para durar mais do que uma única instrução; portanto, a criação de 
variáveis desses tipos tende a violar as suposições fundamentais do projeto 
da biblioteca. Esse é o caso de std::vector::reference , e vimos que 
violar essa suposição pode levar a um comportamento indefinido. 
Portanto, você deseja evitar código neste formato: auto someVar = 
expressão do tipo de classe de proxy "invisível" ; 
Mas como você pode reconhecer quando objetos proxy estão em uso? É 
improvável que o software que os emprega anuncie sua existência. Eles 
deveriam ser invisíveis , pelo menos conceitualmente! E depois de encontrá-
los, você realmente precisa abandonar o automóvel e as muitas vantagens 
que o item 5 demonstra para ele? 
Vejamos primeiro a questão de como você os encontra. Embora as classes 
de proxy “invisíveis” sejam projetadas para passar despercebidas pelo radar 
do programador no uso diário, as bibliotecas que as utilizam geralmente 
documentam que o fazem. Quanto mais você se familiarizar com as decisões 
básicas de design das bibliotecas que usa, menor será a probabilidade de ser 
pego de surpresa pelo uso de proxy nessas bibliotecas. 
Onde a documentação é insuficiente, os arquivos de cabeçalho preenchem a 
lacuna. Raramente é possível que o código-fonte oculte totalmente os objetos 
proxy. Eles normalmente são retornados de funções que se espera que os 
clientes chamem, portanto, as assinaturas de funções geralmente refletem 
sua existência. Aqui está a especificação para std::vector::operator[] , 
por exemplo: namespace std { // dos padrões C++ 
 
 Ponto 6 | 53 
template class 
vector { public: 
… 
 referência de classe {…}; 
 operador de referência [](size_type n); 
… 
}; 
} 
Supondo que você saiba que operator[] para std::vector normalmente 
retorna um T& , o tipo de retorno não convencional para operator[] neste caso 
é uma dica de que uma classe proxy está em uso. Prestar muita atenção às 
interfaces que você está usando muitas vezes pode revelar a existência de 
classes proxy. 
Na prática, muitos desenvolvedores descobrem o uso de classes proxy 
somente quando tentam rastrear problemas de compilação misteriosos ou 
depurar resultados incorretos de testes de unidade. Independentemente de 
como você os encontra, uma vez determinado que auto está deduzindo o tipo 
de uma classe de proxy em vez do tipo que está sendo proxy, a solução não 
precisa envolver o abandono de auto . auto em si não é o problema. O 
problema é que auto não está deduzindo o tipo que você deseja deduzir. A 
solução é forçar um tipo diferente de dedução. A maneira como você faz isso 
é o que chamo de idioma do inicializador explicitamente digitado . 
O idioma do inicializador digitado explicitamente envolve a declaração de uma 
variável com auto , mas a conversão da expressão de inicialização para o tipo 
que você deseja que auto deduza. Veja como ele pode ser usado para forçar 
highPriority a ser um bool , por exemplo: auto highPriority = static_cast( 
features(w)[5] ) ; 
Aqui, features(w)[5] continua retornando um objeto 
std::vector::reference , como sempre, mas a conversão altera o tipo da 
expressão para bool , que auto então deduz como o tipo para alta prioridade . 
Em tempo de execução, o objeto std::vec tor::reference retornado de 
std::vector::operator[] executa a conversão para bool que ele suporta 
e, como parte dessa conversão, o ainda válido ponteiro para o 
std::vector retornado dos recursos é desreferenciado. Isso evita o 
comportamento indefinido que encontramos anteriormente. O índice 5 é então 
 
54 | Artigo 6 
aplicado aos bits apontados pelo ponteiro, e o valor bool que emerge é usado 
para inicializar highPriority . 
Para o exemplo Matrix , o idioma do inicializador digitado explicitamente seria 
assim: auto sum = static_cast( m1 + m2 + m3 + m4 ) ; 
As aplicações do idioma não estão limitadas a inicializadores que produzem 
tipos de classe proxy. Também pode ser útil enfatizar que você está criando 
deliberadamente uma variável de tipo diferente daquela gerada pela 
expressão de inicialização. Por exemplo, suponha que você tenha uma função 
para calcular algum valor de tolerância: double calcEpsilon(); //retorna o valor 
da tolerância 
calcEpsilon retorna claramente um double , mas suponha que você saiba que 
para sua aplicação a precisão de um float é adequada e você se preocupa 
com a diferença de tamanho entre float se double s. Você poderia declarar 
uma variável float para armazenar o resultado 
de calcEpsilon , 
float ep = calcEpsilon(); // converte implicitamente // double 
→ float mas isso dificilmente anuncia “Estou reduzindo deliberadamente a 
precisão do valor retornado pela função”. Uma declaração usando o idioma do 
inicializador digitado explicitamente, entretanto, faz: auto ep = 
static_cast( calcEpsilon() ) ; 
Um raciocínio semelhante se aplica se você tiver uma expressão de ponto 
flutuante que está armazenando deliberadamente como um valor integral. 
Suponha que você precise calcular o índice de um elemento em um contêiner 
com iteradores de acesso aleatório (por exemplo, um std::vector , std::deque 
ou std::array ), e você recebe um double entre 0,0 e 1,0 indicando a que 
distância do início do contêiner o elemento desejado está localizado. ( 0,5 
indicaria o meio do contêiner.) Suponha ainda que você esteja confiante de 
que o índice resultante caberá em um int . Se o contêiner for c e o duplo for d 
, você poderá calcularo índice desta forma, 
int índice = d * c.size(); 
mas isso obscurece o fato de que você está convertendo intencionalmente o 
double à direita em um int . O idioma do inicializador digitado explicitamente 
torna as coisas transparentes: 
automático = static_cast( d * c.size() ) ; 
 
 Ponto 6 | 55 
Coisas para lembrar 
• Tipos de proxy “invisíveis” podem fazer com que auto deduza o tipo 
“errado” para uma expressão de inicialização. 
• O idioma do inicializador digitado explicitamente força o auto a deduzir 
o tipo que você deseja que ele tenha. 
 
56 
CAPÍT
ULO 3 
Mud
ando para C++ 
moderno 
Quando se trata de recursos de grande nome, C++ 11 e C++ 14 têm muito do 
que se orgulhar. auto , ponteiros inteligentes, semântica de movimento, 
lambdas, simultaneidade – cada um é tão importante que dedico um capítulo 
a ele. É essencial dominar esses recursos, mas tornar-se um programador 
C++ moderno e eficaz também requer uma série de etapas menores. Cada 
etapa responde a perguntas específicas que surgem durante a jornada do C++ 
98 ao C++ moderno. Quando você deve usar colchetes em vez de parênteses 
para criação de objetos? Por que as declarações de alias são melhores que 
typedef s? Como constexpr difere de const ? Qual é a relação entre funções 
de membro const e segurança de thread? A lista continua e continua. E, uma 
por uma, este capítulo fornece as respostas. 
Item 7: Distinguir entre () e {} ao criar 
objetos. 
 
 Ponto 7 | 57 
Dependendo da sua perspectiva, as opções de sintaxe para inicialização de 
objetos em C++ 11 incorporam uma vergonha de riqueza ou uma bagunça 
confusa. Como regra geral, os valores de inicialização podem ser 
especificados com parênteses, sinal de igual ou colchetes: 
intx ( 0 ) ; // inicializador está entre parênteses int y = 0; // 
inicializador segue "=" 
int z { 0 } ; // inicializador está entre colchetes 
Em muitos casos, também é possível usar sinal de igual e colchetes 
juntos: int z = {0} ; // inicializador usa "=" e chaves 
No restante deste item, geralmente ignorarei a sintaxe do sinal de igual mais 
colchetes, porque C++ geralmente a trata da mesma forma que a versão 
apenas com colchetes. 
O lobby da “bagunça confusa” aponta que o uso de um sinal de igual para 
inicialização muitas vezes engana os novatos em C++, fazendo-os pensar que 
uma atribuição está ocorrendo, mesmo que não esteja. Para tipos nativos 
como int , a diferença é acadêmica, mas para tipos definidos pelo usuário, é 
importante distinguir inicialização de atribuição, porque diferentes chamadas 
de função estão envolvidas: 
Widget w1; // chama o construtor padrão Widget w2 = w1; // não é 
uma atribuição; chama copiador 
w1 = w2; // uma tarefa; chama operador de cópia= 
Mesmo com diversas sintaxes de inicialização, houve algumas situações em 
que o C++ 98 não tinha como expressar a inicialização desejada. Por exemplo, 
não foi possível indicar diretamente que um contêiner STL deveria ser criado 
contendo um determinado conjunto de valores (por exemplo, 1, 3 e 5). 
Para resolver a confusão de múltiplas sintaxes de inicialização, bem como o 
fato de que elas não cobrem todos os cenários de inicialização, o C++ 11 
introduz a inicialização uniforme : uma única sintaxe de inicialização que pode, 
pelo menos em conceito, ser usada em qualquer lugar e expressar tudo. . É 
baseado em colchetes e, por esse motivo, prefiro o termo inicialização com 
colchetes . “Inicialização uniforme” é uma ideia. “Inicialização reforçada” é 
uma construção sintática. 
 
58 | Artigo 7 
A inicialização reforçada permite expressar o que antes era inexprimível. 
Usando colchetes, é fácil especificar o conteúdo inicial de um contêiner: 
std::vector v { 1, 3, 5 } ; // o conteúdo inicial de v é 1, 3, 5 Chaves também 
podem ser usadas para especificar valores de inicialização padrão para 
membros de dados não estáticos. Esse recurso – novo no C++ 11 – é 
compartilhado com a sintaxe de inicialização “ = ”, mas não com parênteses: 
classe Widget 
{… 
privado : int x {0} ; // tudo bem, o valor padrão de x é 0 
int y = 0; // também está bem int z ( 0 ) ; //erro! }; 
Por outro lado, objetos não copiáveis (por exemplo, std::atomic s – veja Item 
40 ) podem ser inicializados usando colchetes ou parênteses, mas não usando 
“ = ”: 
std::atomic ai1 { 0 } ; // multar 
std::atomic ai2 ( 0 ) ; // multar 
std::atomic ai3 = 0; //erro! 
Portanto, é fácil entender por que a inicialização reforçada é chamada de 
“uniforme”. Das três maneiras de designar uma expressão de inicialização em 
C++, apenas colchetes podem ser usados em todos os lugares. 
Um novo recurso da inicialização com chaves é que ela proíbe conversões de 
restrição implícitas entre tipos integrados. Se não for garantido que o valor de 
uma expressão em um inicializador entre chaves seja expressável pelo tipo 
do objeto que está sendo inicializado, o código não será compilado: double x, 
y, z; … 
int soma1 { x + y + z } ; //erro! soma de duplos pode 
// não pode ser expresso como int 
A inicialização usando parênteses e “ = ” não verifica conversões estreitas, 
porque isso poderia quebrar muito código legado: 
int soma2 ( x + y + z ) ; // ok (valor da expressão 
// truncado para um int) 
int soma3 = x + y + z; // idem 
 
 Ponto 7 | 59 
análise mais irritante do C++ . Um efeito colateral da regra do C++ de que 
qualquer coisa que possa ser analisada como uma declaração deve ser 
interpretada como tal, a análise mais irritante aflige com mais frequência os 
desenvolvedores quando eles desejam construir um objeto por padrão, mas 
inadvertidamente acabam declarando uma função. A raiz do problema é que 
se você quiser chamar um construtor com um argumento, você pode fazer 
assim, 
Widget w1 (10) ; // chama o Widget ctor com o argumento 10, mas se você 
tentar chamar um construtor do Widget com zero argumentos usando a 
sintaxe análoga, você declara uma função em vez de um objeto: 
Widget w2 () ; // análise mais irritante! declara uma função 
// chamado w2 que retorna um Widget! 
Funções não podem ser declaradas usando chaves para a lista de 
parâmetros, então construir um objeto por padrão usando chaves não tem 
esse problema: 
Widget w3 {} ; // chama o Widget ctor sem argumentos 
Portanto, há muito a ser dito sobre a inicialização reforçada. É a sintaxe que 
pode ser usada na mais ampla variedade de contextos, evita conversões 
implícitas e é imune à análise mais incômoda do C++. Uma trifeta de bondade! 
Então, por que este item não tem o título algo como “Preferir sintaxe de 
inicialização entre chaves”? 
A desvantagem da inicialização reforçada é o comportamento às vezes 
surpreendente que a acompanha. Esse comportamento surge do 
relacionamento incomumente emaranhado entre inicializadores reforçados, 
std::initializer_list s e resolução de sobrecarga do construtor. Suas interações 
podem levar a um código que parece que deveria fazer uma coisa, mas na 
verdade faz outra. Por exemplo, o Item 2 explica que quando uma variável 
autodeclarada tem um inicializador entre chaves, o tipo deduzido é 
std::initializer_list , mesmo que outras maneiras de declarar uma variável com 
o mesmo inicializador produzam um tipo mais intuitivo. Como resultado, 
quanto mais você gosta de auto , menos entusiasmado você ficará com a 
inicialização preparada. 
Nas chamadas do construtor, parênteses e colchetes têm o mesmo 
significado, desde que os parâmetros std::initializer_list não estejam 
envolvidos: 
classe Widget { público: 
 
60 | Artigo 7 
Widget(int i, bool b); // ctors não declarando Widget(int i, double d); // 
parâmetros std::initializer_list 
… 
}; 
Widget w1 ( 10, verdadeiro ) ; //chama o primeiro ctor 
Widget w2 { 10, verdadeiro } ; // também chama o primeiro ctor 
Widget w3 ( 10, 5,0 ) ; //chama o segundo ctor 
Widget w4 { 10,5,0 } ; // também chama o segundo ctor 
Se, no entanto, um ou mais construtores declararem um parâmetro do tipo 
std::initial izer_list , as chamadas que usam a sintaxe de inicialização 
reforçada preferem fortemente as sobrecargas que levam std::initializer_list s. 
Fortemente . Se houver alguma maneira de os compiladores interpretarem 
uma chamada usando um inicializador reforçado como sendo para um 
construtor que usa um std::initial izer_list , os compiladores empregarão essa 
interpretação. Se a classe Widget acima for aumentada com um construtor 
que recebe um std::initializer_list , por exemplo, 
classe Widget { público: 
Widget(int i, bool b); // como antes 
Widget(int i, duplo d); // como antes Widget(std::initializer_list il); // adicionado 
… 
}; 
Os widgets w2 e w4 serão construídos usando o novo construtor, mesmo que 
o tipo dos elementos std::initializer_list ( long double ) é, comparado aos 
construtores não std::initializer_list , uma correspondência pior para ambos os 
argumentos! Olhar: 
Widget w1 ( 10, verdadeiro ) ; // usa parênteses e, como antes, 
 //chama o primeiro ctor 
Widget w2 { 10, verdadeiro } ; // usa chaves, mas agora chama 
 // std::initializer_list ctor 
 // (10 e true converte para long double) 
Widget w3 ( 10, 5,0 ) ; // usa parênteses e, como antes, 
 //chama o segundo ctor 
 
 Ponto 7 | 61 
Widget w4 { 10, 5,0 } ; // usa chaves, mas agora chama 
 // std::initializer_list ctor 
 // (10 e 5.0 são convertidos para long double) Mesmo o que 
normalmente seria uma construção de copiar e mover pode ser sequestrado 
por 
std::initializer_list : 
classe Widget { público: 
Widget(int i, bool b); // como antes 
Widget(int i, duplo d); // como antes Widget(std::initializer_list il); // como antes 
 operador float() const; //converte … //para flutuar 
}; 
Widget w5 ( w4 ) ; // usa parênteses, chama copy ctor 
Widget w6 { w4 } ; // usa chaves, chamadas 
 // std::initializer_list ctor 
 // (w4 converte para float e float 
 //converte para long double) 
Widget w7 ( std::move(w4) ) ; // usa parênteses, chama move ctor 
Widget w8 { std::move(w4) } ; // usa chaves, chamadas 
 // std::initializer_list ctor 
 // (pelo mesmo motivo que w6) 
A determinação dos compiladores de combinar inicializadores com chaves 
com construtores que usam std::initializer_list s é tão forte que prevalece 
mesmo se o construtor std::ini tializer_list de melhor correspondência não 
puder ser chamado. Por exemplo: 
classe Widget { público: 
Widget(int i, bool b); // como antes 
Widget(int i, duplo d); // como antes 
Widget(std::initializer_list il); //o tipo do elemento é 
 // agora bool 
… // não implícito 
}; //funções de conversão 
 
62 | Artigo 7 
Widget w {10, 5,0} ; //erro! requer redução de conversões 
Aqui, os compiladores irão ignorar os dois primeiros construtores (o segundo 
oferece uma correspondência exata em ambos os tipos de argumento) e 
tentar chamar o construtor usando um std::initializer_list . Chamar esse 
construtor exigiria a conversão de um int ( 10 ) e um double ( 5.0 ) em bool s. 
Ambas as conversões estariam diminuindo 
( bool não pode representar exatamente nenhum dos valores) e conversões 
restritivas são proibidas dentro de inicializadores entre chaves, portanto a 
chamada é inválida e o código é rejeitado. 
Somente se não houver como converter os tipos de argumentos em um 
inicializador com chaves para o tipo em um std::initializer_list os compiladores 
recorrem à resolução de sobrecarga normal. Por exemplo, se substituirmos o 
construtor std::initializer_list por outro que usa 
std::initializer_list , os construtores não std::initializer_list tornam-
se candidatos novamente, porque não há como converter int s e bool s para 
std::string s: 
classe Widget { público: 
Widget(int i, bool b); // como antes 
Widget(int i, duplo d); // como antes 
 // o tipo de elemento std::initializer_list agora é std::string 
Widget(std::initializer_list il); 
… // não implícito 
}; //funções de conversão 
Widget w1 ( 10, verdadeiro ) ; // usa parênteses, ainda chama o primeiro 
ctor 
Widget w2 { 10, verdadeiro } ; // usa chaves, agora chama o primeiro 
ctor 
Widget w3 ( 10, 5,0 ) ; // usa parênteses, ainda chama o segundo ctor 
Widget w4 { 10, 5,0 } ; // usa chaves, agora chama o segundo ctor 
Isso nos leva perto do fim de nosso exame de inicializadores reforçados e 
sobrecarga de construtor, mas há um caso extremo interessante que precisa 
ser resolvido. Suponha que você use um conjunto vazio de colchetes para 
construir um objeto que oferece suporte à construção padrão e também à 
construção std::initializer_list . O que significam seus colchetes vazios? Se 
 
 Ponto 7 | 63 
eles significarem “sem argumentos”, você obterá a construção padrão, mas 
se eles significarem “ std::initializer_list vazio ”, você obterá a construção de 
um std::ini tializer_list sem elementos. 
A regra é que você obtenha a construção padrão. Colchetes vazios significam 
nenhum argumento, não um std::initializer_list vazio : 
classe Widget { public: Widget(); //tor padrão 
Widget(std::initializer_list il); //std::inicializador 
 // _list ctor 
… // não implícito 
}; //funções de conversão 
Widget w1; // chama o ctor padrão 
Widget w2 {} ; // também chama o ctor padrão 
Widget w3 () ; // análise mais irritante! declara uma função! 
Se você quiser chamar um construtor std::initializer_list com um std::ini 
tializer_list vazio , faça isso transformando os colchetes vazios em um 
argumento do construtor - colocando os colchetes vazios dentro dos 
parênteses ou colchetes demarcando o que você está passando: 
Widget w4( {} ); // chama std::initializer_list ctor 
 //com lista vazia 
Widget w5{ {} }; // idem 
Neste ponto, com regras aparentemente misteriosas sobre inicializadores 
reforçados, std::initial izer_list s e sobrecarga de construtores borbulhando em 
seu cérebro, você pode estar se perguntando o quanto dessas informações 
são importantes na programação do dia-a-dia. Mais do que você imagina, 
porque uma das classes diretamente afetadas é std::vector . 
std::vector tem um construtor não std::initializer_list que permite especificar o 
tamanho inicial do contêiner e um valor que cada um dos elementos iniciais 
deve ter, mas também tem um construtor que recebe um std::initializer_list 
que permite que você para especificar os valores iniciais no contêiner. Se você 
criar um std::vector de um tipo numérico (por exemplo, um std::vector ) e 
passar dois argumentos para o construtor, colocar esses argumentos entre 
parênteses ou colchetes fará uma tremenda diferença: 
std::vector v1 ( 10, 20 ) ; // usa não-std::initializer_list 
 
64 | Artigo 7 
 // ctor: cria 10 elementos 
 // std::vector, todos os elementos possuem 
 //valor de 20 
std::vector v2 { 10, 20 } ; // usa std::initializer_list ctor: 
//cria std::vector de 2 elementos, 
 // os valores dos elementos são 10 e 20 
Mas vamos voltar atrás em std::vector e também nos detalhes de 
parênteses, colchetes e regras de resolução de sobrecarga de construtor. 
Existem duas conclusões principais desta discussão. Primeiro, como autor de 
uma classe, você precisa estar ciente de que, se o seu conjunto de 
construtores sobrecarregados incluir uma ou mais funçõesque utilizam std::ini 
tializer_list , o código do cliente que usa inicialização com chaves poderá ver 
apenas as sobrecargas de std::ini tializer_list . Como resultado, é melhor 
projetar seus construtores de modo que a sobrecarga chamada não seja 
afetada pelo uso de parênteses ou colchetes pelos clientes. Em outras 
palavras, aprenda com o que agora é visto como um erro no design da 
interface std::vec tor e projete suas classes para evitá-lo. 
Uma implicação é que se você tiver uma classe sem construtor 
std::initializer_list e adicionar um, o código do cliente usando inicialização 
entre chaves poderá descobrir que as chamadas que costumavam resolver 
para construtores não std::initializer_list agora são resolvidas para a nova 
função. É claro que esse tipo de coisa pode acontecer sempre que você 
adiciona uma nova função a um conjunto de sobrecargas: chamadas que 
costumavam resolver uma das sobrecargas antigas podem começar a chamar 
a nova. A diferença com as sobrecargas do construtor std::initializer_list é que 
uma sobrecarga std::initializer_list não apenas compete com outras 
sobrecargas, ela as ofusca a tal ponto que as outras sobrecargas dificilmente 
podem ser consideradas. Portanto, adicione tais sobrecargas somente com 
grande deliberação. 
A segunda lição é que, como cliente de classe, você deve escolher 
cuidadosamente entre parênteses e colchetes ao criar objetos. A maioria dos 
desenvolvedores acaba escolhendo um tipo de delimitador como padrão, 
usando o outro apenas quando necessário. As pessoas que utilizam chaves 
por padrão são atraídas por sua incomparável amplitude de aplicabilidade, sua 
proibição de restringir conversões e sua imunidade à análise mais irritante do 
C++. Essas pessoas entendem que em alguns casos (por exemplo, criação 
de um std::vector com um determinado tamanho e valor de elemento inicial), 
os parênteses são necessários. Por outro lado, a multidão goparênteses-go 
 
 Ponto 7 | 65 
adota os parênteses como seu delimitador de argumento padrão. Eles são 
atraídos por sua consistência com a tradição sintática do C++ 98, por evitar o 
problema auto -deduced-a- std::initializer_list e pelo conhecimento de que 
suas chamadas de criação de objeto não serão inadvertidamente 
interceptadas por std:: construtores izer_list iniciais . Eles admitem que às 
vezes apenas chaves servem (por exemplo, ao criar um contêiner com valores 
específicos). Não há consenso de que uma das abordagens seja melhor que 
a outra, então meu conselho é escolher uma e aplicá-la de forma consistente. 
Se você é autor de templates, a tensão entre parênteses e colchetes na 
criação de objetos pode ser especialmente frustrante, pois, em geral, não é 
possível saber qual deve ser usado. Por exemplo, suponha que você queira 
criar um objeto de tipo arbitrário a partir de um número arbitrário de 
argumentos. Um modelo variado torna isso conceitualmente simples: 
template // 
tipos de argumentos a serem usados 
void doSomeWork(Ts&&... params) 
{ 
 crie um objeto T local a partir de 
parâmetros... … 
} 
Existem duas maneiras de transformar a linha de pseudocódigo em código 
real (consulte o Item 25 para obter informações sobre std::forward ): 
T localObject ( std::forward(params)... ) ; //usando parênteses 
T localObject { std::forward(params)... } ; // usando chaves Então 
considere este código de chamada: 
std::vetor v; 
… 
doSomeWork>(10, 20); 
Se doSomeWork usar parênteses ao criar localObject , o resultado será um 
std::vector com 10 elementos. Se doSomeWork usar colchetes, o resultado 
será um std::vec tor com 2 elementos. Qual é correto? O autor de 
doSomeWork não pode saber. Somente o chamador pode. 
Este é precisamente o problema enfrentado pelas funções std::make_unique 
e std::make_shared da Biblioteca Padrão (ver Item 21 ). Essas funções 
 
66 | Artigo 7 
resolvem o problema usando parênteses internamente e documentando essa 
decisão como parte de suas interfaces.1 
Coisas para lembrar 
• A inicialização reforçada é a sintaxe de inicialização mais amplamente 
utilizável, evita conversões estreitas e é imune à análise mais incômoda 
do C++. 
• Durante a resolução de sobrecarga do construtor, os inicializadores com 
chaves são correspondidos aos parâmetros std::initializer_list se 
possível, mesmo que outros construtores ofereçam correspondências 
aparentemente melhores. 
• Um exemplo de onde a escolha entre parênteses e colchetes pode fazer 
uma diferença significativa é criar um std::vector com 
dois argumentos. 
• Escolher entre parênteses e colchetes para a criação de objetos dentro 
de modelos pode ser um desafio. 
Item 8: Prefira nullptr a 0 e NULL . 
Então o negócio é o seguinte: o literal 0 é um int , não um ponteiro. Se o C++ 
estiver olhando para 0 em um contexto onde apenas um ponteiro pode ser 
usado, ele interpretará relutantemente 0 como um ponteiro nulo, mas essa é 
uma posição alternativa. A política primária do C++ é que 0 seja um int , não 
um ponteiro. 
Na prática, o mesmo vale para NULL . Há alguma incerteza nos detalhes no 
caso de NULL , porque as implementações podem dar a NULL um tipo integral 
diferente de int (por exemplo, long ). Isso não é comum, mas realmente não 
importa, porque o problema aqui não é o tipo exato de NULL , é que nem 0 
nem NULL possuem um tipo de ponteiro. 
 
1Projetos mais flexíveis — aqueles que permitem aos chamadores determinar se parênteses ou colchetes devem 
ser usados em funções geradas a partir de um modelo — são possíveis. Para obter detalhes, consulte a entrada 
de 5 de junho de 2013 do blog C++ de Andrze j , “ Interface intuitiva — Parte I ”. 
http://akrzemi1.wordpress.com/
http://akrzemi1.wordpress.com/
http://akrzemi1.wordpress.com/
http://akrzemi1.wordpress.com/2013/06/05/intuitive-interface-part-i/
 
 | 67 
No C++ 98, a principal implicação disso era que a sobrecarga em tipos de 
ponteiro e integrais poderia levar a surpresas. Passar 0 ou NULL para tais 
sobrecargas nunca é chamado de sobrecarga de ponteiro: 
vazio f(int); // três sobrecargas de f 
vazio f(bool); vazio f(vazio*); f(0); // chama f(int), não 
f(void*) 
f(NULO); // pode não compilar, mas normalmente chama 
//f(int). Nunca chama f(void*) 
A incerteza quanto ao comportamento de f(NULL) é reflexo da margem de 
manobra concedida às implementações quanto ao tipo de NULL . Se NULL 
for definido como, digamos, 0L (ou seja, 0 como long ), a chamada é ambígua, 
porque a conversão de long para int , long para bool e 0L para void* são 
consideradas igualmente boas. O interessante dessa chamada é a 
contradição entre o significado aparente do código-fonte (“Estou chamando f 
com NULL — o ponteiro nulo”) e seu significado real (“Estou chamando f com 
algum tipo de número inteiro — não o ponteiro nulo”). Esse comportamento 
contra-intuitivo é o que levou à diretriz para programadores de C++ 98 
evitarem sobrecarga em tipos de ponteiro e integrais. Essa diretriz permanece 
válida no C++ 11, porque, apesar do conselho deste item, é provável que 
alguns desenvolvedores continuem a usar 0 e NULL , mesmo que nullptr seja 
uma escolha melhor. 
nullptr é que ele não possui um tipo integral. Para ser honesto, ele também 
não possui um tipo de ponteiro, mas você pode considerá-lo um ponteiro de 
todos os tipos. O tipo real de nullptr é std::nullptr_t e, em uma definição 
maravilhosamente circular, std::nullptr_t é definido como o tipo de nullptr . O 
tipo std::nullptr_t converte implicitamente em todos os tipos de ponteiro brutos, 
e é isso que faz nullptr agir como se fosse um ponteiro de todos os tipos. 
Chamar a função sobrecarregada f com nullptr chama a sobrecarga void* (ou 
seja, a sobrecarga do ponteiro), porque nullptr não pode ser visto como algo 
integral:fé para garantir que as informações 
e instruções contidas nesta obra sejam precisas, a editora e o autor isentam-se de qualquer 
responsabilidade por erros ou omissões, incluindo, sem limitação, responsabilidade por danos 
resultantes do uso ou confiança neste trabalho. O uso das informações e instruções contidas 
neste trabalho é por sua conta e risco. Se quaisquer exemplos de código ou outra tecnologia 
que este trabalho contém ou descreve estão sujeitos a licenças de código aberto ou aos direitos 
de propriedade intelectual de terceiros, é sua responsabilidade garantir que seu uso esteja em 
conformidade com tais licenças e/ou direitos. 
978-1-491-90399-5 
[TI] 
 
Para Darla, 
extraordinário labrador retriever preto 
http://oreilly.com/catalog/errata.csp?isbn=9781491903995
 
 
 
 
vii 
Índice 
Da Editora. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 
. . . . . . . . . . . . . . . . XI 
Agradecimentos. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 
. . . . . . . . . . . . . . . . . . . . xiii 
Introdução. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 
. . . . . . . . . . . . . . . . . . . . . . 1 
1. Deduzindo Tipos. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 
. . . . . . . . . . . . . . . . . . . . . . . 9 
Item 1: Entenda a dedução do tipo de modelo. 9 
Item 2: Entenda a dedução automática . 18 
Item 3: Entenda o decltype . 23 
Item 4: Saiba como visualizar os tipos deduzidos. 30 
2. automático . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 
. . . . . . . . . . . . . . . . . . . . . . . . . . . 37 
Item 5: Prefira declarações de tipo automáticas a explícitas. 37 Item 6: Use 
o idioma do inicializador digitado explicitamente ao deduzir 
automaticamente 
tipos indesejados. 43 
3. Mudando para C++ moderno. . . . . . . . . . . . . . . . . . . . . . . . . . . . 
. . . . . . . . . . . . . . . . . . . . . . . . . 49 
Item 7: Distinguir entre () e {} ao criar objetos. 49 Item 8: Prefira nullptr a 0 
e NULL . 58 Item 9: Prefira declarações de alias a typedef s. 63 
Item 10: Prefira enum s com escopo a enum s sem escopo. 67 
Item 11: Prefira funções excluídas às privadas indefinidas. 74 
 
 
Item 12: Declarar substituição de funções de substituição . 79 
Item 13: Prefira const_iterator s a iterator s. 86 Item 14: Declare funções 
noexcept se elas não emitirem exceções. 90 Item 15: Use constexpr 
sempre que possível. 97 Item 16: Tornar as funções de membro const 
seguras para threads. 103 
Item 17: Compreenda a geração de função de membro especial. 109 
4. Ponteiros inteligentes. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 
. . . . . . . . . . . . . . . . . . . . . . . . . . . 117 
Item 18: Use std::unique_ptr para recurso de propriedade exclusiva 
gerenciamento. 118 
Item 19: Use std::shared_ptr para recurso de propriedade compartilhada 
gerenciamento. 125 
Item 20: Use std::weak_ptr para ponteiros do tipo std::shared_ptr que 
podem 
balançar. 134 
Item 21: Prefira std::make_unique e std::make_shared para uso direto de 
novo . 139 
Item 22: Ao usar o idioma Pimpl, defina funções de membro especiais em 
o arquivo de implementação. 147 
5. Referências Rvalue, Semântica de Movimento e 
Encaminhamento Perfeito. . . . . . . . . . . . . . . . . . . . 157 Item 23: 
Entenda std::move e std::forward . 158 
Item 24: Distinguir referências universais de referências de valor. 164 Item 
25: Use std::move em referências de rvalue, std::forward em universal 
referências. 168 
Item 26: Evite sobrecarga nas referências universais. 177 
Item 27: Familiarize-se com alternativas à sobrecarga na universal 
referências. 184 Item 28: Entenda o colapso de referência. 197 
Item 29: Suponha que as operações de movimentação não estejam 
presentes, não sejam baratas e não 
usado. 203 
Item 30: Familiarize-se com casos de falha de encaminhamento perfeito. 
207 
6. Expressões Lambda. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 
. . . . . . . . . . . . . . . . . . . . 215 Item 31: Evite modos de captura padrão. 
216 
 
ix 
Item 32: Use a captura de inicialização para mover objetos para 
fechamentos. 224 
Item 33: Use decltype nos parâmetros auto&& para std::forward eles. 229 
Item 34: Prefira lambdas a std::bind . 232 
7. A API de simultaneidade. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 
. . . . . . . . . . . . . . . . . . . . . . . . 241 
Item 35: Prefira a programação baseada em tarefas à baseada em threads. 
241 
Item 36: Especifique std::launch::async se a assincronicidade for essencial. 
245 
Item 37: Torne std::threads incompatíveis em todos os caminhos. 250 
Item 38: Esteja ciente dos diferentes comportamentos do destruidor de 
identificador de thread. 258 
Item 39: Considere futuros vazios para comunicação de eventos únicos. 
262 
 
viii | Índice 
Item 40: Use std::atomic para simultaneidade, volátil para memória especial. 
271 
8. Ajustes. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 
. . . . . . . . . . . . . . . . . . . . 281 
Item 41: Considere a passagem por valor para parâmetros copiáveis que 
são baratos para 
mover e sempre copiado. 281 
Item 42: Considere a colocação em vez da inserção. 292 
Índice. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 
. . . . . . . . . . . . . . . . . . . . . . 303 
 
 
 Índice | 
 
 
 
 
 
Do Editor 
Usando exemplos de código 
Este livro está aqui para ajudá-lo a realizar seu trabalho. Em geral, se um 
código de exemplo for oferecido com este livro, você poderá usá-lo em seus 
programas e documentação. Você não precisa entrar em contato conosco 
para obter permissão, a menos que esteja reproduzindo uma parte 
significativa do código. Por exemplo, escrever um programa que utilize vários 
trechos de código deste livro não requer permissão. Vender ou distribuir um 
CD-ROM com exemplos de livros da O'Reilly requer permissão. Responder a 
uma pergunta citando este livro e citando código de exemplo não requer 
permissão. Incorporar uma quantidade significativa de código de exemplo 
deste livro na documentação do seu produto requer permissão. 
Agradecemos, mas não exigimos, atribuição. Uma atribuição geralmente inclui 
título, autor, editora e ISBN. Por exemplo: “ C++ Moderno Eficaz por Scott 
Meyers (O'Reilly). Direitos autorais 2015 Scott Meyers, 978-1-491-90399-5.” 
Se você acha que o uso de exemplos de código está fora do uso justo ou da 
permissão dada acima, sinta-se à vontade para nos contatar em 
permissions@oreilly.com . 
Livros on-line do Safari® 
Safari Books Online é uma biblioteca digital sob 
demanda que oferece conteúdo especializado em 
formato de livro e vídeo dos principais autores 
mundiais em tecnologia e negócios. 
Profissionais de tecnologia, desenvolvedores de software, web designers e 
profissionais de negócios e criativos usam Safari Books Online como recurso 
principal para pesquisa, solução de problemas, aprendizado e treinamento de 
certificação. 
http://safaribooksonline.com/
https://www.safaribooksonline.com/explore/
https://www.safaribooksonline.com/explore/
 
xiii 
Safari Books Online oferece uma variedade de planos e preços para empresa 
, governo , educação e indivíduos. 
Os membros têm acesso a milhares de livros, vídeos de treinamento e 
manuscritos de pré-publicação em um banco de dados totalmente pesquisável 
de editoras como O'Reilly Media, Prentice Hall Professional, Addison-Wesley 
Professional, Microsoft Press, Sams, Que, Peachpit Press, Focal Press, Cisco 
Press, John Wiley & Sons, Syngress, Morgan Kaufmann, IBM Redbooks, 
Packt, Adobe Press, FT Press, Apress, Manning, New Riders, McGraw-Hill, 
Jones & Bartlett, Course Technology e centenas def(nullptr); // chama a sobrecarga de f(void*) 
Usar nullptr em vez de 0 ou NULL evita surpresas de resolução de sobrecarga, 
mas essa não é sua única vantagem. Também pode melhorar a clareza do 
código, especialmente quando variáveis automáticas estão envolvidas. Por 
exemplo, suponha que você encontre isso em uma base de código: 
resultado automático = findRecord( /* argumentos */ 
); se ( resultado == 0 ) { 
 
68 | 
Artigo 8 
… 
} 
Se você não souber (ou não conseguir descobrir facilmente) o que findRecord 
retorna, pode não estar claro se result é um tipo de ponteiro ou um tipo 
integral. Afinal, 0 
(contra qual resultado é testado) pode ocorrer de qualquer maneira. Por outro 
lado, se você vir o seguinte, auto result = findRecord( /* argumentos */ ); 
if ( resultado == nullptr ) { 
… 
} não há ambigüidade: o resultado deve ser 
do tipo ponteiro. 
nullptr brilha especialmente quando os modelos entram em cena. Suponha 
que você tenha algumas funções que devem ser chamadas somente quando 
o mutex apropriado for bloqueado. Cada função usa um tipo diferente de 
ponteiro: 
int f1(std::shared_ptr spw); // chama-os apenas quando double 
f2(std::unique_ptr upw); // o bool apropriado f3(Widget* pw); // 
mutex está bloqueado O código de chamada que deseja passar ponteiros 
nulos poderia ser assim: 
std::mutex f1m, f2m, f3m; // mutexes para f1, f2 e f3 
usando MuxGuard = // C++11 typedef; veja o item 9 
std::lock_guard; … 
{ 
MuxGuardg(f1m); // bloqueia mutex para f1 auto result = f1( 0 ); 
// passa 0 como ptr nulo para f1 } // desbloqueia o mutex 
… 
{ 
MuxGuardg(f2m); // bloqueia mutex para f2 auto result = f2( NULL 
); // passa NULL como ptr nulo para f2 } // desbloqueia mutex 
… 
{ 
 
 | 69 
Artigo 8 
MuxGuardg(f3m); // bloqueia mutex para f3 
resultado automático = f3( nullptr ); // passa nullptr como null ptr para f3 
} // desbloqueia mutex 
A falha em usar nullptr nas duas primeiras chamadas neste código é triste, 
mas o código funciona e isso conta para alguma coisa. No entanto, o padrão 
repetido no código de chamada – bloquear mutex, chamar função, 
desbloquear mutex – é mais do que triste. É perturbador. Esse tipo de 
duplicação de código-fonte é uma das coisas que os modelos são projetados 
para evitar, então vamos modelar o padrão: 
template auto 
lockAndCall(FuncType func, 
MuxType& mutex, 
PtrType ptr) -> decltype(func(ptr)) 
{ 
MuxGuardg(mutex); 
retornar função(ptr); } 
Se o tipo de retorno desta função ( auto … -> decltype(func(ptr) ) faz você 
coçar a cabeça, faça um favor à sua cabeça e navegue até o Item 3 , que 
explica o que está acontecendo. Lá você verá que em C++ 14, o tipo de 
retorno pode ser reduzido a um simples decltype(auto) : 
template 
decltype(auto) lockAndCall(FuncType func, //C++14 
MuxType e mutex, 
PtrTipo ptr) 
{ 
MuxGuardg(mutex); 
retornar função(ptr); } 
Dado o modelo lockAndCall (qualquer versão), os chamadores podem 
escrever código como este: 
resultado automático1 = lockAndCall(f1, f1m, 0 ); //erro! … 
resultado automático2 = lockAndCall(f2, f2m, NULL ); //erro! … 
 
70 | 
Artigo 8 
resultado automático3 = lockAndCall(f3, f3m, nullptr ); // multar 
Bem, eles podem escrever, mas, como indicam os comentários, em dois dos 
três casos, o código não será compilado. O problema na primeira chamada é 
que quando 0 é passado para lockAnd Call , a dedução do tipo de modelo 
entra em ação para descobrir seu tipo. O tipo 0 é, foi e sempre será int , então 
esse é o tipo do parâmetro ptr dentro da instanciação desta chamada para 
lockAndCall . Infelizmente, isso significa que na chamada para func dentro de 
lockAndCall , um int está sendo passado e isso não é compatível com o 
parâmetro std::shared_ptr que f1 espera. O 0 passado na chamada 
para lockAndCall pretendia representar um ponteiro nulo, mas o que 
realmente foi passado foi um int comum . Tentar passar esse int para f1 como 
std::shared_ptr é um erro de tipo. A chamada para lockAndCall com 
0 falha porque dentro do modelo, um int está sendo passado para uma função 
que requer um std:: shared_ptr . 
A análise para a chamada envolvendo NULL é essencialmente a mesma. 
Quando NULL é passado para lockAndCall , um tipo integral é deduzido para 
o parâmetro ptr , e um erro de tipo ocorre quando ptr —um tipo int ou int - é 
passado para f2 , que espera obter um std::unique_ptr . 
Por outro lado, a chamada envolvendo nullptr não apresenta problemas. 
Quando nullptr é passado para lockAndCall , o tipo de ptr é deduzido como 
std::nullptr_t . Quando ptr é passado para f3 , há uma conversão implícita de 
std::nullptr_t para Widget* , porque std::nullptr_t converte implicitamente para 
todos os tipos de ponteiro. 
O fato de que a dedução do tipo de modelo deduz os tipos “errados” para 0 e 
NULL (ou seja, seus tipos verdadeiros, em vez de seu significado substituto 
como uma representação para um ponteiro nulo) é a razão mais convincente 
para usar nullptr em vez de 0 ou NULL quando você deseja se referir a um 
ponteiro nulo. Com nullptr , os modelos não representam nenhum desafio 
especial. Combinado com o fato de que nullptr não sofre com as surpresas de 
resolução de sobrecarga às quais 0 e NULL são suscetíveis, o caso é rígido. 
Quando você quiser se referir a um ponteiro nulo, use nullptr , não 0 ou NULL 
. 
Coisas para lembrar 
• Prefira nullptr a 0 e NULL . 
• Evite sobrecarregar os tipos integral e ponteiro. 
 
 | 71 
Artigo 8 
 
72 | 
Item 9: Prefira declarações de alias a 
typedef s. 
Estou confiante de que podemos concordar que usar contêineres STL é uma 
boa ideia, e espero que o Item 18 convença você de que usar std::unique_ptr 
é uma boa ideia, mas meu palpite é que nenhum de nós gosta de escrever 
tipos como “ std::unique_ptr> ” 
mais de uma vez. Só de pensar nisso provavelmente aumenta o risco de 
síndrome do túnel do carpo. 
Evitar tais tragédias médicas é fácil. Apresente um typedef : 
typedef 
std::unique_ptr> 
UPtrMapSS; 
Mas typedef s são muuuito C++98. Eles funcionam em C++ 11, claro, mas 
C++ 11 também oferece 
declarações de alias : 
usando UPtrMapSS = 
std::unique_ptr>; Dado que o 
typedef e a declaração de alias fazem exatamente a mesma coisa, é razoável 
perguntar se existe uma razão técnica sólida para preferir um ao outro. 
Existe, mas antes de começar, quero mencionar que muitas pessoas acham 
a declaração de alias mais fácil de engolir quando lidam com tipos que 
envolvem ponteiros de função: 
// FP é sinônimo de ponteiro para uma função que recebe um int e 
// um const std::string& e não retorna nada 
typedef void (* FP )(int, const std::string&); //typedef 
// mesmo significado acima 
usando FP = void (*)(int, const std::string&); // alias 
 //declaração 
É claro que nenhuma das formas é particularmente fácil de sufocar e, de 
qualquer forma, poucas pessoas gastam muito tempo lidando com sinônimos 
para tipos de ponteiros de função; portanto, esse não é um motivo convincente 
para escolher declarações de alias em vez de typedef s. 
Mas existe uma razão convincente: modelos. Em particular, as declarações de 
alias podem ser padronizadas (nesse caso, são chamadas de alias templates 
), enquanto os typedef s não podem. Isso dá aos programadores de C++ 11 
 
 Ponto 9 | 73 
um mecanismo direto para expressar coisas que em C++ 98 tiveram que ser 
hackeadas junto com typedef s aninhados dentro de struct s modelados. Por 
exemplo, considere definir um sinônimo para uma lista vinculada que usa um 
alocador personalizado, MyAlloc . Com um modelo dealias, é muito fácil: 
modelo // MyAllocList usando 
MyAllocList = std::list>; // é sinônimo de 
// std::lista> 
MyAllocList lw; // código do cliente Com um typedef , você 
praticamente terá que criar o bolo do zero: 
modelo // MyAllocList::type struct 
MyAllocList { // é sinônimo de typedef std::list> type ; // std::lista> 
MyAllocList::type lw; // Código do cliente 
Fica pior. Se você quiser usar o typedef dentro de um modelo com o propósito 
de criar uma lista vinculada contendo objetos de um tipo especificado por um 
parâmetro do modelo, você deve preceder o nome do typedef com typename 
: 
modelo 
class Widget { // Widget contém private: // a MyAllocList 
typename MyAllocList::tipo lista; // como membro de dados 
… 
}; 
Aqui, MyAllocList::type refere-se a um tipo que depende de um parâmetro 
de tipo de modelo ( T ). MyAllocList::type é, portanto, um tipo dependente 
, e uma das muitas regras cativantes do C++ é que os nomes dos tipos 
dependentes devem ser precedidos pelo tipo name . 
Se MyAllocList for definido como um modelo de alias, essa necessidade de 
typename desaparece (assim como o complicado sufixo “ ::type ”): 
modelo 
usando MyAllocList = std::list>; // como antes 
template 
class Widget {privado: 
 lista MyAllocList ; // sem "nome do tipo", 
… // não "::tipo" 
 
74 | 
}; 
Para você, MyAllocList (ou seja, o uso do modelo de alias) pode parecer 
tão dependente do parâmetro do modelo T quanto MyAllocList::type (ou 
seja, o uso do tipo aninhado 
Artigo 9 
def ), mas você não é um compilador. Quando os compiladores processam o 
modelo Widget e encontram o uso de MyAllocList (ou seja, o uso do 
modelo alias), eles sabem que MyAllocList é o nome de um tipo, porque 
MyAllocList é um modelo alias: ele deve nomear um tipo. MyAllocList é, 
portanto, um type não dependente e um especificador typename não é 
obrigatório nem permitido. 
Quando os compiladores veem MyAllocList::type (ou seja, o uso do 
typedef aninhado ) no modelo Widget , por outro lado, eles não podem ter 
certeza de que ele nomeia um tipo, porque pode haver uma especialização de 
MyAllocList que eles ainda não viram onde MyAllocList::type se refere a 
algo diferente de um tipo. Parece loucura, mas não culpe os compiladores por 
essa possibilidade. São os humanos que produzem esse código. 
Por exemplo, alguma alma equivocada pode ter inventado algo assim: class 
Wine {…}; 
template // classe de especialização MyAllocList 
MyAllocList { // para quando T é Wine private: enum class 
WineType // veja o item 10 para informações sobre { White, Red, 
Rose }; // "classe enum" 
Tipo WineType ; // nesta classe, o tipo é … // um membro de 
dados ! 
}; 
Como você pode ver, MyAllocList::type não se refere a um tipo. Se 
Widget fosse instanciado com Wine , MyAllocList::type dentro do modelo 
Widget se referiria a um membro de dados, não a um tipo. Dentro do modelo 
Widget , então, se MyAllocList::type se refere a um tipo é honestamente 
dependente do que T é, e é por isso que os compiladores insistem em você 
afirmar que é um tipo precedendo-o com 
Digite o nome . 
 
 Ponto 9 | 75 
Se você já fez alguma metaprogramação de modelo (TMP), quase certamente 
se deparou com a necessidade de pegar parâmetros de tipo de modelo e criar 
tipos revisados a partir deles. Por exemplo, dado algum tipo T , você pode 
querer remover quaisquer const ou qualificadores de referência que T contém, 
por exemplo, você pode querer transformar const std::string& em std::string . 
Ou você pode querer adicionar const a um tipo ou transformá-lo em uma 
referência lvalue, por exemplo, transformar Widget em const Widget ou em 
Widget& . (Se você não fez nenhum TMP, isso é uma pena, porque se você 
quiser ser um programador C++ verdadeiramente eficaz, você precisa estar 
familiarizado pelo menos com o básico desta faceta do C++. Você pode ver 
exemplos de TMP em ação , incluindo os tipos de transformações de tipo que 
acabei de mencionar, nos itens 23 e 27. ) 
O C++ 11 fornece as ferramentas para realizar esses tipos de transformações 
na forma de type traits , uma variedade de modelos dentro do cabeçalho 
 . Existem dezenas de características de tipo nesse cabeçalho, e 
nem todas realizam transformações de tipo, mas aquelas que oferecem uma 
interface previsível. Dado um tipo T ao qual você gostaria de aplicar uma 
transformação, o tipo resultante é std:: transformação ::type . Por exemplo: 
std:: remove_const ::type // produz T de const T std:: 
remove_reference ::type // produz T de T& e T&& 
std:: add_lvalue_reference ::type // produz T& de T 
Os comentários apenas resumem o que essas transformações fazem, 
portanto, não os leve muito ao pé da letra. Antes de usá-los em um projeto, 
você deve procurar as especificações precisas, eu sei. 
De qualquer forma, minha motivação aqui não é fornecer um tutorial sobre 
características de tipo. Em vez disso, observe que a aplicação dessas 
transformações implica escrever “ ::type ” no final de cada uso. Se você aplicá-
los a um parâmetro de tipo dentro de um modelo (que é praticamente sempre 
como você os emprega em código real), também terá que preceder cada uso 
com type name . A razão para esses dois aumentos de velocidade sintática é 
que as características do tipo C++ 11 são implementadas como typedef s 
aninhados dentro de struct s modelados . É isso mesmo, eles são 
implementados usando a tecnologia de sinônimos de tipo que venho tentando 
convencer você a ser inferior aos modelos de alias! 
Há uma razão histórica para isso, mas vamos ignorá-la (é chato, eu prometo), 
porque o Comitê de Padronização reconheceu tardiamente que os modelos 
de alias são o melhor caminho a seguir e incluiu esses modelos no C++ 14 
para todos as transformações do tipo C++ 11. Os aliases têm um formato 
 
76 | 
comum: para cada transformação C++ 11 std:: transformação ::type , há 
um modelo de alias C++ 14 correspondente chamado std:: transformação _t . 
Exemplos esclarecerão o que quero dizer: 
std::remove_const::type // C++11: const T → T std::remove_const 
_t // equivalente em C++14 
std::remove_reference::type // C++11: T&/T&& → T 
std::remove_reference _t // equivalente em C++14 
std::add_lvalue_reference::type // C++11: T → T& 
std::add_lvalue_reference _t // equivalente em C++14 
As construções do C++ 11 permanecem válidas no C++ 14, mas não sei por 
que você deseja usá-las. Mesmo que você não tenha acesso ao C++ 14, 
escrever você mesmo os modelos de alias é uma brincadeira de criança. 
Somente recursos da linguagem C++ 11 são necessários e até mesmo 
crianças podem 
Artigo 9 
imitar um padrão, certo? Se acontecer de você ter acesso a uma cópia 
eletrônica do padrão C++ 14, é ainda mais fácil, porque tudo o que é 
necessário é copiar e colar. Aqui, vou começar: 
modelo 
usando remove_const_t = nome do tipo remove_const::type; 
modelo 
usando remove_reference_t = typename remove_reference::type; 
modelo usando add_lvalue_reference_t = typename 
add_lvalue_reference::type; Ver? Não poderia ser mais fácil. 
Coisas para lembrar 
• typedef s não suportam modelagem, mas declarações de alias sim. 
• Os modelos de alias evitam o sufixo “ ::type ” e, nos modelos, o prefixo 
“ typename ” frequentemente necessário para se referir a typedef s. 
• C++14 oferece modelos de alias para todas as transformações de 
características de tipo C++11. 
 
 Ponto 9 | 77 
Item 10: Prefiraenum s com escopo a 
enum s sem escopo. 
Como regra geral, declarar um nome entre chaves limita a visibilidade desse 
nome ao escopo definido pelas chaves. O mesmo não acontece com os 
enumeradores declarados em enum s no estilo C++ 98. Os nomes desses 
enumeradores pertencem ao escopo que contém o enum , e isso significa que 
nada mais nesse escopo pode ter o mesmo nome: 
enum Color { preto , branco , vermelho }; // preto, branco, vermelho 
são // no mesmo escopo que Color 
branco automático = falso; //erro! já branco // 
declarado neste escopo 
O fato de esses nomes de enumeradores vazarem para o escopo que contém 
sua definição de enum dá origem ao termo oficial para esse tipo de enum : 
unscoped . Suas novas contrapartes em C++ 11, enum s com escopo definido 
, não vazam nomes desta maneira: 
enumeração classe Cor {preto, branco, vermelho}; // preto, branco, 
vermelho // têm como escopo Color auto 
white = false; // tudo bem, nenhum outro 
 
78 | Artigo 10 
 // "branco" no escopo 
Cor c = branco ; //erro! nenhum enumerador nomeado 
 // "branco" está neste escopo Color c = 
Color::white ; // multar 
auto c = Cor::branco ; // também está bem (e de acordo 
// com o conselho do Item 5 ) 
Como enum s com escopo definido são declarados via “ enum class ”, às vezes 
são chamados de enum classes . 
A redução na poluição do namespace oferecida pelos enums com escopo 
definido é razão suficiente para preferi-los a seus irmãos sem escopo, mas os 
enums com escopo definido têm uma segunda vantagem convincente: seus 
enumeradores são tipificados com muito mais força. Enumeradores para enum 
s sem escopo são convertidos implicitamente em tipos integrais (e, a partir daí, 
em tipos de ponto flutuante). Caricaturas semânticas como as seguintes são, 
portanto, completamente válidas: enum Color { preto, branco, vermelho }; // enum 
sem escopo 
std::vector // func. retornando primeFactors(std::size_t x); 
//fatores primos de x 
Cor c = vermelho; 
… if (c ( c ) ( 
c ) ); //compila 
… 
} 
Pode parecer que enum s com escopo definido tenham uma terceira vantagem 
sobre enum s sem escopo, porque enum s com escopo definido podem ser 
declarados adiante, ou seja, seus nomes podem ser declarados sem 
especificar seus enumeradores: 
enum Cor; //erro! classe enum Cor; // multar 
Isto é enganoso. No C++ 11, enum s sem escopo também podem ser 
declarados posteriormente, mas somente após um pouco de trabalho 
adicional. O trabalho surge do fato de que todo enum em C++ possui um tipo 
subjacente integral que é determinado pelos compiladores. Para uma 
enumeração sem escopo como Color , enum Color { black, white, red }; 
os compiladores podem escolher char como o tipo subjacente, porque existem 
apenas três valores para representar. No entanto, alguns enum s têm um 
intervalo de valores muito maior, por exemplo: 
enum Status {bom = 0, falhou = 1, 
incompleto = 100, corrompido = 
200, 
indeterminado = 0xFFFFFFFF }; 
Aqui os valores a serem representados variam de 0 a 0xFFFFFFFF . Exceto 
em máquinas incomuns (onde um char consiste em pelo menos 32 bits), os 
 
80 | Artigo 10 
compiladores terão que selecionar um tipo integral maior que char para a 
representação dos valores de Status . 
Para fazer uso eficiente da memória, os compiladores geralmente desejam 
escolher o menor tipo subjacente para um enum que seja suficiente para 
representar seu intervalo de valores do enumerador. Em alguns casos, os 
compiladores otimizarão a velocidade em vez do tamanho e, nesse caso, eles 
podem não escolher o menor tipo subjacente permitido, mas certamente 
desejam otimizar o tamanho. Para tornar isso possível, o C++ 98 oferece 
suporte apenas a definições de enum (onde todos os enumeradores são 
listados); declarações enum não são permitidas. Isso possibilita que os 
compiladores selecionem um tipo subjacente para cada enum antes de o enum 
ser usado. 
Mas a incapacidade de declarar enum s tem desvantagens. O mais notável é 
provavelmente o aumento nas dependências de compilação. Considere 
novamente o status enum : 
enum Status {bom = 0, falhou = 1, 
incompleto = 100, corrompido = 
200, 
indeterminado = 0xFFFFFFFF }; 
Esse é o tipo de enum que provavelmente será usado em todo o sistema e, 
portanto, incluído em um arquivo de cabeçalho do qual cada parte do sistema 
depende. Se um novo valor de status for introduzido, 
enum Status {bom = 0, falhou = 1, 
incompleto = 100, corrompido = 
200, auditado = 500, 
indeterminado = 0xFFFFFFFF }; 
é provável que todo o sistema tenha que ser recompilado, mesmo que apenas 
um único subsistema – possivelmente apenas uma única função! – use o novo 
enumerador. Esse é o tipo de coisa que as pessoas odeiam . E é o tipo de 
coisa que a capacidade de declarar enum s no C++ 11 elimina. Por exemplo, 
aqui está uma declaração perfeitamente válida de um enum com escopo 
definido e uma função que usa um como parâmetro: 
status da classe enum; //declaração de encaminhamento 
void continueProcessing(Status); // uso de enum declarado por fwd O 
cabeçalho que contém essas declarações não requer recompilação se a 
definição de Status for revisada. Além disso, se Status for modificado (por 
 
 Ponto 10 | 81 
exemplo, para adicionar o enumerador auditado ), mas o comportamento de 
continueProcessing não for afetado (por exemplo, porque continueProcessing 
não usa audited ), a implementação de continueProcessing também não 
precisará ser recompilada. 
Mas se os compiladores precisam saber o tamanho de um enum antes de ser 
usado, como os enum s do C++ 11 podem escapar com declarações futuras 
quando os enum s do C++ 98 não podem? A resposta é simples: o tipo 
subjacente para um enum com escopo definido é sempre conhecido e, para 
enum sem escopo , você pode especificá-lo. 
Por padrão, o tipo subjacente para enum s com escopo definido é int 
: enum class Status; // o tipo subjacente é int 
Se o padrão não for adequado para você, você pode substituí-lo: 
status da classe enum : std::uint32_t ; // tipo subjacente para 
 // O status é std::uint32_t 
 // (de ) 
De qualquer forma, os compiladores sabem o tamanho dos enumeradores em 
um enum com escopo definido . 
Para especificar o tipo subjacente para um enum sem escopo , você faz o 
mesmo que para um enum com escopo e o resultado pode ser declarado 
posteriormente: 
enum Cor : std::uint8_t ; // fwd decl para enum sem escopo; 
 // o tipo subjacente é//std::uint8_t 
As especificações de tipo subjacentes também podem estar na definição de 
um enum : 
enum class Status : std::uint32_t {bom = 0, falhou = 1, 
incompleto = 100, corrompido = 200, auditado = 500, 
indeterminado = 0xFFFFFFFF }; 
Tendo em vista o fato de que enum s com escopo evitam a poluição do 
namespace e não são suscetíveis a conversões implícitas de tipo sem sentido, 
você pode ficar surpreso ao saber que há pelo menos uma situação em que 
enum s sem escopo podem ser úteis. Isso é quando se refere a campos dentro 
 
82 | Artigo 10 
de std::tuple s do C++ 11. Por exemplo, suponha que temos uma tupla 
contendo valores para o nome, endereço de e-mail e valor de reputação de um 
usuário em um site de rede social: 
usando UserInfo = // digite alias; veja o item 9 
std::tuple ; //reputação 
Embora os comentários indiquem o que cada campo da tupla representa, isso 
provavelmente não será muito útil quando você encontrar um código como 
este em um arquivo fonte separado: 
Informações do usuário uInfo; // objeto do tipo tupla 
… 
auto val = std::get (uInfo); //obtém o valor do campo 1 
Como programador, você tem muitas coisas para controlar. Você realmente 
deveria se lembrar de que o campo 1 corresponde ao endereço de e-mail do 
usuário? Eu acho que não. Usar uma enumeração sem escopo para associar 
nomes a números de campos evita a necessidade de: 
enum UserInfoFields { uiName, uiEmail, uiReputation }; 
Informações do usuário uInfo; // como antes 
… 
auto val = std::get(uInfo); // ah, pega o valor de 
// campo de e-mail 
O que faz isso funcionar é a conversão implícita de UserInfoFields para 
std::size_t , que é o tipo que std::get requer. 
O código correspondente com enum s com escopo definido é 
substancialmente mais detalhado: enum class UserInfoFields { 
uiName, uiEmail, uiReputation }; 
Informações do usuário uInfo; // como antes 
… 
valor automático = 
std::get(UserInfoFields::uiEmail) > (uInfo); 
 
 Ponto 10 | 83 
A verbosidade pode ser reduzida escrevendo uma função que recebe um 
enumerador e retorna seu valor std::size_t correspondente , mas é um pouco 
complicado. std::get é um modelo, e o valor que você fornece é um argumento 
de modelo (observe o uso de colchetes angulares, não parênteses), portanto, 
a função que transforma um enumerador em std::size_t deve produzir seu 
resultado durante a compilação . Como explica o Item 15 , isso significa que 
deve ser uma função constexpr . 
Na verdade, deveria ser um modelo de função constexpr , porque deveria 
funcionar com qualquer tipo de enum . E se quisermos fazer essa 
generalização, devemos generalizar o tipo de retorno também. Em vez de 
retornar std::size_t , retornaremos o tipo subjacente do enum . Está 
disponível através do traço de tipo std::underlying_type . (Veja o Item 9 para 
informações sobre características de tipo.) Finalmente, declararemos 
noexcept (veja o Item 14 ), porque sabemos que ele nunca produzirá uma 
exceção. O resultado é um modelo de função toUType que usa um 
enumerador arbitrário e pode retornar seu valor como uma constante de 
tempo de compilação: 
modelo 
constexpr nome do tipo std::underlying_type::type 
toUType(E enumerador) noexcept 
{ retornar 
static_cast::type>(enumerador); } 
Em C++ 14, toUType pode ser simplificado substituindo typename std::underly 
ing_type::type com o std::underlying_type_t mais elegante (consulte o Item 
9 ): 
modelo // C++14 
constexpr std::underlying_type _t toUType(E 
enumerador) noexcept 
{ 
return static_cast>(enumerador); } 
automático ainda mais elegante (consulte o Item 3 ) também é válido em C++ 
14: 
modelo // C++14 
constexpr automático 
toUType(E enumerador) noexcept 
{ 
 
84 | Artigo 10 
return static_cast>(enumerador); } 
Independentemente de como está escrito, toUType nos permite acessar um 
campo da tupla como 
esse: 
auto val = std::get(uInfo); Ainda é mais 
necessário escrever do que usar o enum sem escopo , mas também evita a 
poluição do namespace e conversões inadvertidas envolvendo enumeradores. 
Em muitos casos, você pode decidir que digitar alguns caracteres extras é um 
preço razoável a pagar pela capacidade de evitar as armadilhas de uma 
tecnologia enum que remonta a uma época em que o estado da arte em 
telecomunicações digitais era o modem de 2.400 bauds. . 
Coisas para lembrar 
• Enum s no estilo C++ 98 agora são conhecidos como enum s sem 
escopo. 
• Os enumeradores de enum s com escopo definido são visíveis apenas 
dentro do enum . Eles são convertidos para outros tipos apenas com 
conversão. 
• Tanto os enums com escopo quanto os sem escopo suportam a 
especificação do tipo subjacente. O tipo subjacente padrão para enum s 
com escopo definido é int . Enum s sem escopo não têm tipo subjacente 
padrão. 
• Enum s com escopo sempre podem ser declarados posteriormente. 
Enum s sem escopo podem ser declarados posteriormente apenas se 
sua declaração especificar um tipo subjacente. 
Item 11: Prefira funções excluídas às 
privadas indefinidas. 
Se você estiver fornecendo código para outros desenvolvedores e quiser evitar 
que eles chamem uma função específica, geralmente você simplesmente não 
declara a função. Nenhuma declaração de função, nenhuma função para 
chamar. Mole-mole. Mas às vezes o C++ declara funções para você, e se você 
quiser evitar que os clientes chamem essas funções, o trabalho não é mais tão 
fácil. 
 
 Ponto 10 | 85 
A situação surge apenas para as “funções-membro especiais”, ou seja, as 
funções-membro que o C++ gera automaticamente quando são necessárias. 
O item 17 discute essas funções em detalhes, mas por enquanto nos 
preocuparemos apenas com o construtor de cópia e o operador de atribuição 
de cópia. Este capítulo é amplamente dedicado às práticas comuns em C++ 
98 que foram substituídas pelas melhores práticas em C++ 11 e, em C++ 98, 
se você quiser suprimir o uso de uma função de membro, é quase sempre o 
construtor de cópia , o operador de atribuição ou ambos. 
A abordagem do C++ 98 para impedir o uso dessas funções é declará-las 
privadas e não defini-las. Por exemplo, próximo à base da hierarquia iostreams 
na Biblioteca Padrão C++ está o modelo de classe basic_ios . Todas as 
classes istream e ostream herdam (possivelmente indiretamente) desta 
classe. Copiar istreams e ostreams é indesejável, porque não está claro o que 
tais operações deveriam fazer. Um objeto istream , por exemplo, representa 
um fluxo de valores de entrada, alguns dos quais já podem ter sido lidos e 
alguns dos quais serão potencialmente lidos posteriormente. Se um istream 
fosse copiado, isso implicaria copiar todos os valores que já foram lidos, bem 
como todos os valores que seriam lidos no futuro? A maneira mais fácil de lidar 
com essas questões é defini-las como inexistentes. Proibir a cópia de streams 
faz exatamente isso. 
 
86 | 
Para tornar as classes istream e ostream não copiáveis, basic_ios é 
especificado em C++98 da seguinte forma (incluindo os comentários): 
template > 
classe básico_ios: público ios_base { 
público:… 
privado: basic_ios(const basic_ios& ); // não definido 
basic_ios& operador=(const basic_ios&); // não definido }; 
Declarar essas funções como privadas evita que os clientes as chamem. 
Deixar de defini-los deliberadamente significa que se o código que ainda tem 
acesso a eles (ou seja, funções-membro ou amigos da classe) os utilizar, a 
vinculação falhará devido à falta de definições de função. 
No C++ 11, há uma maneira melhor de atingir essencialmente o mesmo fim:use “ = delete ” para marcar o construtor de cópia e o operador de atribuição 
de cópia como funções excluídas . Aqui está a mesma parte de basic_ios 
especificada em C++ 11: 
template > 
classe básico_ios: público ios_base { público: 
… 
basic_ios(const basic_ios& ) = excluir; basic_ios& 
operador=(const basic_ios&) = excluir; 
… 
}; 
A diferença entre excluir essas funções e declará-las privadas pode parecer 
mais uma questão de moda do que qualquer outra coisa, mas há mais 
substância aqui do que você imagina. As funções excluídas não podem ser 
usadas de forma alguma, portanto, mesmo o código que está nas funções 
membro e amiga não será compilado se tentar copiar objetos basic_ios . Isso 
é uma melhoria em relação ao comportamento do C++ 98, onde tal uso 
impróprio não seria diagnosticado até o momento do link. 
Por convenção, as funções excluídas são declaradas public , não private . Há 
uma razão para isso. Quando o código do cliente tenta usar uma função 
membro, o C++ verifica a acessibilidade antes do status excluído. Quando o 
código do cliente tenta usar uma função privada excluída , alguns 
compiladores reclamam apenas sobre a função ser private , mesmo que a 
acessibilidade da função não afete realmente se ela pode ser usada. Vale a 
pena ter isso em mente ao revisar o código legado para substituir funções-
membro privadas e não definidas por funções excluídas, porque tornar as 
 
 Ponto 11 | 87 
novas funções públicas geralmente resultará em mensagens de erro 
melhores. 
Uma vantagem importante das funções excluídas é que qualquer função pode 
ser excluída, enquanto apenas as funções-membro podem ser privadas . Por 
exemplo, suponha que temos uma função não membro que recebe um 
número inteiro e retorna se é um número da sorte: bool isLucky(int number); 
A herança C do C++ significa que praticamente qualquer tipo que possa ser 
visto como vagamente numérico será convertido implicitamente em int , mas 
algumas chamadas que seriam compiladas podem não fazer sentido: 
if (isLucky('a')) … // 'a' é um número da sorte? if (isLucky(true)) … 
// é "verdadeiro"? 
if (isLucky(3.5))… // devemos truncar para 3 // antes de 
verificar a sorte? Se os números da sorte realmente devem ser inteiros, 
gostaríamos de evitar que chamadas como essas sejam compiladas. 
Uma maneira de fazer isso é criar sobrecargas excluídas para os tipos que 
queremos filtrar: 
bool éLucky(int número); //função original bool isLucky(char) = 
delete ; // rejeita caracteres bool isLucky(bool) = delete ; // 
rejeita bools 
bool isLucky (duplo) = excluir ; //rejeita duplas e 
//flutua 
(O comentário sobre a sobrecarga dupla que diz que tanto double se float s 
serão rejeitados pode surpreendê-lo, mas sua surpresa se dissipará quando 
você lembrar que, dada a escolha entre converter um float em um int ou em 
um double , C++ prefere a conversão para double . Chamar isLucky com um 
float irá, portanto, chamar a sobrecarga double , não a int . Bem, o fato de 
essa sobrecarga ser excluída impedirá a compilação da chamada. 
Embora as funções excluídas não possam ser usadas, elas fazem parte do 
seu programa. Como tal, eles são levados em consideração durante a 
resolução de sobrecargas. É por isso que, com as declarações de função 
excluídas acima, as chamadas indesejáveis para isLucky serão rejeitadas: if 
(isLucky('a')) … // erro! chamada para função excluída 
 
88 | 
Artigo 11 
if (isLucky(true))… // erro! if (isLucky(3.5f))… // 
erro! 
Outro truque que as funções excluídas podem executar (e as funções-membro 
privadas não podem) é impedir o uso de instanciações de modelo que devem 
ser desabilitadas. Por exemplo, suponha que você precise de um modelo que 
funcione com ponteiros integrados ( apesar do conselho do Capítulo 4 para 
preferir ponteiros inteligentes a ponteiros brutos): 
template void 
processPointer(T* ptr); 
Existem dois casos especiais no mundo dos ponteiros. Um deles são os 
ponteiros void* , porque não há como desreferencia-los, aumentá-los ou 
decrementá-los, etc. O outro são os ponteiros char* , porque eles 
normalmente representam ponteiros para strings no estilo C, não ponteiros 
para caracteres individuais. Esses casos especiais geralmente exigem 
tratamento especial e, no caso do modelo processPointer , vamos supor que 
o tratamento adequado seja rejeitar chamadas usando esses tipos. Ou seja, 
não deveria ser possível chamar processPointer com ponteiros void* ou char* 
. 
Isso é facilmente aplicado. Basta excluir essas instanciações: 
modelo 
void processPointer(void*) = excluir; 
modelo 
void processPointer(char*) = excluir; 
Agora, se chamar processPointer com um void* ou um char* for inválido, 
provavelmente também é inválido chamá-lo com um const void* ou um const 
char* , então essas instanciações normalmente também precisarão ser 
excluídas: 
modelo 
void processPointer(const void*) = excluir; 
modelo 
void processPointer(const char*) = excluir; 
E se você realmente quiser ser minucioso, também excluirá o const volátil 
void* e const volátil char* sobrecargas e, em seguida, você trabalhará nas 
 
 Ponto 11 | 89 
sobrecargas de ponteiros para outros tipos de caracteres padrão: std::wchar_t 
, std::char16_t e std::char32_t . 
Curiosamente, se você tiver um modelo de função dentro de uma classe e 
quiser desabilitar algumas instanciações declarando-as privadas (à 
convenção clássica do C++ 98), não poderá, porque não é possível fornecer 
uma função de membro especialização do modelo um nível de acesso 
diferente daquele do modelo principal. Se processPointer fosse um modelo de 
função membro dentro de Widget , por exemplo, e você quisesse desabilitar 
chamadas para void* ponteiros, esta seria a abordagem C++98, embora não 
fosse compilada: 
classe Widget { público: 
… 
template void 
processPointer(T* ptr) { … } 
privado: modelo // erro! void processPointer(void*); 
}; 
O problema é que as especializações de modelo devem ser escritas no escopo 
do namespace, não no escopo da classe. Este problema não surge para 
funções excluídas, porque elas não precisam de um nível de acesso diferente. 
Eles podem ser excluídos fora da classe (portanto, no escopo do namespace): 
classe Widget { público: 
… 
template void 
processPointer(T* ptr) 
{…} 
… }; 
template // ainda void Widget::processPointer(void*) = delete; 
// público, 
 // mas 
 // deletadas A verdade é que a prática do 
C++ 98 de declarar funções privadas e não defini-las foi na verdade uma 
tentativa de alcançar o que as funções deletadas do C++ 11 realmente 
realizam. Como emulação, a abordagem C++98 não é tão boa quanto a real. 
Não funciona fora das classes, nem sempre funciona dentro das classes e, 
quando funciona, pode não funcionar até o momento do link. Portanto, atenha-
se às funções excluídas. 
 
90 | 
Artigo 11 
Lembretes • 
Prefira funções excluídas às privadas 
indefinidas. 
• Qualquer função pode ser excluída, incluindo funções de não membros 
e instanciações de modelos. 
Item 12: Declarar substituição de funções 
de substituição . 
O mundo da programação orientada a objetos em C++ gira em torno de 
classes, herança e funções virtuais. Uma das ideias mais fundamentais neste 
mundo é que as implementações de funções virtuais em classes derivadas 
substituem as implementações de suas contrapartes de classe base. É 
desanimador, então, perceber quão facilmente a substituição de funções 
virtuais pode dar errado. É quase como se esta parte da linguagem tivesse 
sido concebida com a ideia de que a Lei de Murphy não deveria apenas ser 
obedecida, mastambém honrada. 
Como “substituir” parece muito com “sobrecarga”, mas não tem nenhuma 
relação, deixe-me esclarecer que a substituição de função virtual é o que torna 
possível invocar uma função de classe derivada por meio de uma interface de 
classe base: 
classe Base { public: virtual void doWork(); //função virtual da classe 
base 
… 
}; 
classe Derivado: public Base { public: virtual void doWork(); // 
substitui Base::doWork … // ("virtual" é opcional 
}; // aqui) 
std::unique_ptr upb = // cria o ponteiro da classe base 
std::make_unique(); // para objeto de classe derivada; 
// veja o item 21 para informações sobre 
… //std::make_unique 
upb->doWork(); //chama doWork através da base 
//classe ptr; classe derivada 
 // a função é invocada Para que a 
substituição ocorra, vários requisitos devem ser atendidos: 
 
 Ponto 12 | 91 
• A função da classe base deve ser virtual. 
• Os nomes das funções base e derivadas devem ser idênticos (exceto no 
caso de destruidores). 
• Os tipos de parâmetros das funções base e derivadas devem ser 
idênticos. 
• A constância das funções base e derivada deve ser idêntica. 
• Os tipos de retorno e as especificações de exceção das funções base e 
derivadas devem ser compatíveis. 
A essas restrições, que também faziam parte do C++ 98, o C++ 11 adiciona 
mais uma: 
• qualificadores de referência das funções devem ser idênticos. Os 
qualificadores de referência de função de membro são um dos recursos 
menos divulgados do C++ 11, portanto, não se surpreenda se você nunca 
ouviu falar deles. Eles tornam possível limitar o uso de uma função 
membro apenas a lvalues ou apenas a rvalues. As funções-membro não 
precisam ser virtuais para serem usadas: 
classe Widget { 
público: 
… 
void doWork() & ; // esta versão do doWork se aplica 
// somente quando *this for um lvalue 
void doWork() && ; // esta versão do doWork se aplica }; // somente 
quando *this for um rvalue 
… 
Widget makeWidget(); //função de fábrica (retorna rvalue) Widget w; 
// objeto normal (um lvalue) … 
w.doWork(); // chama Widget::doWork para lvalues // 
(ou seja, Widget::doWork &) 
makeWidget().doWork(); // chama Widget::doWork para rvalues 
// (ou seja, Widget::doWork &&) 
Falarei mais sobre funções-membro com qualificadores de referência 
posteriormente, mas por enquanto, simplesmente observe que se uma 
 
92 | Artigo 12 
função virtual em uma classe base tiver um qualificador de referência, as 
substituições de classe derivada dessa função deverão ter exatamente o 
mesmo qualificador de referência. Caso contrário, as funções declaradas 
ainda existirão na classe derivada, mas não substituirão nada na classe 
base. 
Todos esses requisitos de substituição significam que pequenos erros podem 
fazer uma grande diferença. O código que contém erros de substituição 
normalmente é válido, mas seu significado não é o que você pretendia. 
Portanto, você não pode confiar que os compiladores o notificarão se você 
fizer algo errado. Por exemplo, o código a seguir é completamente legal e, à 
primeira vista, parece razoável, mas não contém nenhuma substituição de 
função virtual – nem uma única função de classe derivada vinculada a uma 
função de classe base. Você consegue identificar o problema em cada caso, 
ou seja, por que cada função da classe derivada não substitui a função da 
classe base com o mesmo nome? 
classe Base { public: virtual 
void mf1() const; vazio virtual 
mf2(int x); vazio virtual mf3() 
&; vazio mf4() const; }; 
classe Derivado: public Base { public: 
virtual void mf1(); vazio virtual mf2 (int 
não assinado x); 
vazio virtual mf3() &&; 
vazio mf4() const; }; 
Precisa de alguma ajuda? 
• mf1 é declarado const em Base , mas não em Derived . 
• mf2 recebe um int Base , mas um unsigned int em Derivado . 
• mf3 é qualificado como lvalue em Base , mas qualificado como rvalue em 
Derived . 
• mf4 não é declarado virtual em Base . 
Você pode pensar: “Ei, na prática, essas coisas gerarão avisos do compilador, 
então não preciso me preocupar”. Talvez isso seja verdade. Mas talvez não 
seja. Com dois dos compiladores que verifiquei, o código foi aceito sem 
reclamação, e isso com todos os avisos habilitados. (Outros compiladores 
forneceram avisos sobre alguns dos problemas, mas não todos.) 
 
 Ponto 12 | 93 
Como declarar substituições de classes derivadas é importante para acertar, 
mas é fácil errar, o C++ 11 oferece uma maneira de tornar explícito que uma 
função de classe derivada deve substituir uma versão de classe base: declare-
a override . Aplicar isso ao exemplo acima produziria esta classe derivada: 
class Derivado: public Base { public: virtual void 
mf1() override ; substituição de void virtual mf2 
(unsigned int x) ; 
virtual void mf3() && substituição ; virtual 
void mf4() substituição const ; }; 
É claro que isso não será compilado, porque, quando escrito dessa maneira, 
os compiladores irão criticar todos os problemas relacionados à substituição. 
Isso é exatamente o que você deseja e é por isso que você deve declarar 
todas as suas funções de substituição override . 
O código que usa override que compila é o seguinte (assumindo que o objetivo 
é que todas as funções em Derived substituam os virtuais no Base) : 
classe Base { public: virtual 
void mf1() const; vazio virtual 
mf2(int x); vazio virtual mf3() 
&; vazio virtual mf4() const; }; 
class Derivado: public Base { public: 
virtual void mf1() const override; 
substituição de virtual void mf2 ( int x); 
virtual void mf3() & substituição; 
void mf4() substituição const; // adicionar "virtual" está OK, }; // mas não 
é necessário 
Observe que neste exemplo, parte do processo de fazer as coisas 
funcionarem envolve declarar mf4 virtual em Base . A maioria dos erros 
relacionados à substituição ocorre em classes derivadas, mas também é 
possível que algo esteja incorreto nas classes base. 
Uma política de uso de substituição em todas as substituições de classes 
derivadas pode fazer mais do que apenas permitir que os compiladores 
informem quando possíveis substituições não estão substituindo nada. 
Também pode ajudá-lo a avaliar as ramificações se você estiver pensando em 
alterar a assinatura de uma função virtual em uma classe base. Se as classes 
derivadas usam override em todos os lugares, você pode simplesmente alterar 
a assinatura, recompilar seu sistema, ver quanto dano você causou (ou seja, 
quantas classes derivadas falham na compilação) e então decidir se vale a 
 
94 | Artigo 12 
pena alterar a assinatura. Sem override , você esperaria ter testes de unidade 
abrangentes em vigor, porque, como vimos, as classes virtuais derivadas que 
deveriam substituir as funções da classe base, mas não o fazem, não 
precisam gerar diagnósticos do compilador. 
C++ sempre teve palavras-chave, mas C++ 11 introduz duas palavras-chave 
contextuais , over ride e final . 2Essas palavras-chave têm a característica de 
serem reservadas, mas apenas em determinados contextos. No caso de 
override , tem significado reservado apenas quando ocorre no final de uma 
declaração de função-membro. Isso significa que se você tiver um código 
legado que já usa o nome override , não será necessário alterá-lo para C++ 
11: 
class Warning { // potencial classe herdada do C++ 98 
público: 
… 
substituição nula (); // legal em C++98 e C++11 
… // (com o mesmo significado) 
}; 
Isso é tudo o que há a dizer sobre override , mas não é tudo o que há a dizer 
sobre os qualificadores de referência de função-membro. Prometi que daria 
mais informações sobre eles mais tarde, e agora é mais tarde. 
Se quisermos escrever uma função que aceite apenas argumentos lvalue, 
declaramos um parâmetro de referência não const lvalue:void 
doSomething(Widget & w); // aceita apenas widgets lvalue Se quisermos 
escrever uma função que aceite apenas argumentos rvalue, declaramos um 
parâmetro de referência rvalue: void doSomething(Widget && w); // aceita 
apenas rvalue Widgets Os qualificadores de referência de função membro 
simplesmente tornam possível traçar a mesma distinção para o objeto no qual 
uma função membro é invocada, ou seja, *this . É precisamente análogo ao 
const no final de uma declaração de função-membro, que indica que o objeto 
no qual a função-membro é invocada (ou seja, *this ) é 
const . 
A necessidade de funções de membros qualificadas como referência não é 
comum, mas pode surgir. Por exemplo, suponha que nossa classe Widget 
 
2Aplicar final a uma função virtual evita que a função seja substituída em classes derivadas. final também 
pode ser aplicado a uma classe, caso em que a classe está proibida de ser usada como classe base. 
 
 Ponto 12 | 95 
tenha um membro de dados std::vector e oferecemos uma função de acesso 
que dá aos clientes acesso direto a ele: 
classe Widget { público: 
usando DataType = std::vector; // veja o item 9 para … // 
informações sobre "usar" 
DataType& data() { valores de retorno; } 
… 
privado: 
Valores de DataType; 
}; 
Este não é o design mais encapsulado que já viu a luz do dia, mas deixe isso 
de lado e considere o que acontece neste código do cliente: 
Widget com; 
… auto vals1 = w.data(); // copia w.values para vals1 O tipo de retorno de 
Widget::data é uma referência lvalue (um std::vector& , para ser mais 
preciso) e como as referências lvalue são definidas como lvalues, estamos 
inicializando vals1 de um lvalue. vals1 é, portanto, uma cópia construída a 
partir de w.values , exatamente como diz o comentário. 
Agora suponha que temos uma função de fábrica que cria Widget s, 
Widget makeWidget(); e queremos inicializar uma variável com o std::vector 
dentro do Widget retornado de makeWidget : 
auto vals2 = makeWidget().data(); //copia os valores dentro do 
// Widget em vals2 
Novamente, Widgets::data retorna uma referência lvalue e, novamente, a 
referência lvalue é um lvalue, então, novamente, nosso novo objeto ( vals2 ) 
é uma cópia construída a partir de valores dentro de Widget . Desta vez, 
porém, o Widget é o objeto temporário retornado do makeWidget (ou seja, um 
rvalue), portanto, copiar o std::vector dentro dele é uma perda de tempo. Seria 
preferível movê-lo, mas, como os dados retornam uma referência lvalue, as 
regras do C++ exigem que os compiladores gerem código para uma cópia. 
(Há alguma margem de manobra para otimização por meio do que é 
conhecido como “regra como se”, mas seria tolo confiar que seus 
compiladores encontrarão uma maneira de tirar vantagem disso.) 
 
96 | Artigo 12 
O que é necessário é uma maneira de especificar que quando os dados são 
invocados em um rvalue Widget , o resultado também deve ser um rvalue. 
Usar qualificadores de referência para sobrecarregar dados para lvalue e 
rvalue Widget s torna isso possível: 
class Widget { public: usando DataType = 
std::vector; … 
Tipo de dados& dados() & // para widgets lvalue, 
{valores de retorno; } // retorna lvalor 
Tipo de dados dados() && // para widgets de valor, 
{ return std::move(valores); } // retorna rvalor 
… 
privado: 
Valores de DataType; 
}; 
Observe os diferentes tipos de retorno das sobrecargas de dados . A 
sobrecarga de referência lvalue retorna uma referência lvalue (ou seja, um 
lvalue) e a sobrecarga de referência rvalue retorna um objeto temporário (ou 
seja, um rvalue). Isso significa que o código do cliente agora se comporta 
como gostaríamos: 
auto vals1 = w.data(); // chama a sobrecarga de lvalue para 
 // Widget::dados, copiar - 
 //constrói vals1 
auto vals2 = makeWidget().data(); // chama a sobrecarga de rvalue para 
 // Widget::dados, mover - 
 //constrói vals2 
Isso certamente é bom, mas não deixe que o brilho caloroso desse final feliz 
o distraia do verdadeiro ponto deste item. Esse ponto é que sempre que você 
declarar uma função em uma classe derivada destinada a substituir uma 
função virtual em uma classe base, certifique-se de declarar essa função 
override . 
Coisas para lembrar 
• Declare a substituição das funções override . 
 
 Ponto 12 | 97 
• Os qualificadores de referência de função de membro tornam possível 
tratar objetos lvalue e rvalue ( *this ) de maneira diferente. 
 
98 | 
Item 13: Prefira const_iterator s a iterator 
s. 
const_iterator s são o equivalente STL de ponteiros para const . Eles apontam 
para valores que não podem ser modificados. A prática padrão de usar const 
sempre que possível determina que você deve usar const_iterator s sempre 
que precisar de um iterador, mas não precisa modificar o que o iterador 
aponta. 
Isso é tão verdadeiro para C++ 98 quanto para C++ 11, mas em C++ 98, 
const_iterator s tinha suporte apenas indiferente. Não foi tão fácil criá-los e, 
uma vez que você tivesse um, as maneiras de usá-lo eram limitadas. Por 
exemplo, suponha que você queira pesquisar em std::vector a primeira 
ocorrência de 1983 (o ano “C++” substituiu “C por Classes” como o nome da 
linguagem de programação) e, em seguida, insira o valor 1998 (o ano ano em 
que o primeiro padrão ISO C++ foi adotado) naquele local. Se não houver 
1983 no vetor, a inserção deverá ocorrer no final do vetor. Usando iterator s 
em C++ 98, isso foi fácil: 
valores std::vector; … 
std::vector::iterador it = 
std::find(valores.begin(),valores.end(), 1983); valores.inserir(it, 1998); 
Mas iterator s não são realmente a escolha adequada aqui, porque esse 
código nunca modifica o que um iterador aponta. Revisar o código para usar 
const_iterator s deveria ser trivial, mas em C++ 98 era tudo menos isso. Aqui 
está uma abordagem que é conceitualmente sólida, embora ainda não seja 
correta: 
typedef std::vector::iterador IterT; // digite typedef 
std::vector::const_iterator ConstIterT; //defs std::vector 
valores; … 
ConstIterT ci = 
std::find( static_cast( values.begin() ) , // lançar 
static_cast( values.end() ) , // elenco 1983); 
valores.insert( static_cast(ci) , 1998); // não deve 
 // compilar; ver 
 // abaixo 
 
 | 99 
Artigo 13 
Os typedef s não são obrigatórios, é claro, mas facilitam a escrita das 
conversões no código. (Se você está se perguntando por que estou mostrando 
typedef s em vez de seguir o conselho do Item 9 para usar declarações de 
alias, é porque este exemplo mostra o código C++ 98, e as declarações de 
alias são um recurso novo no C++ 11. ) 
As conversões na chamada para std::find estão presentes porque values é um 
contêiner não const e em C++ 98, não havia uma maneira simples de obter 
um const_iterator de um contêiner não const . As conversões não são 
estritamente necessárias, porque era possível obter const_iterator s de outras 
maneiras (por exemplo, você poderia vincular valores a uma variável de 
referência a const e , em seguida, usar essa variável no lugar de valores em 
seu código), mas uma De uma forma ou de outra, o processo de obter 
const_iterator s para elementos de um contêiner não- const envolvia alguma 
contorção. 
Depois que você tinha os const_iterator s, as coisas muitas vezes pioravam, 
porque no C++ 98, os locais para inserções (e apagamentos) podiam ser 
especificados apenas por iterator s. const_iterator s não eram aceitáveis. É 
por isso que, no código acima, converti o const_iterator (que tive tanto cuidado 
aoobter de std::find ) em um iterador : passar um const_iterator para inserir 
não seria compilado. 
Para ser honesto, o código que mostrei também pode não ser compilado, 
porque não há conversão portátil de const_iterator para iterator , nem mesmo 
com static_cast . Mesmo a marreta semântica conhecida como 
reinterpret_cast não consegue fazer o trabalho. (Essa não é uma restrição do 
C++ 98. Também é verdade no C++ 11. const_iterator s simplesmente não 
são convertidos em iterator s, não importa o quanto pareça que deveriam.) 
Existem algumas maneiras portáteis de gerar iterator é aquele ponto onde 
const_iterator s chegam, mas eles não são óbvios, não são universalmente 
aplicáveis e não valem a pena discutir neste livro. Além disso, espero que 
agora meu ponto esteja claro: const_iterator s eram tantos problemas no C++ 
98 que raramente valiam a pena. No final das contas, os desenvolvedores não 
usam const sempre que possível , eles usam sempre que prático , e em C++ 
98, const_iterator s simplesmente não eram muito práticos. 
Tudo isso mudou no C++ 11. Agora const_iterator s são fáceis de obter e usar. 
As funções-membro do contêiner cbegin e cend produzem const_iterator s, 
mesmo para contêineres não- const , e as funções-membro STL que usam 
iteradores para identificar posições (por exemplo, insert e erase ) na verdade 
 
100 | 
usam const_iterator s. Revisar o código C++ 98 original que usa iterator s para 
usar const_iterator s em C++ 11 é realmente 
trivial: 
valores std::vector; // como antes … auto it = // use cbegin 
Artigo 13 
std::find(valores. c início(),valores. c fim(), 1983); // e encerrar 
valores.inserir(it, 1998); 
Agora esse é o código usando const_iterator s que é prático! 
Praticamente a única situação em que o suporte do C++ 11 para const_iterator 
s fica um pouco aquém é quando você deseja escrever código de biblioteca 
genérico ao máximo. Esse código leva em consideração que alguns 
contêineres e estruturas de dados semelhantes a contêineres oferecem início 
e fim (mais cbegin , cend , rbegin , etc.) como funções não membros , em vez 
de membros. Este é o caso de arrays integrados, por exemplo, e também de 
algumas bibliotecas de terceiros com interfaces que consistem apenas em 
funções livres. O código maximamente genérico, portanto, usa funções não 
membros em vez de assumir a existência de versões membros. 
Por exemplo, poderíamos generalizar o código com o qual estamos 
trabalhando em um modelo findAnd Insert da seguinte maneira: 
modelo 
void findAndInsert(C& container, // no container, encontre const V& 
targetVal, // primeira ocorrência const V& insertVal) // de targetVal, then 
{ // insere insertVal 
 usando std::cbegin; // lá usando std::cend; 
auto it = std::find( cbegin (container), // não membro cbegin 
cend (container), // cend não membro 
targetVal); 
container.insert(it, insertVal); } 
Isso funciona bem em C++ 14, mas, infelizmente, não em C++ 11. Através de 
um descuido durante a padronização, o C++ 11 adicionou as funções não-
membros begin e end , mas não conseguiu adicionar cbegin , cend , rbegin , 
rend , crbegin e crend . C++ 14 corrige isso 
supervisão. 
 
 | 
 101 
Se você estiver usando C++ 11, deseja escrever código genérico ao máximo 
e nenhuma das bibliotecas que está usando fornece os modelos ausentes 
para cbegin e amigos não-membros, você pode criar suas próprias 
implementações com facilidade. Por exemplo, aqui está uma implementação 
de não-membro cbegin : 
modelo 
auto cbegin(const C& container)->decltype(std::begin(container)) { 
Artigo 13 
return std::begin(contêiner); // veja a explicação abaixo } 
Você está surpreso ao ver que o não membro cbegin não chama o membro 
cbegin , não é? Eu também. Mas siga a lógica. Este modelo cbegin aceita 
qualquer tipo de argumento que represente uma estrutura de dados 
semelhante a um contêiner, C , e acessa esse argumento por meio de seu 
parâmetro de referência a const , container . Se C for um tipo de contêiner 
convencional (por exemplo, um std::vector ), o contêiner será uma 
referência a uma versão const desse contêiner (por exemplo, um const 
std::vector& ). Invocar a função inicial não-membro (fornecida pelo C++ 
11) em um contêiner const produz um const_iterato r, e esse iterador é o que 
esse modelo retorna. A vantagem de implementar as coisas dessa maneira é 
que ele funciona mesmo para contêineres que oferecem uma função de 
membro inicial (que, para contêineres, é o que o início não-membro do C++ 
11 chama), mas não oferece um membro cbegin . Portanto, você pode usar 
este cbegin não-membro em contêineres que suportam diretamente apenas 
Begin . 
Este modelo também funciona se C for um tipo de array integrado. Nesse 
caso, container se torna uma referência a um array const . C++ 11 fornece 
uma versão especializada de início não-membro para matrizes que retorna 
um ponteiro para o primeiro elemento da matriz. Os elementos de um array 
const são const , então o ponteiro que o não-membro começa retorna para 
um array const é um ponteiro para const , e um ponteiro para const é, de fato, 
um const_iterator para um array. (Para obter informações sobre como um 
modelo pode ser especializado para matrizes integradas, consulte a discussão 
do Item 1 sobre dedução de tipo em modelos que usam parâmetros de 
referência 
para matrizes.) 
 
102 | 
Mas voltando ao básico. O objetivo deste item é encorajá-lo a usar const_itera 
tor s sempre que puder. A motivação fundamental — usar const sempre que 
for significativo — é anterior ao C++ 11, mas no C++ 98 simplesmente não era 
prático ao trabalhar com iteradores. No C++ 11, é eminentemente prático, e o 
C++ 14 organiza os poucos negócios inacabados que o C++ 11 deixou para 
trás. 
Coisas para lembrar 
• Prefira const_iterator s a iterator s. 
• Em código maximamente genérico, prefira versões não membros de 
begin , end , rbegin , etc., em vez de suas contrapartes de função 
membro. 
Artigo 13 
 
 Ponto 14 | 
 103 
Item 14: Declare funções noexcept se 
elas não emitirem exceções. 
No C++ 98, as especificações de exceção eram feras bastante 
temperamentais. Você tinha que resumir os tipos de exceção que uma função 
poderia emitir, portanto, se a implementação da função fosse modificada, a 
especificação da exceção também poderia exigir revisão. Alterar uma 
especificação de exceção pode quebrar o código do cliente, porque os 
chamadores podem depender da especificação de exceção original. Os 
compiladores normalmente não ofereciam ajuda para manter a consistência 
entre implementações de funções, especificações de exceção e código do 
cliente. A maioria dos programadores decidiu que as especificações de 
exceção do C++ 98 não valiam a pena. 
Durante o trabalho no C++ 11, surgiu um consenso de que a informação 
verdadeiramente significativa sobre o comportamento de emissão de 
exceções de uma função era se ela tinha alguma. Preto ou branco, uma 
função pode emitir uma exceção ou garante que não o fará. Essa dicotomia 
talvez ou nunca forma a base das especificações de exceção do C++ 11, que 
essencialmente substituem as do C++ 98. (As especificações de exceção no 
estilo C++ 98 permanecem válidas, mas estão obsoletas.) No C++ 11, 
noexcept incondicional é para funções que garantem que não emitirão 
exceções. 
Se uma função deve ser declarada dessa forma é uma questão de design de 
interface. O comportamento de emissão de exceções de uma função é de 
interesse fundamental para os clientes. Os chamadores podem consultar o 
status noexcept de uma função , e os resultados de tal consulta podem afetar 
a segurança ou a eficiência da exceção do código de chamada. Como tal, se 
uma função é noexcept é uma informação tão importante quanto se uma 
função membro é const . Deixar de declarar uma função noexcept quando 
vocêsabe que ela não emitirá uma exceção é simplesmente uma 
especificação de interface inadequada. 
Mas há um incentivo adicional para aplicar noexcept funções que não 
produzem exceções: permite que os compiladores gerem código-objeto 
melhor. Para entender o porquê, é útil examinar a diferença entre as maneiras 
do C++ 98 e do C++ 11 de dizer que uma função não emitirá exceções. 
Considere uma função f que promete aos chamadores que nunca receberão 
uma exceção. As duas maneiras de expressar isso são: 
 
104 | Artigo 14 
int f(int x) lance() ; // sem exceções de f: estilo C++98 int f(int x) noexcept ; // 
sem exceções de f: estilo C++ 11 Se, em tempo de execução, uma exceção sair 
de f , a especificação de exceção de f será violada. Com a especificação de 
exceção C++ 98, a pilha de chamadas é desenrolada para o chamador de f e, 
após algumas ações não relevantes aqui, a execução do programa é 
encerrada. Com a especificação de exceção C++ 11, o comportamento do 
tempo de execução é um pouco diferente: a pilha só é possivelmente 
desenrolada antes do término da execução do programa. 
A diferença entre desenrolar a pilha de chamadas e possivelmente desenrolá-
la tem um impacto surpreendentemente grande na geração de código. Em 
uma função noexcept , os otimizadores não precisam manter a pilha de tempo 
de execução em um estado desenrolável se uma exceção se propagar para 
fora da função, nem devem garantir que os objetos em uma função noexcept 
sejam destruídos na ordem inversa da construção caso uma exceção deixe a 
função . Funções com especificações de exceção “ throw() ” carecem de tal 
flexibilidade de otimização, assim como funções sem nenhuma especificação 
de exceção. A situação pode ser resumida desta forma: 
Função RetType ( params ) noexcept ; // mais otimizável 
Função RetType ( params ) throw() ; // menos otimizável 
Função RetType ( params ); // menos otimizável 
Isso por si só é motivo suficiente para declarar funções noexcept sempre que 
você souber que elas não produzirão exceções. 
Para algumas funções, o caso é ainda mais forte. As operações de 
movimentação são o exemplo proeminente. Suponha que você tenha uma 
base de código C++ 98 usando um std::vec tor . Widget s são 
adicionados ao std::vector de tempos em tempos via push_back : 
std::vector vw; … 
Widget com; … //trabalhar com w 
vw.push_back(w); //adiciona w a vw 
… 
 
 Ponto 14 | 
 105 
Suponha que esse código funcione bem e você não tenha interesse em 
modificá-lo para C++ 11. No entanto, você deseja aproveitar o fato de que a 
semântica de movimentação do C++ 11 pode melhorar o desempenho do 
código legado quando tipos habilitados para movimentação estão envolvidos. 
Portanto, você garante que o Widget tenha operações de movimentação, seja 
escrevendo-as você mesmo ou certificando-se de que as condições para sua 
geração automática sejam atendidas (ver Item 17 ). 
Quando um novo elemento é adicionado a um std::vector , é possível que o 
std::vector não tenha espaço para ele, ou seja, que o tamanho do std::vector 
seja igual à sua capacidade. Quando isso acontece, o std::vector aloca um 
novo e maior pedaço de memória para armazenar seus elementos e transfere 
os elementos do pedaço de memória existente para o novo. No C++ 98, a 
transferência era realizada copiando cada elemento da memória antiga para 
a nova memória e, em seguida, destruindo os objetos da memória antiga. Esta 
abordagem permitiu que push_back oferecesse uma forte garantia de 
segurança de exceção: se uma exceção fosse lançada durante a cópia dos 
elementos, o estado do std::vec tor permaneceria inalterado, porque nenhum 
dos elementos na memória antiga foi destruído até que todos os elementos foi 
copiado com sucesso para a nova memória. 
No C++ 11, uma otimização natural seria substituir a cópia de elementos 
std::vector por movimentos. Infelizmente, fazer isso corre o risco de violar a 
garantia de segurança de exceção de push_back . Se n elementos foram 
movidos da memória antiga e uma exceção foi lançada movendo o elemento 
n+1 , a operação push_back não poderá ser executada até a conclusão. Mas 
o std::vector original foi modificado: n de seus elementos foram movidos. 
Restaurar seu estado original pode não ser possível, porque a tentativa de 
mover cada objeto de volta para a memória original pode gerar uma exceção. 
Este é um problema sério, porque o comportamento do código legado pode 
depender da forte garantia de segurança de exceção do push_back . Portanto, 
as implementações do C++ 11 não podem substituir silenciosamente as 
operações de cópia dentro de push_back por movimentos, a menos que se 
saiba que as operações de movimento não emitirão exceções. Nesse caso, 
fazer com que os movimentos substituíssem as cópias seria seguro e o único 
efeito colateral seria a melhoria do desempenho. 
std::vector::push_back aproveita essa estratégia de “mova se puder, mas 
copie se precisar”, e não é a única função na Biblioteca Padrão que o faz. 
Outras funções que ostentam a forte garantia de segurança de exceção em 
C++98 (por exemplo, std::vec tor::reserve , s td::deque::insert , etc.) se 
 
106 | Artigo 14 
comportam da mesma maneira. Todas essas funções substituem chamadas 
para operações de cópia em C++98 por chamadas para operações de 
movimentação em C++11 somente se as operações de movimentação forem 
conhecidas por não emitirem exceções. Mas como uma função pode saber se 
uma operação de movimentação não produzirá uma exceção? A resposta é 
óbvia: ele verifica se a operação foi declarada noexcept .3 
de troca compreendem outro caso em que noexcept é particularmente 
desejável. swap é um componente chave de muitas implementações de 
algoritmos STL e também é comumente empregado em operadores de 
atribuição de cópia. Seu uso generalizado torna as otimizações que noexcept 
oferece especialmente valiosas. Curiosamente, se os swap s na Biblioteca 
Padrão são noexcept , às vezes depende de os swap s definidos pelo usuário 
serem noexcept . Por exemplo, as declarações para swap s da Biblioteca 
Padrão para arrays e std::pair são: 
modelo 
void swap(T (&a)[N], // veja T (&b)[N]) noexcept(noexcept(swap(*a, 
*b))) ; // abaixo 
modelo 
par de estruturas { 
… 
void swap(par& p) noexcept(noexcept(swap(primeiro, p.primeiro)) 
&& noexcept(swap(segundo, p.segundo))); 
… 
}; 
Essas funções são condicionalmente noexcept : se elas são noexcept 
depende se as expressões dentro das cláusulas noexcept são noexcept . 
Dados dois arrays de Widget , por exemplo, swap ping deles será noexcept 
somente se swap ping de elementos individuais nos arrays for noexcept , ou 
seja, se swap para Widget for noexcept . O autor da troca do Widget determina 
se as matrizes de ping de troca do Widget são noexcept . Isso, por sua vez, 
determina se outros swap s, como aquele para arrays de arrays de Widget , 
 
3 A verificação é normalmente bastante indireta. Funções como std::vector::push_back chamam 
std::move_if_noexcept , uma variação de std::move que converte condicionalmente para um 
rvalue (consulte o Item 23 ), dependendo se o construtor de movimento do tipo é noexcept . Por sua vez, 
std::move_if_noexcept consulta std::is_nothrow_move_constructible , e o valor dessa 
característica de tipo (consulte o Item 9 ) é definido pelos compiladores, com base no fato de o construtor de 
movimento ter uma designação noexcept (ou throw() ). 
 
 Ponto 14 | 
 107 
são noexcept . Da mesma forma, se a troca de ping em dois objetos std::pair 
contendo Widget s é noexcept depende se a troca por Widget s é noexcept . 
O fato de que a troca de estruturas de dados de nível superior geralmente 
pode ser noexcept apenas se a troca de seus constituintes de nível inferior for 
noexcept deve motivá-lo a oferecer noexcepttroque funções sempre que 
puder. 
Até agora, espero que você esteja entusiasmado com as oportunidades de 
otimização que o noexcept oferece. Infelizmente, devo moderar seu 
entusiasmo. A otimização é importante, mas a correção é mais importante. 
Observei no início deste item que noexcept faz parte da interface de uma 
função, então você deve declarar uma função noexcept apenas se estiver 
disposto a se comprometer com uma implementação noexcept no longo 
prazo. Se você declarar uma função noexcept e depois se arrepender dessa 
decisão, suas opções serão sombrias. Você pode remover noexcept da 
declaração da função (ou seja, alterar sua interface), correndo assim o risco 
de quebrar o código do cliente. Você pode alterar a implementação de forma 
que uma exceção possa escapar, mas ainda assim manter a especificação de 
exceção original (agora incorreta). Se você fizer isso, seu programa será 
encerrado se uma exceção tentar sair da função. Ou você pode resignar-se 
com a implementação existente, abandonando tudo o que despertou seu 
desejo de mudar a implementação em primeiro lugar. Nenhuma dessas 
opções é atraente. 
O fato é que a maioria das funções são neutras em relação às exceções . 
Essas funções não geram exceções, mas as funções que elas chamam 
podem emitir uma. Quando isso acontece, a função neutra em relação à 
exceção permite que a exceção emitida passe em seu caminho para um 
manipulador mais acima na cadeia de chamadas. Funções neutras em relação 
a exceções nunca são noexcept , porque podem emitir tais exceções “apenas 
de passagem”. A maioria das funções, portanto, não possui a designação 
noexcept . 
Algumas funções, no entanto, têm implementações naturais que não emitem 
exceções, e para algumas outras — principalmente as operações de 
movimentação e troca — sendo noexcept pode ter um retorno tão significativo, 
vale a pena implementá-las de uma maneira noexcept , se possível. 4Quando 
 
4As especificações de interface para operações de movimentação em contêineres na Biblioteca Padrão não 
possuem noexcept . No entanto, os implementadores têm permissão para fortalecer as especificações de 
exceção para funções da Biblioteca Padrão e, na prática, é comum que pelo menos algumas operações de 
movimentação de contêineres sejam declaradas noexcept . Essa prática exemplifica o conselho deste item. 
Tendo descoberto que é possível escrever operações de movimentação de contêineres de forma que exceções 
 
108 | Artigo 14 
você pode dizer honestamente que uma função nunca deve emitir exceções, 
você definitivamente deve declará-la noexcept . 
Observe que eu disse que algumas funções têm noexcept implementações. 
Torcer a implementação de uma função para permitir uma declaração 
noexcept é abanar o rabo. É colocar a carroça na frente dos bois. Não é ver a 
floresta pelas árvores. É… escolha sua metáfora favorita. Se uma 
implementação direta de função puder gerar exceções (por exemplo, 
invocando uma função que pode lançar), os obstáculos que você percorrerá 
para ocultar isso dos chamadores (por exemplo, capturar todas as exceções 
e substituí-las por códigos de status ou valores de retorno especiais) serão 
não apenas complicará a implementação da sua função, mas também 
complicará o código nos locais de chamada. Por exemplo, os chamadores 
podem precisar verificar códigos de status ou valores de retorno especiais. O 
custo de tempo de execução dessas complicações (por exemplo, ramificações 
extras, funções maiores que colocam mais pressão nos caches de instruções, 
etc.) pode exceder qualquer aceleração que você espera alcançar por meio 
de noexcept , além de estar sobrecarregado com código-fonte que é mais 
difícil compreender e manter. Isso seria uma engenharia de software ruim. 
Para algumas funções, ser noexcept é tão importante que é assim por padrão. 
No C++ 98, era considerado um estilo ruim permitir as funções de desalocação 
de memória (ou seja, operador excluir e operador delete[] ) e destruidores para 
emitir exceções e, no C++ 11, essa regra de estilo foi praticamente atualizada 
para uma regra de linguagem. Por padrão, todas as funções de desalocação 
de memória e todos os destruidores — definidos pelo usuário e gerados pelo 
compilador — são implicitamente noexcept . Portanto, não há necessidade de 
declará-los noexcept . (Fazer isso não prejudica nada, apenas não é 
convencional.) A única vez que um destruidor não é implicitamente noexcept 
é quando um membro de dados da classe (incluindo membros herdados e 
aqueles contidos em outros membros de dados) é de um tipo que afirma 
expressamente que seu destruidor pode emitir exceções (por exemplo, 
declara-o “ noexcept(false) ”). Esses destruidores são incomuns. Não há 
nenhum na Biblioteca Padrão, e se o destruidor de um objeto que está sendo 
usado pela Biblioteca Padrão (por exemplo, porque está em um contêiner ou 
foi passado para um algoritmo) emitir uma exceção, o comportamento do 
programa será indefinido. 
 
não sejam lançadas, os implementadores geralmente declaram as operações noexcept , mesmo que o Padrão 
não exija que eles façam isso. 
 
 Ponto 14 | 
 109 
É importante notar que alguns designers de interface de biblioteca distinguem 
funções com contratos amplos daquelas com contratos restritos . Uma função 
com um contrato amplo não tem pré-condições. Tal função pode ser chamada 
independentemente do estado do programa e não impõe restrições aos 
argumentos que os chamadores passam para ela. 5Funções com contratos 
amplos nunca apresentam comportamento indefinido. 
Funções sem contratos amplos têm contratos estreitos. Para tais funções, se 
uma pré-condição for violada, os resultados serão indefinidos. 
Se você está escrevendo uma função com um contrato amplo e sabe que ela 
não emitirá exceções, seguir o conselho deste item e declará-la noexcept é 
fácil. Para funções com contratos restritos, a situação é mais complicada. Por 
exemplo, suponha que você esteja escrevendo uma função f usando um 
parâmetro std::string e suponha que a implementação natural de f nunca 
produza uma exceção. Isso sugere que f deve ser declarado noex cept . 
Agora suponha que f tenha uma pré-condição: o comprimento de seu 
parâmetro std::string não exceda 32 caracteres. Se f fosse chamado com um 
std::string cujo comprimento fosse maior que 32, o comportamento seria 
indefinido, porque uma violação de pré-condição por definição resulta em 
comportamento indefinido. f não tem obrigação de verificar esta pré-condição, 
porque as funções podem assumir que suas pré-condições foram satisfeitas. 
(Os chamadores são responsáveis por garantir que tais suposições sejam 
válidas.) Mesmo com uma pré-condição, então, declarar f noexcept parece 
apropriado: 
void f(const std::string& s) noexcept ; // pré-condição: // 
s.length()outros . Para obter mais 
informações sobre o Safari Books Online, visite-nos online . 
Como entrar em contato conosco 
Comentários e perguntas sobre este livro podem ser endereçados à editora: 
O'Reilly Media, Inc. 
Rodovia Gravenstein 1005 Norte 
Sebastopol, CA 95472 
800-998-9938 (nos Estados Unidos ou Canadá) 
707-829-0515 (internacional ou local) 
707-829-0104 (fax) 
Para comentar ou tirar dúvidas técnicas sobre este livro, envie um e-mail para 
bookquestions@oreilly.com . 
Para obter mais informações sobre nossos livros, cursos, conferências e 
notícias, consulte nosso site em http://www.oreilly.com . 
Encontre-nos no Facebook : http://facebook.com/oreilly 
Siga-nos no Twitter: http://twitter.com/oreillymedia 
Assista-nos no YouTube: http://www.youtube.com/oreillymedia 
https://www.safaribooksonline.com/pricing/
https://www.safaribooksonline.com/pricing/
https://www.safaribooksonline.com/enterprise/
https://www.safaribooksonline.com/enterprise/
https://www.safaribooksonline.com/enterprise/
https://www.safaribooksonline.com/government/
https://www.safaribooksonline.com/government/
https://www.safaribooksonline.com/academic-public-library/
https://www.safaribooksonline.com/our-library/
https://www.safaribooksonline.com/our-library/
http://safaribooksonline.com/
http://www.oreilly.com/
http://facebook.com/oreilly
http://facebook.com/oreilly
http://twitter.com/oreillymedia
http://www.youtube.com/oreillymedia
 
 
xii | Do Editor 
Agradecimentos 
Comecei a investigar o que era então conhecido como C++0x (o nascente 
C++11) em 2009. Publiquei inúmeras perguntas no grupo de notícias da 
Usenet comp.std.c++ e sou grato aos membros dessa comunidade 
(especialmente Daniel Krügler) pelas suas postagens muito úteis. Nos anos 
mais recentes, recorri ao Stack Overflow quando tive dúvidas sobre C++ 11 e 
C++ 14, e estou igualmente grato a essa comunidade por sua ajuda na 
compreensão dos pontos mais delicados do C++ moderno. 
Em 2010, preparei materiais para um curso de treinamento em C++0x 
(publicado como Visão Geral do Novo C++ , Artima Publishing, 2010). Tanto 
esses materiais quanto meu conhecimento foram muito beneficiados pela 
verificação técnica realizada por Stephan T. Lavavej, Bernhard Merkle, 
Stanley Friesen, Leor Zolman, Hendrik Schober e Anthony Williams. Sem a 
ajuda deles, eu provavelmente nunca estaria em condições de empreender 
Effective Modern C++ . Esse título, aliás, foi sugerido ou endossado por vários 
leitores que responderam à minha postagem no blog de 18 de fevereiro de 
2014, “Ajude-me a nomear meu livro”. e Andrei Alexandrescu (autor de 
Modern C++ Design , Addison-Wesley, 2001) teve a gentileza de abençoar o 
título por não explorar seu território terminológico. 
Não consigo identificar as origens de todas as informações deste livro, mas 
algumas fontes tiveram um impacto relativamente direto. O uso do Item 4 de 
um modelo indefinido para extrair informações de tipo dos compiladores foi 
sugerido por Stephan T. Lavavej, e Matt P. Dziubinski chamou minha atenção 
para Boost.TypeIndex. No Item 5 , o exemplo 
unsignedstd::vector::size_type é do artigo de Andrey Karpov de 28 de 
fevereiro de 2010, “ De que maneira o padrão C++0x pode ajudá-lo a eliminar 
erros de 64 bits . ”O std::pair / std::pair 
no mesmo item é da palestra de Stephan T. Lavavej no Going Native 2012 , 
“STL11: Magic && Secrets”. O item 6 foi inspirado no artigo de Herb Sutter de 
12 de agosto de 2013, “ GotW #94 Solution: AAA Style (Almost Always Auto) 
http://stackoverflow.com/
http://stackoverflow.com/
http://www.artima.com/shop/overview_of_the_new_cpp
http://scottmeyers.blogspot.com/2014/02/help-me-name-my-book.html
http://scottmeyers.blogspot.com/2014/02/help-me-name-my-book.html
http://scottmeyers.blogspot.com/2014/02/help-me-name-my-book.html
http://erdani.com/index.php/books/modern-c-design/
http://erdani.com/index.php/books/modern-c-design/
http://www.viva64.com/en/b/0060/
http://www.viva64.com/en/b/0060/
http://www.viva64.com/en/b/0060/
http://www.viva64.com/en/b/0060/
http://channel9.msdn.com/Events/GoingNative/GoingNative-2012/STL11-Magic-Secrets
http://channel9.msdn.com/Events/GoingNative/GoingNative-2012/STL11-Magic-Secrets
http://herbsutter.com/2013/08/12/gotw-94-solution-aaa-style-almost-always-auto/
http://herbsutter.com/2013/08/12/gotw-94-solution-aaa-style-almost-always-auto/
 
xv 
. ” O item 9 foi motivado pela postagem do blog de Martinho Fernandes de 27 
de maio de 2012, “ Tratamento de nomes de dependentes .” O exemplo do 
Item 12 que demonstra a sobrecarga nos qualificadores de referência é 
baseado na resposta de Casey à pergunta: “ Qual é um caso de uso para 
sobrecarregar funções-membro em qualificadores de referência? ”, postado 
no Stack Overflow em 14 de janeiro de 2014. Meu tratamento do Item 15 sobre 
o suporte expandido do C++ 14 para funções constexpr incorpora informações 
que recebi de Rein Halbersma. O item 16 é baseado na apresentação C++ e 
Beyond 2012 de Herb Sutter , “Você não conhece const e mutable .” O 
conselho do item 18 para que as funções de fábrica retornem std::unique_ptr 
s é baseado no artigo de Herb Sutter de 30 de maio de 2013, “ GotW# 90 
Solution: Factories . ” No item 19 , fastLoadWidget é derivado da apresentação 
Going Native 2013 de Herb Sutter , “ My Favorite C++ 10-Liner ”. Meu 
tratamento de std::unique_ptr e tipos incompletos no Item 22 baseia-se no 
artigo de Herb Sutter de 27 de novembro de 2011, “ GotW #100: Compilation 
Firewalls ” bem como na resposta de Howard Hinnant de 22 de maio de 2011 
à pergunta Stack Overflow, “ Is std:: unique_ptr necessário para saber a 
definição completa de T? ” O exemplo de adição de Matrix no Item 25 é 
baseado nos escritos de David Abrahams. Comentário de JoeArgonne de 8 
de dezembro de 2012 na postagem do blog de 30 de novembro de 2012, 
“Outra alternativa à captura de movimento lambda,” foi a fonte da abordagem 
baseada em std::bind do Item 32 para emular a captura de inicialização em 
C++ 11. A explicação do item 37 sobre o problema com uma separação 
implícita no destruidor de std::thread foi retirada de Hans-J. Artigo de Boehm 
de 4 de dezembro de 2008, “ N2802: Um apelo para reconsiderar o 
desanexamento na destruição para objetos de thread . ” O item 41 foi 
originalmente motivado pelas discussões da postagem do blog de David 
Abrahams de 15 de agosto de 2009, “ Quer velocidade? Passe por valor. ” A 
ideia de que os tipos somente de movimento merecem tratamento especial se 
deve a Matthew Fioravante, enquanto a análise da cópia baseada em 
atribuições decorre de comentários de Howard Hinnant. No Item 42 , Stephan 
T. Lavavej e Howard Hinnant me ajudaram a compreender os perfis relativos 
de desempenho das funções de colocação e inserção, e Michael Winterberg 
chamou minha atenção para como a colocação pode levar a vazamentos de 
recursos. (Michael credita a apresentação Going Native 2013 de Sean Parent 
, “ C++ Seasoning ” , como sua fonte). Michael também apontou como as 
funções de posicionamento usam inicialização direta, enquanto as funções de 
inserção usam inicialização de cópia. 
Revisar os rascunhos de um livro técnico é uma tarefa exigente, demorada e 
extremamente crítica, e tenho sorte de que tantas pessoas se dispuseram a 
fazer isso por mim. Rascunhos completos ou parciais do Effective Modern C++ 
http://herbsutter.com/2013/08/12/gotw-94-solution-aaa-style-almost-always-auto/
http://flamingdangerzone.com/cxx11/2012/05/27/dependent-names-bliss.html
http://flamingdangerzone.com/cxx11/2012/05/27/dependent-names-bliss.html
http://stackoverflow.com/questions/21052377/whats-a-use-case-for-overloading-member-functions-on-reference-qualifiers
http://stackoverflow.com/questions/21052377/whats-a-use-case-for-overloading-member-functions-on-reference-qualifiers
http://stackoverflow.com/questions/21052377/whats-a-use-case-for-overloading-member-functions-on-reference-qualifiersem um pedaço aleatório de memória que você converteu em um 
std::vector . O resultado da conversão é indefinido, portanto não há garantias comportamentais para o 
programa que contém a conversão. 
 
110 | Artigo 14 
ao encerramento do programa. Por esta razão, os projetistas de bibliotecas 
que distinguem contratos amplos de contratos restritos geralmente não 
reservam nada, exceto para funções com contratos amplos. 
Como ponto final, deixe-me elaborar minha observação anterior de que os 
compiladores normalmente não oferecem ajuda na identificação de 
inconsistências entre implementações de funções e suas especificações de 
exceção. Considere este código, que é perfeitamente legal: 
configuração vazia(); // funções definidas em outro lugar void 
cleanup(); 
void doWork() noexcept 
{ 
configurar(); // configura o trabalho a ser feito … // faz o 
trabalho real 
limpar(); //realiza ações de limpeza 
} 
Aqui, doWork é declarado noexcept , embora chame as funções não- noexcept 
setup e cleanup . Isso parece contraditório, mas pode ser aquele documento 
de configuração e limpeza que eles nunca emitem exceções, mesmo que não 
sejam declarados dessa forma. Poderia haver boas razões para suas 
declarações não- noexcept . Por exemplo, eles podem fazer parte de uma 
biblioteca escrita em C. (Mesmo funções da Biblioteca Padrão C que foram 
movidas para o namespace std não possuem especificações de exceção, por 
exemplo, std::strlen não é declarado noexcept .) Ou eles poderiam fazer parte 
de uma biblioteca C++98 que decidiu não usar especificações de exceção 
C++98 e ainda não foi revisada para C++11. 
Como existem razões legítimas para que as funções noexcept dependam de 
código sem a garantia noexcept , o C++ permite tal código, e os compiladores 
geralmente não emitem avisos sobre isso. 
Coisas para lembrar 
• noexcept faz parte da interface de uma função e isso significa que os 
chamadores podem depender dela. 
• noexcept são mais otimizáveis do que as funções não- noexcept . 
 
 Ponto 14 | 
 111 
• noexcept é particularmente valioso para operações de movimentação, 
troca , memória 
funções de desalocação e destruidores. 
• A maioria das funções são neutras em relação a exceções, em vez de 
noexcept . 
 
112 | Artigo 15 
Item 15: Use constexpr sempre que 
possível. 
Se houvesse um prêmio para a nova palavra mais confusa em C++ 11, 
constexpr provavelmente ganharia. Quando aplicado a objetos, é 
essencialmente uma forma reforçada de const , mas quando aplicado a 
funções, tem um significado bem diferente. Vale a pena eliminar a confusão, 
porque quando constexpr corresponde ao que você deseja expressar, você 
definitivamente deseja usá-lo. 
Conceitualmente, constexpr indica um valor que não é apenas constante, mas 
também conhecido durante a compilação. O conceito é apenas parte da 
história, porque quando constexpr é aplicado a funções, as coisas têm mais 
nuances do que isso sugere. Para que eu não estrague o final surpreendente, 
por enquanto direi apenas que você não pode presumir que os resultados das 
funções constexpr são const , nem pode presumir que seus valores são 
conhecidos durante a compilação. Talvez o mais intrigante seja o fato de que 
essas coisas são características . É bom que as funções constexpr não 
produzam resultados const ou conhecidos durante a compilação! 
Mas vamos começar com objetos constexpr . Esses objetos são, de fato, const 
e, de fato, possuem valores que são conhecidos em tempo de compilação. 
(Tecnicamente, seus valores são determinados durante a tradução , e a 
tradução consiste não apenas em compilação, mas também em vinculação. A 
menos que você escreva compiladores ou vinculadores para C++, entretanto, 
isso não terá efeito sobre você, então você pode programar alegremente como 
se os valores de objetos constexpr foram determinados durante a 
compilação.) 
Os valores conhecidos durante a compilação são privilegiados. Eles podem 
ser colocados em memória somente leitura, por exemplo, e, especialmente 
para desenvolvedores de sistemas embarcados, esta pode ser uma 
característica de considerável importância. De aplicabilidade mais ampla é 
que valores integrais que são constantes e conhecidos durante a compilação 
podem ser usados em contextos onde C++ requer uma expressão constante 
integral . Esses contextos incluem especificação de tamanhos de array, 
argumentos de modelo integrais (incluindo comprimentos de objetos std::array 
), valores de enumerador, especificadores de alinhamento e muito mais. Se 
você quiser usar uma variável para esse tipo de coisa, certamente vai querer 
declará-la constexpr , porque então os compiladores garantirão que ela tenha 
um valor em tempo de compilação: 
 
 Ponto 15 | 
 113 
int tamanho; // variável não constexpr … 
constexpr auto arraySize1 = sz; //erro! o valor de sz não 
// conhecido na compilação std::array data1; //erro! mesmo 
problema constexpr auto arraySize2 = 10; // tudo bem, 10 é um 
 // constante em tempo de compilação 
std::array dados2; // bem, arraySize2 
// é constexpr 
Observe que const não oferece a mesma garantia que constexpr , porque os 
objetos const não precisam ser inicializados com valores conhecidos durante 
a compilação: int sz; // como antes … 
const auto arraySize = sz; // tudo bem, arraySize é 
// const cópia de sz 
std::array dados; //erro! valor de arraySize 
//não conhecido na compilação 
Simplificando, todos os objetos constexpr são const , mas nem todos os 
objetos const são constexpr . Se você deseja que os compiladores garantam 
que uma variável tenha um valor que possa ser usado em contextos que 
exigem constantes de tempo de compilação, a ferramenta a ser alcançada é 
con stexpr , não const . 
Os cenários de uso para objetos constexpr tornam-se mais interessantes 
quando funções constexpr estão envolvidas. Tais funções produzem 
constantes de tempo de compilação quando são chamadas com constantes 
de tempo de compilação . Se eles forem chamados com valores 
desconhecidos até o tempo de execução, eles produzirão valores de tempo 
de execução. Pode parecer que você não sabe o que eles farão, mas essa é 
a maneira errada de pensar sobre isso. A maneira correta de ver isso é esta: 
• constexpr podem ser usadas em contextos que exigem constantes de 
tempo de compilação. Se os valores dos argumentos que você passa para 
uma função constexpr em tal contexto forem conhecidos durante a 
compilação, o resultado será calculado durante a compilação. Se algum 
dos valores dos argumentos não for conhecido durante a compilação, seu 
código será rejeitado. 
 
114 | Artigo 15 
• Quando uma função constexpr é chamada com um ou mais valores que 
não são conhecidos durante a compilação, ela atua como uma função 
normal, computando seu resultado em tempo de execução. Isso significa 
que você não precisa de duas funções para executar a mesma operação, 
uma para constantes de tempo de compilação e outra para todos os outros 
valores. A função constexpr faz tudo. 
Suponha que precisamos de uma estrutura de dados para armazenar os 
resultados de um experimento que possa ser executado de diversas maneiras. 
Por exemplo, o nível de iluminação pode ser alto, baixo ou desligado durante 
o experimento, assim como a velocidade do ventilador e a temperatura, etc. 
Se houver n condições ambientais relevantes para o experimento, cada uma 
das quais terá três estados possíveis , o número de combinações é 3 n . 
Armazenar resultados experimentais para todas as combinações de 
condições requer, portanto, uma estrutura de dados com espaço suficiente 
para valores de 3 n . Supondo que cada resultado seja um int e que n seja 
conhecido (ou possa ser calculado) durante acompilação, um std::array 
poderia ser uma escolha razoável de estrutura de dados. Mas precisaríamos 
de uma maneira de calcular 3 n durante a compilação. A Biblioteca Padrão C++ 
fornece std::pow , que é a funcionalidade matemática de que precisamos, 
mas, para nossos propósitos, há dois problemas com ela. Primeiro, std::pow 
funciona em tipos de ponto flutuante e precisamos de um resultado integral. 
Segundo, std::pow não é constexpr (ou seja, não há garantia de retornar um 
resultado em tempo de compilação quando chamado com valores em tempo 
de compilação), portanto não podemos usá-lo para especificar o tamanho de 
um std::array . 
Felizmente, podemos escrever o poder de que precisamos. Mostrarei como 
fazer isso daqui a pouco, mas primeiro vamos ver como isso pode ser 
declarado e usado: 
constexpr // pow é uma função constexpr int pow(int 
base, int exp) noexcept // que nunca lança 
{ 
… // impl está abaixo 
} constexpr auto numConds = 5; //# de condições 
std::array resultados; //resultados tem 
//3^numConds 
 //elementos 
 
 Ponto 15 | 
 115 
Lembre-se de que constexpr na frente de pow não diz que pow retorna um 
valor const , ele diz que se base e exp são constantes em tempo de 
compilação, o resultado de pow pode ser usado como uma constante em 
tempo de compilação. Se base e/ou exp não forem constantes em tempo de 
compilação, o resultado de pow será calculado em tempo de execução. Isso 
significa que pow não só pode ser chamado para fazer coisas como calcular 
em tempo de compilação o tamanho de um std::array , mas também pode ser 
chamado em contextos de tempo de execução como este: 
base automática = readFromDB("base"); // obtém esses valores auto 
exp = readFromDB("exponent"); // em tempo de execução 
auto baseToExp = pow(base, exp) ; //chama a função pow 
// em tempo de execução 
Como as funções constexpr devem ser capazes de retornar resultados em 
tempo de compilação quando chamadas com valores em tempo de 
compilação, restrições são impostas às suas implementações. As restrições 
diferem entre C++11 e C++14. 
No C++ 11, as funções constexpr não podem conter mais do que uma única 
instrução executável: um return . Isso parece mais limitante do que é, porque 
dois truques podem ser usados para estender a expressividade das funções 
constexpr além do que você imagina. Primeiro, o operador condicional “ ?: ” 
pode ser usado no lugar de instruções if-else e, segundo, a recursão pode 
ser usada em vez de loops. pow pode, portanto, ser implementado assim: 
constexpr int pow(int base, int exp) noexcept 
{ 
return (exp == 0 ? 1 : base * pow(base, exp - 1)); } 
Isso funciona, mas é difícil imaginar que alguém, exceto um programador 
funcional radical, consideraria isso bonito. No C++14, as restrições nas 
funções constexpr são substancialmente mais flexíveis, portanto a seguinte 
implementação se torna possível: 
constexpr int pow(int base, int exp) noexcept // C++14 
{ 
resultado automático = 1; 
for (int i = 0; i (mid.xValue() * 10) poderia ser usado para instanciar um modelo ou para 
especificar um valor de enumerador. 
 
118 | Artigo 15 
// retorna a reflexão de p em relação à origem (C++14) constexpr Point 
reflexão(const Point& p) noexcept 
{ 
Resultado pontual; //cria ponto não-const 
resultado. setX (-p.xValue()); // define o resultado dos valores x e y . 
setY (-p.yValue()); 
resultado de retorno; // retorna uma cópia dele } 
O código do cliente poderia ser assim: 
constexpr Ponto p1(9,4, 27,7); // como acima 
ponto constexpr p2(28,8, 5,3); constexpr 
auto mid = ponto médio (p1, p2); 
constexpr auto reflectedMid = // o valor de reflectMid é reflexão(mid); // 
(-19,1 -16,5) e conhecido // durante a 
compilação 
O conselho deste item é usar constexpr sempre que possível,e agora espero 
que esteja claro o porquê: tanto objetos constexpr quanto funções constexpr 
podem ser empregados em uma gama mais ampla de contextos do que 
objetos e funções não- constexpr . Ao usar cons stexpr sempre que possível, 
você maximiza a variedade de situações nas quais seus objetos e funções 
podem ser usados. 
É importante observar que constexpr faz parte da interface de um objeto ou 
função. constexpr proclama “Posso ser usado em um contexto onde C++ 
requer uma expressão constante”. Se você declarar um objeto ou função 
constexpr , os clientes poderão usá-lo em tais contextos. Se mais tarde você 
decidir que o uso de constexpr foi um erro e removê-lo, poderá fazer com que 
quantidades arbitrariamente grandes de código do cliente parem de ser 
compiladas. (O simples ato de adicionar E/S a uma função para depuração ou 
ajuste de desempenho pode levar a esse problema, porque instruções de E/S 
geralmente não são permitidas em funções constexpr .) Parte de “sempre que 
possível” em “Use constexpr sempre que possível” . ”é a sua disposição de 
assumir um compromisso de longo prazo com as restrições que impõe aos 
objetos e funções aos quais você o aplica. 
Coisas para lembrar 
 
 Ponto 15 | 
 119 
• constexpr são const e são inicializados com valores conhecidos durante 
a compilação. 
• constexpr podem produzir resultados em tempo de compilação quando 
chamadas com argumentos cujos valores são conhecidos durante a 
compilação. 
• constexpr podem ser usados em uma gama mais ampla de contextos 
do que objetos e funções não constexpr . 
• constexpr faz parte da interface de um objeto ou função. 
Item 16: Torne as funções de membro 
const seguras para threads. 
Se estivermos trabalhando em um domínio matemático, poderemos achar 
conveniente ter uma classe representando polinômios. Dentro desta classe, 
provavelmente seria útil ter uma função para calcular a(s) raiz(es) de um 
polinômio, ou seja, valores onde o polinômio é avaliado como zero. Tal função 
não modificaria o polinômio, então seria natural declará-la const : 
class Polynomial { public: using RootsType = // estrutura de dados 
contendo valores std::vector; // onde o polinômio é avaliado 
como zero … // (veja o Item 9 para informações sobre "usar") 
RootsType Roots() const; 
… 
}; 
Calcular as raízes de um polinômio pode ser caro, então não queremos fazê-
lo se não for necessário. E se tivermos que fazer isso, certamente não 
queremos fazer isso mais de uma vez. Portanto, armazenaremos em cache 
a(s) raiz(es) do polinômio se tivermos que calcular 
 
120 | Artigo 16 
e implementaremos raízes para retornar o valor armazenado em cache. Aqui 
está a abordagem básica: 
classe Polinomial { público: usando 
RootsType = std::vector; 
RootsType root() const 
{ 
if (!rootsAreValid) { // se o cache não for válido 
… // calcula raízes, 
 // armazena-os em rootVals 
raízesAreValid = verdadeiro; } 
retornar rootVals; } 
privado: mutável boolrootsAreValid{false}; // veja o item 7 para 
informações mutable RootsType rootVals{}; // nos inicializadores }; 
Conceitualmente, o root não altera o objeto Polinomial no qual opera, mas, 
como parte de sua atividade de cache, pode ser necessário modificar rootVals 
erootsAreValid . Esse é um caso de uso clássico para mutable e é por isso 
que faz parte das declarações desses membros de dados. 
Imagine agora que dois threads chamam simultaneamente raízes em um 
objeto Polinomial : 
Polinômio p; 
… 
/*----- Tópico 1 ----- */ /*------- Tópico 2 ------- */ 
autorootsOfP = p.roots() ; auto valsGivingZero = p.roots() ; Este código do 
cliente é perfeitamente razoável. Roots é uma função membro const e isso 
significa que representa uma operação de leitura. Fazer com que vários 
threads executem uma operação de leitura sem sincronização é seguro. Pelo 
menos deveria ser. Nesse caso, não é, porque dentro de root , um ou ambos 
os threads podem tentar modificar os membros de dados rootAreValid e 
rootVals . Isso significa que esse código pode ter threads diferentes lendo e 
gravando na mesma memória sem sincronização, e essa é a definição de uma 
corrida de dados. Este código tem comportamento indefinido. 
 
 Ponto 16 | 121 
O problema é queroots é declarado const , mas não é thread-safe. A 
declaração const é tão correta em C++ 11 quanto seria em C++ 98 (recuperar 
as raízes de um polinômio não altera o valor do polinômio), então o que requer 
retificação é a falta de segurança do thread. 
A maneira mais fácil de resolver o problema é a usual: empregar um mutex : 
classe Polinomial { público: usando 
RootsType = std::vector; 
RootsType root() const 
{ 
 std::lock_guard g(m); // bloqueia mutex if 
(!rootsAreValid) { // se o cache não for válido … // calcula/armazena 
raízes 
raízesAreValid = verdadeiro; } 
retornar rootVals; } // desbloqueia mutex 
privado: 
 mutável std::mutex m; 
mutável boolrootsAreValid{ false }; 
RootsType mutável rootVals{}; }; 
O std::mutex m é declarado mutable , porque bloqueá-lo e desbloqueá-lo não 
são funções-membro const e, dentro das raízes (uma função-membro const ), 
m seria considerado um objeto const . 
Vale a pena notar que, como std::mutex é um tipo somente de movimentação 
(ou seja, um tipo que pode ser movido, mas não copiado), um efeito colateral 
de adicionar m a Polynomial é que Polynomial perde a capacidade de ser 
copiado. Ele ainda pode ser movido, no entanto. 
Em algumas situações, um mutex é um exagero. Por exemplo, se tudo o que 
você está fazendo é contar quantas vezes uma função-membro é chamada, 
um contador std::atomic (ou seja, aquele em que outras threads têm a garantia 
de ver suas operações ocorrerem indivisivelmente - consulte o Item 40 ) 
geralmente será um maneira menos dispendiosa de ir. (Se é realmente mais 
barato depende do hardware em que você está executando e da 
implementação de mutexes em sua biblioteca padrão.) Veja como você pode 
empregar um std::atomic para contar chamadas: 
 
122 | Artigo 16 
class Point { // ponto 2D public:… 
double distanceFromOrigin() const noexcept // veja o item 14 { // para 
noexcept ++contagem de chamadas; // incremento 
atômico 
retornar std::sqrt((x * x) + (y * y)); } 
privado: mutável std::atomic 
callCount{ 0 }; 
duplo x, y; }; 
Assim como std::mutex es, std::atomic s são tipos somente de movimentação, 
portanto, a existência da chamada Count em Point significa que Point também 
é somente de movimentação. 
Como as operações em variáveis std::atomic costumam ser mais baratas do 
que a aquisição e liberação de mutex, você pode ficar tentado a confiar mais 
em std::atomic s do que deveria. Por exemplo, em uma classe que armazena 
em cache um int caro para calcular , você pode tentar usar um par de variáveis 
std::atomic em vez de um mutex: 
widget de 
classe { 
público:… 
int magicValue() const 
{ 
if (cacheValid) retornar cachedValue; 
outro { 
auto val1 = caroComputação1(); auto val2 = 
caroComputação2(); 
 cachedValue = val1 + val2; // ah, ah, parte 1 cacheValid = 
verdadeiro; // ah, ah, parte 2 
retornar valor em cache; 
} 
} privado: 
mutável 
std::atomic
 
 Ponto 16 | 123 
 
cacheValid{ 
false }; 
mutável 
std::atomic
 
cachedValu
e; }; 
Isso funcionará, mas às vezes funcionará muito mais do que deveria. 
Considerar: 
• Um thread chama Widget::magicValue , vê cacheValid como false , 
executa os dois cálculos caros e atribui sua soma a cachedValue . 
• Nesse ponto, um segundo thread chama Widget::magicValue , também vê 
cacheValid como false e, portanto, realiza os mesmos cálculos caros que 
o primeiro thread acabou de concluir. (Este “segundo tópico” pode na 
verdade ser vários outros tópicos.) 
Tal comportamento é contrário ao objetivo do cache. Invertera ordem das 
atribuições para cachedValue e CacheValid elimina esse problema, mas o 
resultado é ainda pior: 
widget de 
classe { 
público:… 
int magicValue() const 
{ 
if (cacheValid) retornar cachedValue; 
outro { 
auto val1 = caroComputação1(); auto val2 = 
caroComputação2(); 
 cacheValid = verdadeiro; // ah, ah, parte 1 retornar 
valor em cache = val1 + val2; // ah, ah, parte 2 
 
124 | Artigo 16 
} 
} 
… 
}; 
Imagine que cacheValid seja false e então: 
• Um thread chama Widget::magicValue e é executado até o ponto onde 
cacheValid está definido como true . 
• Nesse momento, um segundo thread chama Widget::magicValue e 
verifica o cache 
Válido . Vendo isso true , o thread retorna cachedValue , mesmo que o 
primeiro thread ainda não tenha feito uma atribuição a ele. O valor 
retornado está, portanto, incorreto. 
Há uma lição aqui. Para uma única variável ou local de memória que requer 
sincronização, o uso de um std::atomic é adequado, mas quando você chegar 
a duas ou mais variáveis ou locais de memória que requerem manipulação 
como uma unidade, você deve usar um mutex. Para Widget::magicValue , 
ficaria assim: 
widget de 
classe { 
público:… 
int magicValue() const 
{ 
 std::lock_guard guard(m); //bloqueia m 
if (cacheValid) retornar cachedValue; 
outro { 
auto val1 = caroComputação1(); auto val2 = 
caroComputação2(); cachedValue = val1 + 
val2; cacheValid = verdadeiro; retornar valor 
em cache; 
} 
} //desbloqueia m 
… 
 
 Ponto 16 | 125 
privado: mutável 
std::mutex m; 
mutável int cachedValue; // não é mais mutável atômico bool 
cacheValid{ false }; // não é mais atômico }; 
Agora, este item se baseia na suposição de que vários threads podem 
executar simultaneamente uma função de membro const em um objeto. Se 
você estiver escrevendo uma função-membro const onde esse não é o caso - 
onde você pode garantir que nunca haverá mais de um thread executando 
essa função-membro em um objeto - a segurança do thread da função é 
irrelevante. Por exemplo, não é importante se as funções-membro de classes 
projetadas para uso exclusivamente de thread único são thread-safe. Nesses 
casos, você pode evitar os custos associados a mutexes e std::atomic s, bem 
como o efeito colateral de renderizar as classes que os contêm somente para 
movimentação. No entanto, esses cenários sem threading são cada vez mais 
incomuns e provavelmente se tornarão ainda mais raros. A aposta segura é 
que as funções-membro const estarão sujeitas à execução simultânea e é por 
isso que você deve garantir que suas funções-membro const sejam thread-
safe. 
 
Coisas para lembrar 
• Torne as funções de membro const seguras para threads, a menos que 
você tenha certeza de que elas nunca serão usadas em um contexto 
simultâneo. 
• O uso de variáveis std::atomic pode oferecer melhor desempenho do que 
um mutex, mas são adequadas para manipulação de apenas uma única 
variável ou local de memória. 
Item 17: Compreenda a geração de 
função de membro especial. 
No jargão oficial do C++, as funções-membro especiais são aquelas que o 
C++ deseja gerar por conta própria. C++ 98 tem quatro dessas funções: o 
construtor padrão, o destruidor, o construtor de cópia e o operador de 
atribuição de cópia. Há letras miúdas, é claro. Essas funções são geradas 
apenas se forem necessárias, ou seja, se algum código as utilizar sem que 
sejam expressamente declaradas na classe. Um construtor padrão é gerado 
somente se a classe não declarar nenhum construtor. (Isso evita que os 
 
126 | Artigo 16 
compiladores criem um construtor padrão para uma classe onde você 
especificou que os argumentos do construtor são necessários.) As funções de 
membro especiais geradas são implicitamente public e inline e não são 
virtuais, a menos que a função em questão seja um destruidor em um derivado 
classe herdando de uma classe base com um destruidor virtual. Nesse caso, 
o destruidor gerado pelo compilador para a classe derivada também é virtual. 
Mas você já sabe dessas coisas. Sim, sim, história antiga: Mesopotâmia, 
dinastia Shang, FORTRAN, C++98. Mas os tempos mudaram e as regras para 
geração de funções-membro especiais em C++ mudaram com eles. É 
importante estar ciente das novas regras, porque poucas coisas são tão 
centrais para uma programação C++ eficaz quanto saber quando os 
compiladores inserem silenciosamente funções-membro em suas classes. A 
partir do C++ 11, o clube de funções de membros especiais tem mais dois 
membros: o construtor de movimento e o operador de atribuição de 
movimento. Suas assinaturas são: 
classe Widget { público: 
… 
 Widget(Widget&& rhs); //mover construtor 
 Widget& operador=(Widget&& rhs); //mover operador de atribuição 
… 
}; 
 
 Ponto 17 | 127 
As regras que regem a sua geração e comportamento são análogas às dos 
seus irmãos copiadores. As operações de movimentação são geradas 
somente se forem necessárias e, se forem geradas, executam “movimentos 
entre membros” nos membros de dados não estáticos da classe. Isso significa 
que o construtor de movimentação move constrói cada membro de dados não 
estáticos da classe a partir do membro correspondente de seu parâmetro rhs 
e o operador de atribuição de movimentação move atribui cada membro de 
dados não estáticos a partir de seu parâmetro. O construtor de movimentação 
também constrói suas partes da classe base (se houver), e o operador de 
atribuição de movimentação atribui suas partes da classe base. Agora, 
quando me refiro a uma operação de movimentação, construção de 
movimentação ou atribuição de movimentação de um membro de dados ou 
classe base, não há garantia de que uma movimentação realmente ocorrerá. 
“Movimentos de membros” são, na realidade, mais parecidos com solicitações 
de movimentação de membros , porque os tipos que não são habilitados para 
movimentação (ou seja, que não oferecem suporte especial para operações 
de movimentação, por exemplo, a maioria das classes legadas do C++ 98) 
serão “movidos ”Através de suas operações de cópia. O coração de cada 
“mudança” de membro é a aplicação de std::move ao objeto a ser movido, e 
o resultado é usado durante a resolução de sobrecarga de função para 
determinar se uma movimentação ou uma cópia deve ser executada. O item 
23 aborda esse processo detalhadamente. Para este item, basta lembrar que 
uma movimentação entre membros consiste em operações de movimentação 
em membros de dados e classes base que suportam operações de 
movimentação, mas uma operação de cópia para aqueles que não o fazem. 
Como é o caso das operações de cópia, as operações de movimentação não 
serão geradas se você mesmo as declarar. No entanto, as condições precisas 
sob as quais são geradas diferem um pouco daquelas para as operações de 
cópia. 
As duas operações de cópia são independentes: declarar uma não impede 
que os compiladores gerem a outra. Portanto, se você declarar um construtor 
de cópia, mas nenhum operador de atribuição de cópia, e escrever um código 
que exija atribuição de cópia, os compiladores gerarão o operador de 
atribuição de cópia para você. Da mesma forma, se você declarar um operador 
de atribuição de cópia, mas nenhum construtor de cópia, mas seu código exigir 
construção de cópia, os compiladores gerarão o construtor de cópia para 
você. Isso era verdade no C++ 98 e ainda é verdade no C++ 11. 
As duas operações de movimentação não são independentes. Se você 
declarar um deles, isso impedirá que os compiladores gerem o outro. A 
 
128 | Artigo 17 
justificativa é que se você declarar, digamos, um construtor de movimentação 
para sua classe, estará indicando que há algo sobre como a construção de 
movimentação deve ser implementada que é diferente da movimentação 
padrão entre membros que os compiladores gerariam. E se há algo errado 
com a construção de mudanças entremembros, provavelmente também 
haverá algo errado com a atribuição de mudanças entre membros. Portanto, 
declarar um construtor de movimentação evita que um operador de atribuição 
de movimentação seja gerado, e declarar um operador de atribuição de 
movimentação evita que os compiladores gerem um construtor de 
movimentação. 
Além disso, as operações de movimentação não serão geradas para nenhuma 
classe que declare explicitamente uma operação de cópia. A justificativa é que 
declarar uma operação de cópia (construção ou atribuição) indica que a 
abordagem normal para copiar um objeto (cópia membro) não é apropriada 
para a classe, e os compiladores imaginam que se a cópia membro não for 
apropriada para as operações de cópia, A movimentação entre membros 
provavelmente não é apropriada para as operações de movimentação. 
Isso também vai na outra direção. Declarar uma operação de movimentação 
(construção ou atribuição) em uma classe faz com que os compiladores 
desabilitem as operações de cópia. (As operações de cópia são desativadas 
ao excluí-las – consulte o Item 11 ). Afinal, se a movimentação entre membros 
não for a maneira correta de mover um objeto, não há razão para esperar que 
a cópia entre membros seja a maneira correta de copiá-lo. Pode parecer que 
isso pode quebrar o código C++ 98, porque as condições sob as quais as 
operações de cópia são habilitadas são mais restritas no C++ 11 do que no 
C++ 98, mas não é o caso. O código C++ 98 não pode ter operações de 
movimentação, porque não existia tal coisa como “mover” objetos em C++ 98. 
A única maneira de uma classe herdada ter operações de movimentação 
declaradas pelo usuário é se elas foram adicionadas para C++ 11, e as 
classes que são modificadas para aproveitar a semântica de movimentação 
precisam seguir as regras do C++ 11 para geração de função de membro 
especial . 
Talvez você já tenha ouvido falar de uma diretriz conhecida como Regra de 
Três . A Regra de Três afirma que se você declarar qualquer construtor de 
cópia, operador de atribuição de cópia ou destruidor, deverá declarar todos os 
três. Surgiu da observação de que a necessidade de assumir o significado de 
uma operação de cópia quase sempre resultava da classe realizando algum 
tipo de gerenciamento de recursos, e isso quase sempre implicava que (1) 
qualquer gerenciamento de recursos que estivesse sendo feito em uma 
 
 Ponto 17 | 129 
operação de cópia provavelmente precisaria ser feito na outra operação de 
cópia e (2) o destruidor da classe também participaria do gerenciamento do 
recurso (geralmente liberando-o). O recurso clássico a ser gerenciado era a 
memória, e é por isso que todas as classes da Biblioteca Padrão que 
gerenciam memória (por exemplo, os contêineres STL que realizam 
gerenciamento dinâmico de memória) declaram “os três grandes”: ambas as 
operações de cópia e um destruidor. 
Uma consequência da Regra de Três é que a presença de um destruidor 
declarado pelo usuário indica que é improvável que a cópia simples por 
membro seja apropriada para as operações de cópia na classe. Isso, por sua 
vez, sugere que se uma classe declara um destruidor, as operações de cópia 
provavelmente não deveriam ser geradas automaticamente, porque não 
fariam a coisa certa. Na época em que o C++ 98 foi adotado, a importância 
dessa linha de raciocínio não foi totalmente apreciada; portanto, no C++ 98, a 
existência de um destruidor declarado pelo usuário não teve impacto na 
disposição dos compiladores de gerar operações de cópia. Esse continua a 
ser o caso no C++ 11, mas apenas porque restringir as condições sob as quais 
as operações de cópia são geradas quebraria muito código legado. 
O raciocínio por trás da Regra de Três permanece válido, entretanto, e isso, 
combinado com a observação de que a declaração de uma operação de cópia 
impede a geração implícita das operações de movimentação, motiva o fato de 
que C++ 11 não gera operações de movimentação para uma classe com um 
destruidor declarado pelo usuário. 
Portanto, as operações de movimentação são geradas para classes (quando 
necessário) somente se estas três coisas forem verdadeiras: 
• Nenhuma operação de cópia é declarada na classe. 
• Nenhuma operação de movimentação é declarada na classe. 
• Nenhum destruidor é declarado na classe. 
Em algum momento, regras análogas podem ser estendidas às operações de 
cópia, porque o C++ 11 descontinua a geração automática de operações de 
cópia para classes que declaram operações de cópia ou um destruidor. Isso 
significa que se você possui código que depende da geração de operações 
de cópia em classes que declaram um destruidor ou uma das operações de 
cópia, você deve considerar atualizar essas classes para eliminar a 
dependência. Desde que o comportamento das funções geradas pelo 
compilador esteja correto (ou seja, se a cópia entre membros dos membros 
 
130 | Artigo 17 
de dados não estáticos da classe é o que você deseja), seu trabalho é fácil, 
porque o “ = default ” permite que você diga isso explicitamente: 
classe Widget { público: 
… 
~Widget(); //dtor declarado pelo usuário 
… // cópia padrão ctor 
Widget(const Widget&) = padrão ; // comportamento está OK 
Widget& // cópia padrão atribuir operador=(const Widget&) = default ; // 
comportamento está OK 
… 
}; 
Esta abordagem é frequentemente útil em classes base polimórficas, isto é, 
classes que definem interfaces através das quais objetos de classes derivadas 
são manipulados. Classes base polimórficas normalmente têm destruidores 
virtuais, porque se não tiverem, algumas operações (por exemplo, o uso de 
delete ou typeid em um objeto de classe derivada por meio de um ponteiro ou 
referência de classe base) produzem resultados indefinidos ou enganosos. A 
menos que uma classe herde um destruidor que já seja virtual, a única 
maneira de tornar um destruidor virtual é declará-lo explicitamente dessa 
forma. Freqüentemente, a implementação padrão estaria correta e “ = default 
ӎ uma boa maneira de expressar isso. No entanto, um destruidor declarado 
pelo usuário suprime a geração das operações de movimentação, portanto, 
se a mobilidade for suportada, “ = default ”geralmente encontra um segundo 
aplicativo. Declarar as operações de movimentação desativa as operações de 
cópia, portanto, se a capacidade de cópia também for desejada, mais uma 
rodada de “ = default ”faz o trabalho: 
classe Base { público: virtual ~Base() = padrão ; // torna o dtor virtual 
Base(Base&&) = padrão; // apoia a movimentação 
 Operador Base&=(Base&&) = padrão; 
 Base(const Base&) = padrão; // suporta cópia 
 Operador Base&=(const Base&) = padrão; 
… 
}; 
Na verdade, mesmo que você tenha uma classe onde os compiladores 
estejam dispostos a gerar as operações de copiar e mover e onde as funções 
 
 Ponto 17 | 131 
geradas se comportem como você deseja, você pode optar por adotar uma 
política de declará-las você mesmo e usar “ = default ”para suas definições. É 
mais trabalhoso, mas deixa suas intenções mais claras e pode ajudá-lo a 
evitar alguns bugs bastante sutis. Por exemplo, suponha que você tenha uma 
classe representando uma tabela de strings, ou seja, uma estrutura de dados 
que permite pesquisas rápidas de valores de strings através de um ID inteiro: 
classe StringTable { público: 
StringTable() {} 
… //funções para inserção, apagamento, pesquisa, // etc., mas 
sem funcionalidade de copiar/mover/dtor 
privado: valores std::map; }; 
Supondo que a classe não declare operações de cópia, operações de 
movimentação e nenhum destruidor, os compiladores gerarão 
automaticamente essas funções se forem usadas. Isso é muito conveniente. 
Mas suponha que algum tempo depois seja decidido que seria útil registrar a 
construção padrão e a destruição de tais objetos. Adicionar essa 
funcionalidade é fácil: 
classe StringTable{ público: 
StringTable() 
{ makeLogEntry("Criando objeto StringTable"); } // adicionado 
 
 ~StringTable() // também 
{ makeLogEntry("Destruindo objeto StringTable"); } // adicionado 
… // outras funções como antes 
privado: valores std::map; // como antes }; 
Isso parece razoável, mas declarar um destruidor tem um efeito colateral 
potencialmente significativo: impede que as operações de movimentação 
sejam geradas. No entanto, a criação das operações de cópia da classe não 
é afetada. Portanto, é provável que o código compile, execute e passe nos 
testes funcionais. Isso inclui testar sua funcionalidade de movimentação, 
porque mesmo que essa classe não esteja mais habilitada para 
movimentação, as solicitações para movê-la serão compiladas e executadas. 
Tais solicitações, conforme observado anteriormente neste item, farão com 
que cópias sejam feitas. O que significa que o código que “mexe” objetos 
StringTable na verdade os copia, ou seja, copia o std::map objetos. E copiando um std ::map provavelmente 
 
132 | Artigo 17 
será muito mais lento do que movê-lo. O simples ato de adicionar um 
destruidor à classe poderia ter introduzido um problema significativo de 
desempenho! Se as operações de copiar e mover tivessem sido 
explicitamente definidas usando “ = default ”, o problema não teria surgido. 
Agora, tendo suportado minha interminável tagarelice sobre as regras que 
regem as operações de cópia e movimentação no C++ 11, você pode estar se 
perguntando quando voltarei minha atenção para as outras duas funções-
membro especiais, o construtor padrão e o destruidor. Essa hora é agora, mas 
apenas para esta frase, porque quase nada mudou para essas funções-
membro: as regras no C++ 11 são quase as mesmas que no C++ 98. As 
regras do C++ 11 que regem as funções de membro especiais são assim: 
• Construtor padrão : mesmas regras do C++ 98. Gerado somente se a 
classe não contiver construtores declarados pelo usuário. 
• Destruidor : Essencialmente as mesmas regras do C++ 98; a única 
diferença é que os destruidores são noexcept por padrão (veja o Item 14 
). Como no C++ 98, virtual somente se um destruidor de classe base for 
virtual. 
• Construtor de cópia : mesmo comportamento de tempo de execução do 
C++ 98: construção de cópia por membro de membros de dados não 
estáticos. Gerado somente se a classe não tiver um construtor de cópia 
declarado pelo usuário. Excluído se a classe declarar uma operação de 
movimentação. A geração desta função em uma classe com um operador 
ou destruidor de atribuição de cópia declarado pelo usuário está obsoleta. 
• Operador de atribuição de cópia : mesmo comportamento de tempo de 
execução do C++ 98: atribuição de cópia por membro de membros de 
dados não estáticos. Gerado somente se a classe não tiver um operador 
de atribuição de cópia declarado pelo usuário. Excluído se a classe 
declarar uma operação de movimentação. A geração desta função em 
uma classe com um construtor ou destruidor de cópia declarado pelo 
usuário está obsoleta. 
• Construtor de movimento e operador de atribuição de movimento : 
cada um executa a movimentação por membros de membros de dados 
não estáticos. Gerado somente se a classe não contiver operações de 
cópia, operações de movimentação ou destruidor declaradas pelo usuário. 
Observe que não há nada nas regras sobre a existência de um modelo de 
função de membro que impeça os compiladores de gerar funções de membro 
especiais. Isso significa que se o Widget for assim, 
 
 Ponto 17 | 133 
widget de classe { 
… 
 modelo //constrói Widget Widget(const 
T& rhs); //de qualquer coisa 
 modelo //atribuir widget Widget& 
operador=(const T& rhs); //de qualquer coisa 
… 
}; os compiladores ainda gerarão operações de cópia e movimentação 
para o Widget (assumindo que as condições usuais que regem sua geração 
sejam atendidas), mesmo que esses modelos possam ser instanciados para 
produzir as assinaturas para o construtor de cópia e o operador de atribuição 
de cópia. (Esse seria o caso quando T é Widget .) Com toda a probabilidade, 
isso lhe parecerá um caso extremo que mal vale a pena reconhecer, mas há 
uma razão pela qual estou mencionando isso. O item 26 demonstra que pode 
ter consequências importantes. 
Coisas para lembrar 
• As funções-membro especiais são aquelas que os compiladores podem 
gerar por conta própria: construtor padrão, destruidor, operações de 
cópia e operações de movimentação. 
• As operações de movimentação são geradas apenas para classes sem 
operações de movimentação explicitamente declaradas, operações de 
cópia e um destruidor. 
• O construtor de cópia é gerado apenas para classes sem um construtor 
de cópia declarado explicitamente e é excluído se uma operação de 
movimentação for declarada. O operador de atribuição de cópia é 
gerado apenas para classes sem um operador de atribuição de cópia 
declarado explicitamente e é excluído se uma operação de 
movimentação for declarada. A geração de operações de cópia em 
classes com um destruidor explicitamente declarado está obsoleta. 
• Os modelos de função-membro nunca suprimem a geração de funções-
membro especiais. 
 
 
 
 
135 
CAPÍT
ULO 4 
Pont
eiros 
inteligent
es 
Poetas e compositores têm uma queda pelo amor. E às vezes sobre contar. 
Ocasionalmente ambos. Inspirados pelas diferentes abordagens sobre amor 
e contagem de Elizabeth Barrett Browning (“Como eu te amo? Deixe-me 
contar as maneiras.”) e Paul Simon (“Deve haver 50 maneiras de deixar seu 
amante”), poderíamos tente enumerar as razões pelas quais é difícil amar um 
ponteiro bruto: 
1. Sua declaração não indica se aponta para um único objeto ou para um 
array. 
2. Sua declaração não revela nada sobre se você deve destruir o que ele 
aponta quando terminar de usá-lo, ou seja, se o ponteiro possui aquilo 
para o qual aponta. 
3. Se você determinar que deve destruir o que o ponteiro aponta, não há 
como saber como. Você deve usar delete ou existe um mecanismo de 
 
136 | 
destruição diferente (por exemplo, uma função de destruição dedicada 
para a qual o ponteiro deve ser passado)? 
4. Se você conseguir descobrir que excluir é o caminho a seguir, o Razão 1 
significa que talvez não seja possível saber se deve usar o formato de 
objeto único (“ delete ”) ou o formato de matriz (“ delete [] ”). Se você usar 
o formulário errado, os resultados serão indefinidos. 
5. Supondo que você verifique se o ponteiro possui o que aponta e descubra 
como destruí-lo, é difícil garantir que você execute a destruição 
exatamente uma vez em cada caminho do seu código (incluindo aqueles 
devido a exceções). Perder um caminho leva a vazamentos de recursos, 
e fazer a destruição mais de uma vez leva a 
comportamento indefinido. 
6. Normalmente não há como saber se o ponteiro está pendurado, ou seja, 
aponta para a memória que não contém mais o objeto para o qual o 
ponteiro deveria apontar. Ponteiros pendentes surgem quando objetos 
são destruídos enquanto os ponteiros ainda apontam para eles. 
Os ponteiros brutos são ferramentas poderosas, sem dúvida, mas décadas de 
experiência demonstraram que, com apenas o menor lapso de concentração 
ou disciplina, essas ferramentas podem se voltar contra seus mestres 
ostensivos. 
Indicadores inteligentes são uma forma de resolver esses problemas. 
Ponteiros inteligentes são invólucros em torno de ponteiros brutos que agem 
de maneira muito semelhante aos ponteiros brutos que eles envolvem, mas 
evitam muitas de suas armadilhas. Você deve, portanto, preferir ponteiros 
inteligentes a ponteiros brutos. Os ponteiros inteligentes podem fazer 
praticamente tudo o que os ponteiros brutos podem, mas com muito menos 
oportunidades de erro. 
Existem quatro ponteirosinteligentes em C++ 11: std::auto_ptr , 
std::unique_ptr , std::shared_ptr e std::weak_ptr . Todos são projetados para 
ajudar a gerenciar a vida útil de objetos alocados dinamicamente, ou seja, 
para evitar vazamentos de recursos, garantindo que tais objetos sejam 
destruídos da maneira apropriada e no momento apropriado (inclusive no caso 
de exceções). 
std::auto_ptr é uma sobra obsoleta do C++ 98. Foi uma tentativa de padronizar 
o que mais tarde se tornou std::unique_ptr do C++ 11 . Fazer o trabalho 
corretamente exigia semântica de movimentação, mas o C++ 98 não as 
possuía. Como solução alternativa, std::auto_ptr cooptou suas operações de 
cópia para movimentos. Isso levou a um código surpreendente (copiar um 
 
 Ponto 18 | 137 
std::auto_ptr o define como nulo!) e restrições de uso frustrantes (por exemplo, 
não é possível armazenar std::auto_ptr s em contêineres). 
std::unique_ptr faz tudo que std::auto_ptr faz e muito mais. Ele faz isso com a 
mesma eficiência e sem distorcer o que significa copiar um objeto. É melhor 
que std::auto_ptr em todos os sentidos. O único caso de uso legítimo para 
std::auto_ptr é a necessidade de compilar código com compiladores C++98. 
A menos que você tenha essa restrição, você deve substituir std::auto_ptr por 
std::unique_ptr e nunca olhar para trás. 
As APIs de ponteiro inteligente são extremamente variadas. Praticamente a 
única funcionalidade comum a todos é a construção padrão. Como as 
referências abrangentes para essas APIs estão amplamente disponíveis, 
concentrarei minhas discussões em informações que muitas vezes faltam nas 
visões gerais da API, por exemplo, casos de uso dignos de nota, análises de 
custos de tempo de execução, etc. e usá-los de forma eficaz . 
Item 18: Use std::unique_ptr para 
propriedade exclusiva 
gestão de recursos. 
Quando você pega um ponteiro inteligente, std::unique_ptr geralmente deve 
ser o mais próximo. É razoável supor que, por padrão, std::unique_ptr s são 
do mesmo tamanho que ponteiros brutos e, para a maioria das operações 
(incluindo desreferenciação), eles executam exatamente as mesmas 
instruções. Isso significa que você pode usá-los mesmo em situações 
Artigo 17 
situações onde a memória e os ciclos são apertados. Se um ponteiro bruto for 
pequeno e rápido o suficiente para você, um std::unique_ptr quase certamente 
também o será. 
std::unique_ptr incorpora semântica de propriedade exclusiva . Um std:: 
unique_ptr não nulo sempre possui aquilo para o qual aponta. Mover um 
std::unique_ptr transfere a propriedade do ponteiro de origem para o ponteiro 
de destino. (O ponteiro de origem está definido como nulo.) Copiar um 
std::unique_ptr não é permitido, porque se você pudesse copiar um 
std::unique_ptr , você acabaria com dois std::unique_ptr s para o mesmo 
recurso, cada um pensando que possuía (e deveria, portanto, destruir) esse 
 
138 | 
recurso. std::unique_ptr é, portanto, um tipo somente de movimentação . Após 
a destruição, um std::unique_ptr não nulo destrói seu recurso. Por padrão, a 
destruição de recursos é realizada aplicando delete ao ponteiro bruto dentro 
de std::unique_ptr . Um uso comum para std::unique_ptr é como um tipo de 
retorno de função de fábrica para objetos em uma hierarquia. Suponha que 
temos uma hierarquia para tipos de investimentos (por exemplo, ações, títulos, 
imóveis, etc.) com uma classe base Investment . 
classe Investimento { … }; 
Estoque de classe: 
Investimento público { … }; 
classe Bond: Investimento público { 
… }; 
classe Imóveis: 
Investimento público { … }; 
Uma função de fábrica para tal hierarquia normalmente aloca um objeto no 
heap e retorna um ponteiro para ele, sendo o chamador responsável por 
excluir o objeto quando ele não for mais necessário. Essa é uma combinação 
perfeita para std::unique_ptr , porque o chamador adquire responsabilidade 
pelo recurso retornado pela fábrica (ou seja, propriedade exclusiva dele), e o 
std::unique_ptr exclui automaticamente o que aponta quando o std::unique_ptr 
é destruído. Uma função de fábrica para a hierarquia de Investimento poderia 
ser declarada assim: 
template // retorna std::unique_ptr 
std::unique_ptr // para um objeto criado 
makeInvestment(Ts&&... params); // dos argumentos fornecidos 
Os chamadores poderiam usar o std::unique_ptr retornado em um único 
escopo da seguinte maneira, 
{ 
… 
 
 
 
 Ponto 18 | 139 
auto pInvestment = // pInvestment é do tipo makeInvestment( 
argumentos ); // std::unique_ptr … 
} // destrói *pInvestment , mas eles também podem usá-lo em cenários de 
migração de propriedade, como quando o std::unique_ptr retornado da fábrica 
é movido para um contêiner, o elemento contêiner é subsequentemente 
movido para um membro de dados de um objeto, e esse objeto é 
posteriormente destruído. Quando isso acontecer, o membro de dados 
std::unique_ptr do objeto também será destruído e sua destruição fará com 
que o recurso retornado da fábrica seja destruído. Se a cadeia de propriedade 
fosse interrompida devido a uma exceção ou outro fluxo de controle atípico 
(por exemplo, retorno antecipado de função ou interrupção de um loop), o 
std::unique_ptr proprietário do recurso gerenciado eventualmente teria seu 
destruidor chamado 7 e o recurso que estava gerenciando seria assim 
destruído. 
Por padrão, essa destruição ocorreria via delete , mas, durante a construção, 
os objetos std::unique_ptr podem ser configurados para usar deleters 
personalizados : funções arbitrárias (ou objetos de função, incluindo aqueles 
decorrentes de expressões lambda) a serem invocadas quando chegar a hora 
de seus recursos sejam destruídos. Se o objeto criado por makeInvestment 
não deveria ser excluído diretamente d, mas em vez disso deveria primeiro ter 
uma entrada de log escrita, makeInvestment poderia ser implementado da 
seguinte maneira. (Uma explicação segue o código, então não se preocupe 
se você vir algo cuja motivação não seja óbvia.) 
auto delInvmt = [](Investment* pInvestment) // custom { // exclui 
makeLogEntry(pInvestment); // (uma lambda delete pInvestment; // 
expressão) }; 
template // std revisado::unique_ptr //tipo de retorno 
makeInvestment(Ts&&... parâmetros) 
{ 
std::unique_ptr // ptr será pInv(nullptr, 
delInvmt); // retornado if ( /* um objeto Stock deve ser criado */ ) 
 
7Existem algumas exceções a esta regra. A maioria resulta do encerramento anormal do programa. Se uma 
exceção se propagar para fora da função primária de um thread (por exemplo, main , para o thread inicial do 
programa) ou se uma especificação noexcept for violada (consulte o Item 14 ), os objetos locais 
não poderão ser destruídos e se std::abort ou um exit função (ou seja, std::_Exit , std::exit ou 
std::quick_exit ) é chamada, eles definitivamente não serão. 
 
140 | Artigo 18 
{ 
pInv.reset(new Estoque(std::forward(params)...)); 
} 
else if ( /* um objeto Bond deve ser criado */ ) 
{ 
pInv.reset(new Bond(std::forward(params)...)); 
} 
else if ( /* um objeto RealEstate deve ser criado */ ) 
{ 
pInv.reset(new RealEstate(std::forward(params)...)); } 
retornar pInv; } 
Em um momento explicarei como isso funciona, mas primeiro considere como 
as coisas parecem se você for um chamador. Supondo que você armazene o 
resultado da chamada makeInvestment em uma variável automática , você se 
diverte ignorando o fato de que o recurso que está usando requer tratamento 
especial durante a exclusão. Na verdade, você realmente se banha em 
êxtase, porque o uso de std::unique_ptr significa que você não precisa se 
preocupar com quando o recurso deve ser destruído, muito menos garantir 
que a destruição aconteça exatamente uma vez em cada caminho do 
programa. std::unique_ptr cuidade todas essas coisas automaticamente. Do 
ponto de vista do cliente, a interface do makeInvestment é ótima. 
A implementação também é muito boa, uma vez que você entende o seguinte: 
• delInvmt é o deleter personalizado para o objeto retornado de 
makeInvestment . Todas as funções de exclusão personalizadas aceitam 
um ponteiro bruto para o objeto a ser destruído e, em seguida, fazem o 
que for necessário para destruir esse objeto. Nesse caso, a ação é chamar 
makeLogEntry e depois aplicar delete . Usar uma expressão lambda para 
criar delInvmt é conveniente, mas, como veremos em breve, também é 
mais eficiente do que escrever uma função convencional. 
• Quando um deleter personalizado for usado, seu tipo deve ser 
especificado como o segundo argumento de tipo para std::unique_ptr . 
Nesse caso, esse é o tipo de delInvmt e é por isso que o tipo de retorno 
de makeInvestment é std::unique_ptr . 
(Para obter informações sobre decltype , consulte o Item 3 .) 
• A estratégia básica do makeInvestment é criar um std::unique_ptr nulo , 
fazê-lo apontar para um objeto do tipo apropriado e então retorná-lo. Para 
 
 Ponto 18 | 141 
associar o deleter personalizado delInvmt com pInv , passamos isso como 
seu segundo argumento do construtor. 
• Tentar atribuir um ponteiro bruto (por exemplo, de new ) a um 
std::unique_ptr não será compilado, porque constituiria uma conversão 
implícita de um ponteiro bruto para um ponteiro inteligente. Essas 
conversões implícitas podem ser problemáticas, portanto, os ponteiros 
inteligentes do C++ 11 as proíbem. É por isso que reset é usado para que 
pInv assuma a propriedade do objeto criado por meio de new . 
• A cada uso de new , usamos std::forward para encaminhar com perfeição 
os argumentos passados para makeInvestment (consulte o Item 25 ). Isso 
disponibiliza todas as informações fornecidas pelos chamadores aos 
construtores dos objetos que estão sendo criados. 
• O excluído personalizado usa um parâmetro do tipo Investment* . 
Independentemente do tipo real de objeto criado dentro de 
makeInvestment (ou seja, Stock , Bond ou Real Estate ), ele será excluído 
dentro da expressão lambda como um objeto Invest ment* . Isso significa 
que excluiremos um objeto de classe derivada por meio de um ponteiro 
de classe base. Para que isso funcione, a classe base — Investimento — 
deve ter um destruidor virtual: 
classe Investimento { 
público: 
… // essencial virtual ~Investimento(); // projeto 
… // componente! 
}; 
Em C++14, a existência da dedução do tipo de retorno da função (consulte o 
Item 3 ) significa que makeInvestment poderia ser implementado desta forma 
mais simples e encapsulada: 
modelo 
auto makeInvestment(Ts&&... params) // C++14 
{ 
auto delInvmt = [](Investment* pInvestment) // isso é agora 
{ // dentro de makeLogEntry(pInvestment); // faz deletar pInvestment; 
// Investimento }; 
std::unique_ptr // como pInv(nullptr, 
delInvmt); // antes 
if (…) // como antes 
 
142 | Artigo 18 
{ 
pInv.reset(new Estoque(std::forward(params)...)); 
} 
senão if (…) // como antes 
{ 
pInv.reset(new Bond(std::forward(params)...)); 
} 
senão if (…) // como antes 
{ 
pInv.reset(new RealEstate(std::forward(params)...)); 
} 
retornar pInv; // como antes } 
Observei anteriormente que, ao usar o deleter padrão (ou seja, delete ), você 
pode razoavelmente assumir que os objetos std::unique_ptr são do mesmo 
tamanho que os ponteiros brutos. Quando eliminadores personalizados 
entram em cena, esse pode não ser mais o caso. Excluidores que são 
ponteiros de função geralmente fazem com que o tamanho de um 
std::unique_ptr cresça de uma palavra para duas. Para eliminadores que são 
objetos de função, a mudança no tamanho depende de quanto estado está 
armazenado no objeto de função. Objetos de função sem estado (por 
exemplo, de expressões lambda sem capturas) não incorrem em penalidade 
de tamanho, e isso significa que quando um deleter personalizado pode ser 
implementado como uma função ou como uma expressão lambda sem 
captura, o lambda é preferível: 
auto delInvmt1 = [](Investimento* pInvestment) // custom { // exclui 
makeLogEntry(pInvestment); // como deletar pInvestment; // sem 
estado }; // lambda 
template // tipo de retorno std::unique_ptr // tem tamanho de 
makeInvestment(Ts&&... args); // Investimento* 
void delInvmt2(Investment* pInvestment) // custom { // exclui 
makeLogEntry(pInvestment); //como função 
excluir pInvestimento; } 
template // tipo de retorno possui std::unique_ptr // mais pelo menos o tamanho 
makeInvestment(Ts&&... params); // do ponteiro de função! 
 
 Ponto 18 | 143 
Excluidores de objetos de função com estado extenso podem gerar objetos 
std::unique_ptr de tamanho significativo. Se você achar que um deleter 
personalizado torna seus std::unique_ptr s inaceitavelmente grandes, você 
provavelmente precisará alterar seu design. 
Funções de fábrica não são o único caso de uso comum para std::unique_ptr 
s. Eles são ainda mais populares como mecanismo para implementar o idioma 
Pimpl. O código para isso não é complicado, mas em alguns casos não é nada 
simples, então vou encaminhá-lo para o Item 22 , que é dedicado ao tópico. 
std::unique_ptr vem em duas formas, uma para objetos individuais ( std:: 
unique_ptr ) e outra para matrizes ( std::unique_ptr ). Como 
resultado, nunca há qualquer ambigüidade sobre que tipo de entidade um 
std::unique_ptr aponta. A API std::unique_ptr foi projetada para corresponder 
ao formulário que você está usando. Por exemplo, não há operador de 
indexação ( operador[] ) para o formulário de objeto único, enquanto o 
formulário de matriz não possui operadores de desreferenciação ( operador* 
e operador-> ). 
A existência de std::unique_ptr para matrizes deve ser de interesse apenas 
intelectual para você, porque std::array , std::vector e std::string são 
virtualmente sempre melhores opções de estrutura de dados do que matrizes 
brutas. Praticamente a única situação que posso conceber quando um 
std::unique_ptr faria sentido seria quando você estivesse usando uma 
API semelhante a C que retorna um ponteiro bruto para uma matriz heap da 
qual você assume propriedade. 
std::unique_ptr é a maneira do C++ 11 de expressar propriedade exclusiva, 
mas um de seus recursos mais atraentes é que ele é convertido de maneira 
fácil e eficiente em um std:: 
shared_ptr : 
std::shared_ptr sp = // converte std::unique_ptr 
makeInvestment( argumentos ); // para std::shared_ptr 
Esta é uma parte importante do motivo pelo qual std::unique_ptr é tão 
adequado como um tipo de retorno de função de fábrica. As funções de fábrica 
não podem saber se os chamadores desejarão usar a semântica de 
propriedade exclusiva para o objeto que retornam ou se a propriedade 
compartilhada (ou seja, std::shared_ptr ) seria mais apropriada. Ao retornar 
um std::unique_ptr , as fábricas fornecem aos chamadores o ponteiro 
inteligente mais eficiente, mas não impedem que os chamadores o substituam 
 
144 | Artigo 18 
por seu irmão mais flexível. (Para obter informações sobre std::shared_ptr , 
vá para o Item 19 .) 
Coisas para lembrar 
• std::unique_ptr é um ponteiro inteligente pequeno, rápido e somente de 
movimentação para gerenciar recursos com semântica de propriedade 
exclusiva. 
• Por padrão, a destruição de recursos ocorre via delete , mas 
eliminadores personalizados podem ser especificados. Excluidores com 
estado e ponteiros de função como exclusões aumentam o tamanho dos 
objetos std::unique_ptr . 
• Converter um std::unique_ptr em um std::shared_ptr é fácil. 
 
 Ponto 19 | 145 
Item 19: Use std::shared_ptrpara 
gerenciamento de recursos de 
propriedade compartilhada. 
Programadores que usam linguagens com coleta de lixo apontam e riem do 
que os programadores C++ passam para evitar vazamentos de recursos. “Que 
primitivo!” eles zombam. “Você não recebeu o memorando do Lisp na década 
de 1960? As máquinas deveriam gerenciar a vida útil dos recursos, não os 
humanos.” Os desenvolvedores de C++ reviram os olhos. “Você quer dizer o 
memorando onde o único recurso é a memória e o momento da recuperação 
de recursos é não determinístico? Preferimos a generalidade e a 
previsibilidade dos destruidores, obrigado.” Mas a nossa bravata é em parte 
fanfarronice. A coleta de lixo é realmente conveniente, e o gerenciamento 
manual da vida pode parecer semelhante à construção de um circuito de 
memória mnemônica usando facas de pedra e peles de urso. Por que não 
podemos ter o melhor dos dois mundos: um sistema que funcione 
automaticamente (como a coleta de lixo), mas que se aplique a todos os 
recursos e tenha um tempo previsível (como os destruidores)? 
std::shared_ptr é a maneira C++ 11 de unir esses mundos. Um objeto 
acessado via std::shared_ptr s tem seu tempo de vida gerenciado por esses 
ponteiros por meio de propriedade compartilhada . Nenhum std::shared_ptr 
específico possui o objeto. Em vez disso, todos os std::shared_ptr s 
apontando para ele colaboram para garantir sua destruição no ponto onde não 
é mais necessário. Quando o último std::shared_ptr apontando para um objeto 
para de apontar para lá (por exemplo, porque o std::shared_ptr é destruído ou 
feito para apontar para um objeto diferente), esse std::shared_ptr destrói o 
objeto para o qual aponta. Tal como acontece com a coleta de lixo, os clientes 
não precisam se preocupar em gerenciar o tempo de vida dos objetos 
apontados, mas, como acontece com os destruidores, o momento da 
destruição dos objetos é determinístico. 
Um std::shared_ptr pode dizer se é o último apontando para um recurso 
consultando a contagem de referência do recurso , um valor associado ao 
recurso que controla quantos std::shared_ptr s apontam para ele. Os 
construtores std::shared_ptr incrementam essa contagem (geralmente - veja 
abaixo), os destruidores std::shared_ptr a diminuem e os operadores de 
atribuição de cópia fazem as duas coisas. (Se sp1 e sp2 são std::shared_ptr 
s para objetos diferentes, a atribuição “ sp1 = sp2; ”modifica sp1 de forma que 
aponte para o objeto apontado por sp2 . O efeito líquido da atribuição é que a 
 
146 | Artigo 19 
contagem de referência para o objeto originalmente apontado por sp1 é 
decrementada, enquanto a do objeto apontado por sp2 é incrementada.) Se 
um std::shared_ptr vê uma contagem de referência de zero após executar 
uma decremento, não há mais std::shared_ptr s apontam para o recurso, 
então o std::shared_ptr o destrói. 
A existência da contagem de referência tem implicações no desempenho: 
• std::shared_ptr s têm o dobro do tamanho de um ponteiro bruto , 
porque contêm internamente um ponteiro bruto para o recurso, bem como 
um ponteiro bruto para a contagem de referência do recurso.8 
• A memória para a contagem de referência deve ser alocada 
dinamicamente . Conceitualmente, a contagem de referências está 
associada ao objeto apontado, mas os objetos apontados não sabem 
nada sobre isso. Portanto, eles não têm lugar para armazenar uma 
contagem de referência. (Uma implicação agradável é que qualquer objeto 
- mesmo aqueles de tipos integrados - pode ser gerenciado por 
std::shared_ptr s.) O item 21 explica que o custo da alocação dinâmica é 
evitado quando o std::shared_ptr é criado por std ::make_shared , mas há 
situações em que std::make_shared não pode ser usado. De qualquer 
forma, a contagem de referência é armazenada como dados alocados 
dinamicamente. 
• Os incrementos e decrementos da contagem de referências devem 
ser atômicos , pois pode haver leitores e gravadores simultâneos em 
threads diferentes. Por exemplo, um std::shared_ptr apontando para um 
recurso em um thread pode estar executando seu destruidor 
(decrementando assim a contagem de referência do recurso para o qual 
aponta), enquanto, em um thread diferente, um std::shared_ptr para o 
mesmo objeto poderiam ser copiados (e, portanto, incrementando a 
mesma contagem de referência). As operações atômicas são 
normalmente mais lentas do que as operações não atômicas, portanto, 
embora as contagens de referência geralmente tenham apenas o tamanho 
de uma palavra, você deve presumir que lê-las e escrevê-las é 
comparativamente caro. 
Despertei sua curiosidade quando escrevi que os construtores std::shared_ptr 
apenas “normalmente” incrementam a contagem de referência do objeto para 
o qual apontam? Criar um std::shared_ptr apontando para um objeto sempre 
 
8Esta implementação não é exigida pelo Padrão, mas todas as implementações da Biblioteca Padrão com as 
quais estou familiarizado a empregam. 
 
 Ponto 19 | 147 
produz mais um std::shared_ptr apontando para esse objeto, então por que 
não devemos sempre incrementar a contagem de referências? 
Mova a construção, é por isso. Mover a construção de um std::shared_ptr de 
outro std::shared_ptr define a fonte std::shared_ptr como nula, e isso significa 
que o antigo std::shared_ptr para de apontar para o recurso no momento em 
que o novo std::shared_ptr é iniciado. Como resultado, nenhuma manipulação 
da contagem de referência é necessária. Mover std::shared_ptr s é, portanto, 
mais rápido do que copiá-los: a cópia requer o incremento da contagem de 
referência, mas a movimentação não. Isso se aplica tanto à atribuição quanto 
à construção, portanto, a construção da movimentação é mais rápida que a 
construção da cópia, e a atribuição da movimentação é mais rápida do que a 
atribuição da cópia. 
Assim como std::unique_ptr (consulte o Item 18 ), std::shared_ptr usa delete 
como seu mecanismo padrão de destruição de recursos, mas também suporta 
exclusões personalizadas. O design desse suporte difere daquele de 
std::unique_ptr , entretanto. Para std::unique_ptr , o tipo do deleter faz parte 
do tipo do ponteiro inteligente. Para std::shared_ptr , não é: 
auto loggingDel = [](Widget *pw) // deletor personalizado { // 
(como no Item 18 ) 
makeLogEntry(pw); excluir pw; }; 
std::unique_ptr upw(novo widget, loggingDel); 
std::shared_ptr // o tipo de exclusão não é spw(new Widget, 
loggingDel); // parte do tipo ptr O design std::shared_ptr é mais flexível. 
Considere dois std::shared_ptr s, cada um com um deleter 
personalizado de um tipo diferente (por exemplo, porque os deleters 
personalizados são especificados por meio de expressões lambda): 
auto customDeleter1 = [](Widget *pw) {… }; // exclusões personalizadas, 
auto customDeleter2 = [](Widget *pw) { … }; //cada um com um 
// tipo diferente 
std::shared_ptr pw1(novo widget, customDeleter1); 
std::shared_ptr pw2(novo widget, customDeleter2); 
Como pw1 e pw2 possuem o mesmo tipo, eles podem ser colocados em um 
contêiner de objetos desse tipo: 
 
148 | Artigo 19 
std::vector> vpw{ pw1, pw2 }; 
Eles também podem ser atribuídos um ao outro e cada um pode ser passado 
para uma função que recebe um parâmetro do tipo std::shared_ptr . 
Nenhuma dessas coisas pode ser feita com std::unique_ptr s que diferem nos 
tipos de seus eliminadores personalizados, porque o tipo do eliminador 
personalizado afetaria o tipo de std::unique_ptr . 
Em outra diferença de std::unique_ptr , especificar um deleter personalizado 
não altera o tamanho de um objeto std::shared_ptr . Independentemente do 
deleter, um objeto std::shared_ptr tem dois ponteiros de tamanho. Isso é uma 
ótima notícia, mas devedeixá-lo um pouco desconfortável. Excluidores 
personalizados podem ser objetos de função e os objetos de função podem 
conter quantidades arbitrárias de dados. Isso significa que eles podem ser 
arbitrariamente grandes. Como um std::shared_ptr pode se referir a um 
deleter de tamanho arbitrário sem usar mais memória? 
Não pode. Pode ser necessário usar mais memória. No entanto, essa memória 
não faz parte do objeto std::shared_ptr . Está na pilha ou, se o criador do 
std::shared_ptr aproveitou o suporte std::shared_ptr para alocadores 
personalizados, é onde quer que a memória gerenciada pelo alocador esteja 
localizada. Observei anteriormente que um objeto std::shared_ptr contém um 
ponteiro para a contagem de referência do objeto para o qual aponta. Isso é 
verdade, mas é um pouco enganador, porque a contagem de referência faz 
parte de uma estrutura de dados maior conhecida como bloco de controle . Há 
um bloco de controle para cada objeto gerenciado por std::shared_ptr s. O 
bloco de controle contém, além da contagem de referência, uma cópia do 
eliminador personalizado, se algum tiver sido especificado. Se um alocador 
personalizado foi especificado, o bloco de controle também contém uma cópia 
dele. O bloco de controle também pode conter dados adicionais, incluindo, 
como explica o Item 21 , uma contagem de referência secundária conhecida 
como contagem fraca, mas ignoraremos tais dados neste Item. Podemos 
imaginar a memória associada a um objeto std::shared_ptr assim: 
std::shared_ptr 
 
 Ponto 19 | 149 
 
O bloco de controle de um objeto é configurado pela função que cria o primeiro 
std::shared_ptr para o objeto. Pelo menos é isso que deveria acontecer. Em 
geral, é impossível para uma função que cria um std::shared_ptr para um 
objeto saber se algum outro std::shared_ptr já aponta para esse objeto, então 
as seguintes regras para criação de blocos de controle são usadas: 
• std::make_shared (veja o Item 21 ) sempre cria um bloco de controle. 
Ele fabrica um novo objeto para apontar, portanto certamente não há bloco 
de controle para esse objeto no momento em que std::make_shared é 
chamado. 
• Um bloco de controle é criado quando um std::shared_ptr é 
construído a partir de um ponteiro de propriedade exclusiva (ou seja, 
um std::unique_ptr ou std::auto_ptr ). Ponteiros de propriedade 
exclusiva não usam blocos de controle, portanto não deve haver nenhum 
bloco de controle para o objeto apontado. (Como parte de sua construção, 
std::shared_ptr assume a propriedade do objeto apontado, portanto, o 
ponteiro uniqueownership é definido como nulo.) 
• Quando um construtor std::shared_ptr é chamado com um ponteiro 
bruto, ele cria um bloco de controle. Se você quisesse criar um 
std::shared_ptr a partir de um objeto que já tivesse um bloco de controle, 
você provavelmente passaria um std::shared_ptr ou um std::weak_ptr 
(veja o Item 20 ) como um argumento de construtor, não um ponteiro bruto 
. 
Os construtores std::shared_ptr que usam std::shared_ptr s ou 
std::weak_ptr s como argumentos do construtor não criam novos blocos 
de controle, porque eles podem contar com os ponteiros inteligentes 
passados a eles para apontar para quaisquer blocos de controle 
necessários. 
 
 
 
 
 
 
 
 
150 | Artigo 19 
Uma consequência dessas regras é que construir mais de um std::shared_ptr 
a partir de um único ponteiro bruto oferece um passeio gratuito no acelerador 
de partículas de comportamento indefinido, porque o objeto apontado terá 
vários blocos de controle. Múltiplos blocos de controle significam múltiplas 
contagens de referência, e múltiplas contagens de referência significam que o 
objeto será destruído diversas vezes (uma vez para cada contagem de 
referência). Isso significa que um código como este é ruim, ruim, ruim: 
auto pw = novo widget; // pw é ptr bruto … 
std::shared_ptr spw1( pw , loggingDel); //cria o controle 
//bloco para *pw 
… 
std::shared_ptr spw2( pw , loggingDel); //cria o 2º 
//bloco de controle // para *pw! 
A criação do ponteiro bruto pw para um objeto alocado dinamicamente é ruim, 
porque vai contra o conselho por trás de todo este capítulo: preferir ponteiros 
inteligentes a ponteiros brutos. (Se você esqueceu a motivação desse 
conselho, refresque sua memória na página 115. ) Mas deixe isso de lado. A 
linha que cria pw é uma abominação estilística, mas pelo menos não causa 
um comportamento indefinido no programa. 
Agora, o construtor de spw1 é chamado com um ponteiro bruto, portanto ele 
cria um bloco de controle (e, portanto, uma contagem de referência) para o 
que é apontado. Neste caso, é *pw (ou seja, o objeto apontado por pw ). Por 
si só, tudo bem, mas o construtor de spw2 é chamado com o mesmo ponteiro 
bruto, portanto também cria um bloco de controle (portanto, uma contagem de 
referência) para *pw . *pw portanto, tem duas contagens de referência, cada 
uma das quais eventualmente se tornará zero, e isso acabará por levar a uma 
tentativa de destruir *pw duas vezes. A segunda destruição é responsável pelo 
comportamento indefinido. 
Há pelo menos duas lições sobre o uso de std::shared_ptr aqui. Primeiro, tente 
evitar passar ponteiros brutos para um construtor std::shared_ptr . A 
alternativa usual é usar std::make_shared (veja Item 21 ), mas no exemplo 
acima, estamos usando deletores personalizados, e isso não é possível com 
std::make_shared . Segundo, se você precisar passar um ponteiro bruto para 
um construtor std::shared_ptr , passe o resultado de new diretamente em vez 
de passar por uma variável de ponteiro bruto. Se a primeira parte do código 
acima fosse reescrita assim, 
 
 Ponto 19 | 151 
std::shared_ptr spw1( new Widget , // uso direto do novo 
loggingDel); 
seria muito menos tentador criar um segundo std::shared_ptr a partir do 
mesmo ponteiro bruto. Em vez disso, o autor do código que cria spw2 usaria 
naturalmente spw1 como um argumento de inicialização (ou seja, chamaria o 
construtor de cópia std::shared_ptr ), e isso não representaria nenhum 
problema: 
std::shared_ptr spw2( spw1 ); // spw2 usa o mesmo 
// bloco de controle como spw1 Uma maneira especialmente surpreendente de 
usar variáveis de ponteiro brutas como argumentos do construtor 
std::shared_ptr pode levar a vários blocos de controle envolve o ponteiro this 
. Suponha que nosso programa use std::shared_ptr s para gerenciar objetos 
Widget e tenhamos uma estrutura de dados que monitora Widget s que foram 
processados: std::vector > processadosWidgets; 
Suponha ainda que o Widget tenha uma função membro que faz o 
processamento: 
classe Widget { público: 
… 
processo vazio(); 
… 
}; 
Aqui está uma abordagem de aparência razoável para Widget::process : 
Widget vazio::process() 
{ 
… // processa o widget 
processadoWidgets.emplace_back( este ); // adiciona-o à lista de } // 
Widgets processados; // isto está errado! 
O comentário sobre isso estar errado diz tudo – ou pelo menos a maior parte. 
(A parte errada é a passagem de this , não o uso de emplace_back . Se você 
não estiver familiarizado com emplace_back , consulte o Item 42 .) Este código 
será compilado, mas está passando um ponteiro bruto ( this ) para um 
contêiner de std ::shared_ptrs . O std::shared_ptr assim construído criará um 
novo bloco de controle para o widget apontado ( *this ). Isso não parece 
prejudicial até que você perceba que se houver std::shared_ptr s fora da 
 
152 | Artigo 19 
função membro que já aponte para isso Widget , é game, set e match para 
comportamento indefinido. 
A API std::shared_ptr inclui um recurso exatamente para esse tipo de situação. 
Provavelmente tem o maishttp://herbsutter.com/2013/05/30/gotw-90-solution-factories/
http://herbsutter.com/2013/05/30/gotw-90-solution-factories/
http://herbsutter.com/2013/05/30/gotw-90-solution-factories/
http://channel9.msdn.com/Events/GoingNative/2013/My-Favorite-Cpp-10-Liner
http://herbsutter.com/gotw/_100/
http://herbsutter.com/gotw/_100/
http://stackoverflow.com/questions/6012157/is-stdunique-ptrt-required-to-know-the-full-definition-of-t
http://stackoverflow.com/questions/6012157/is-stdunique-ptrt-required-to-know-the-full-definition-of-t
http://stackoverflow.com/questions/6012157/is-stdunique-ptrt-required-to-know-the-full-definition-of-t
http://stackoverflow.com/questions/6012157/is-stdunique-ptrt-required-to-know-the-full-definition-of-t
http://jrb-programming.blogspot.com/2012/11/another-alternative-to-lambda-move.html
http://jrb-programming.blogspot.com/2012/11/another-alternative-to-lambda-move.html
http://jrb-programming.blogspot.com/2012/11/another-alternative-to-lambda-move.html
http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2008/n2802.html
http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2008/n2802.html
http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2008/n2802.html
http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2008/n2802.html
http://web.archive.org/web/20140113221447/http:/cpp-next.com/archive/2009/08/want-speed-pass-by-value/
http://web.archive.org/web/20140113221447/http:/cpp-next.com/archive/2009/08/want-speed-pass-by-value/
http://channel9.msdn.com/Events/GoingNative/2013/Cpp-Seasoning
http://channel9.msdn.com/Events/GoingNative/2013/Cpp-Seasoning
 
 
foram oficialmente revisados por Cassio Neri, Nate Kohl, Gerhard Kreuzer, 
Leor Zolman, Bart Vandewoestyne, Stephan T. Lavavej, Nevin “:-)” Liber, 
Rachel Cheng, Rob Stewart, Bob Steagall, Damien Watkins, Bradley E. 
Needham, Rainer Grimm, Fredrik Winkler, Jonathan Wakely, Herb Sutter, 
Andrei Alexandrescu, Eric Niebler, Thomas Becker, Roger Orr, Anthony 
Williams, Michael Winterberg, Benjamin Huchley, Tom Kirby-Green, Alexey A 
Nikitin, William Dealtry, Hubert Matthews e Tomasz Kamiński. Também recebi 
feedback de vários leitores por meio dos E-books de lançamento antecipado 
da O'Reilly e Safari Books Online's Rough Cuts , comentários em meu blog ( 
The View from Aristeia ) e e-mail. Sou grato a cada uma dessas pessoas. O 
livro é muito melhor do que seria sem a ajuda deles. Estou particularmente 
grato a Stephan T. Lavavej e Rob Stewart, cujas observações 
extraordinariamente detalhadas e abrangentes me levam a temer que eles 
tenham gasto quase tanto 
XIV | Agradecimentos 
tanto tempo neste livro quanto eu. Agradecimentos especiais também a Leor 
Zolman, que, além de revisar o manuscrito, verificou novamente todos os 
exemplos de código. 
Resenhas dedicadas de versões digitais do livro foram realizadas por Gerhard 
Kreuzer, Emyr Williams e Bradley E. Needham. 
Minha decisão de limitar o comprimento da linha em exibições de código a 64 
caracteres (a probabilidade máxima de exibição adequada na impressão, bem 
como em uma variedade de dispositivos digitais, orientações de dispositivos 
e configurações de fonte) foi baseada em dados fornecidos por Michael 
Maher. 
Ashley Morgan Williams tornou o jantar no Lake Oswego Pizzicato 
exclusivamente divertido. Quando se trata de Caesars do tamanho de um 
homem, ela é a garota certa. 
Mais de 20 anos depois de viver pela primeira vez através da minha autora, 
minha esposa, Nancy L. Urbano, mais uma vez tolerou muitos meses de 
conversas distraídas com um coquetel de resignação, exasperação e 
respingos oportunos de compreensão e apoio. Durante o mesmo período, 
nossa cadela, Darla, ficou bastante contente em cochilar as horas que passei 
olhando para telas de computador, mas ela nunca me deixou esquecer que 
existe vida além do teclado. 
http://shop.oreilly.com/category/early-release.do
http://shop.oreilly.com/category/early-release.do
http://shop.oreilly.com/category/early-release.do
http://my.safaribooksonline.com/roughcuts
http://my.safaribooksonline.com/roughcuts
http://my.safaribooksonline.com/roughcuts
http://scottmeyers.blogspot.com/
 
xvii 
 Agradecimentos 
 | 
 
 
 
 
1 
Introdução 
Se você é um programador C++ experiente e é como eu, inicialmente abordou 
o C++ 11 pensando: “Sim, sim, entendi. É C++, só que mais.” Mas à medida 
que você aprendeu mais, ficou surpreso com o escopo das mudanças. 
declarações automáticas , loops for baseados em intervalo , expressões 
lambda e referências de rvalue mudam a cara do C++, para não falar dos 
novos recursos de simultaneidade. E depois há as mudanças idiomáticas. 0 e 
typedef s foram eliminados, as declarações nullptr e alias foram incluídas. 
Enums agora devem ter escopo definido. Ponteiros inteligentes agora são 
preferíveis aos integrados. Mover objetos normalmente é melhor do que copiá-
los. 
Há muito o que aprender sobre o C++ 11, sem mencionar o C++ 14. 
Mais importante ainda, há muito a aprender sobre como fazer uso eficaz dos 
novos recursos. Se você precisar de informações básicas sobre recursos 
“modernos” do C++, os recursos serão abundantes, mas se você estiver 
procurando orientação sobre como empregar os recursos para criar software 
que seja correto, eficiente, sustentável e portátil, a pesquisa será mais 
desafiadora. É aí que entra este livro. Ele não se dedica a descrever os 
recursos do C++ 11 e do C++ 14, mas sim à sua aplicação efetiva. 
As informações do livro são divididas em diretrizes chamadas Itens . Quer 
entender as diversas formas de dedução de tipo? Ou sabe quando (e quando 
não) usar declarações automáticas ? Você está interessado em saber por que 
as funções de membro const devem ser thread-safe, como implementar o 
Pimpl Idiom usando std::unique_ptr , por que você deve evitar modos de 
captura padrão em expressões lambda ou as diferenças entre std::atomic e 
volátil ? As respostas estão todas aqui. Além disso, são respostas 
independentes de plataforma e em conformidade com os padrões. Este é um 
livro sobre C++ portátil . 
 
2 | 
Os itens deste livro são diretrizes, não regras, porque as diretrizes têm 
exceções. A parte mais importante de cada item não é o conselho que ele 
oferece, mas a lógica por trás do conselho. Depois de ler isso, você estará em 
condições de determinar se as circunstâncias do seu projeto justificam uma 
violação das orientações do Item. O verdadeiro objetivo deste livro não é dizer 
o que fazer ou o que evitar, mas transmitir uma compreensão mais profunda 
de como as coisas funcionam em C++11 e C++14. 
Terminologia e Convenções 
Para garantir que nos entendemos, é importante concordar com alguma 
terminologia, começando, ironicamente, com “C++”. Houve quatro versões 
oficiais do C++, cada uma nomeada de acordo com o ano em que o padrão 
ISO correspondente foi adotado: C++98 , C++03 , C++11 e C++14 . C++98 e 
C++03 diferem apenas em detalhes técnicos, portanto, neste livro, me refiro a 
ambos como C++98. Quando me refiro ao C++ 11, quero dizer tanto C++ 11 
quanto C++ 14, porque C++ 14 é efetivamente um superconjunto de C++ 11. 
Quando escrevo C++14, quero dizer especificamente C++14. E se eu 
simplesmente mencionar C++, estou fazendo uma declaração ampla que se 
aplica a todas as versões da linguagem. 
Termo 
que uso 
Versões de 
idiomas, quero 
dizer 
C++ Todos 
C++98 C++98 e C++03 
C++11 C++11 e C++14 
C++14 C++14 
Como resultado, posso dizer que o C++ valoriza a eficiência (verdadeiro para 
todas as versões), que o C++ 98 não tem suporte para simultaneidade 
(verdadeiro apenas para C++ 98 e C++ 03), que o C++ 11 suporta expressões 
lambda (verdadeiro para C++11 e C++14) e que C++14 oferece dedução de 
tipo de retorno de função generalizada (verdadeiro apenas para C++14). 
O recurso mais difundido do C++ 11 é provavelmente a semântica de 
movimentação, e a base da semântica de movimentação é distinguir 
expressões que são rvalues daquelas que são lvalues . Issoestranho de todos os nomes na Biblioteca C++ 
Padrão: std:: enable_shared_from_this . Esse é um modelo para uma classe 
base da qual você herda se quiser que uma classe gerenciada por 
std::shared_ptr s seja capaz de criar com segurança um std::shared_ptr a 
partir de um ponteiro this . Em nosso exemplo, Widget herdaria de 
std::enable_shared_from_this da seguinte maneira: 
classe Widget : public std::enable_shared_from_this { 
public: 
… 
processo vazio(); 
… 
}; 
Como eu disse, std::enable_shared_from_this é um modelo de classe base. 
Seu parâmetro de tipo é sempre o nome da classe que está sendo derivada, 
então Widget herda de std::enable_shared_from_this . Se a ideia de 
uma classe derivada herdar de uma classe base modelada na classe derivada 
faz sua cabeça doer, tente não pensar nisso. O código é completamente legal 
e o padrão de design por trás dele é tão bem estabelecido que tem um nome 
padrão, embora seja quase tão estranho quanto 
std::enable_shared_from_this . O nome é O Padrão de Modelo Curiosamente 
Recorrente (CRTP) . Se quiser saber mais sobre isso, libere seu mecanismo 
de busca, pois aqui precisamos voltar a std::enable_shared_from_this . 
std::enable_shared_from_this define uma função membro que cria um 
std::shared_ptr para o objeto atual, mas faz isso sem duplicar blocos de 
controle. A função membro é shared_from_this e você a usa em funções 
membro sempre que desejar um std::shared_ptr que aponte para o mesmo 
objeto que o ponteiro this . Aqui está uma implementação segura de 
Widget::process : 
Widget vazio::process() 
{ 
 // como antes, processa o Widget 
… 
 // adiciona std::shared_ptr ao objeto atual para processedWidgets 
processWidgets.emplace_back( shared_from_this() ); 
 
 Ponto 19 | 153 
} 
Internamente, shared_from_this procura o bloco de controle do objeto atual e 
cria um novo std::shared_ptr que se refere a esse bloco de controle. O design 
depende do objeto atual ter um bloco de controle associado. Para que esse 
seja o caso, deve haver um std::shared_ptr existente (por exemplo, um fora 
da função membro que chama shared_from_this ) que aponta para o objeto 
atual. Se tal std::shared_ptr não existir (ou seja, se o objeto atual não tiver 
nenhum bloco de controle associado), o comportamento será indefinido, 
embora shared_from_this normalmente gere uma exceção. 
Para evitar que os clientes chamem funções-membro que invocam 
shared_from_this antes que um std::shared_ptr aponte para o objeto, as 
classes herdadas de std::enable_shared_from_this geralmente declaram seus 
construtores como privados e fazem com que os clientes criem objetos 
chamando funções de fábrica que retornam std:: shared_ptr s. Widget , por 
exemplo, poderia ser assim: 
classe Widget: público std::enable_shared_from_this { público: 
 //função de fábrica que encaminha argumentos perfeitamente 
 // para um setor privado modelo 
 static std::shared_ptr create(Ts&&... params); 
… 
processo vazio(); // como antes … 
privado: 
 … // atores 
}; 
Até agora, você deve se lembrar apenas vagamente de que nossa discussão 
sobre blocos de controle foi motivada pelo desejo de compreender os custos 
associados aos std::shared_ptr s. Agora que entendemos como evitar a 
criação de muitos blocos de controle, vamos voltar ao tópico original. 
Um bloco de controle normalmente tem apenas algumas palavras, embora 
deletores e alocadores personalizados possam torná-lo maior. A 
implementação usual do bloco de controle é mais sofisticada do que você 
imagina. Faz uso de herança e existe até uma função virtual. (É usado para 
garantir que o objeto apontado seja destruído corretamente.) Isso significa que 
o uso de std::shared_ptr s também incorre no custo do maquinário para a 
função virtual usada pelo bloco de controle. 
 
154 | Artigo 19 
Depois de ler sobre blocos de controle alocados dinamicamente, deletores e 
alocadores arbitrariamente grandes, máquinas de funções virtuais e 
manipulações de contagem de referência atômica, seu entusiasmo por 
std::shared_ptr s pode ter diminuído um pouco. Isso é bom. 
Eles não são a melhor solução para todos os problemas de gerenciamento de 
recursos. Mas pela funcionalidade que eles fornecem, std::shared_ptr tem um 
custo bastante razoável. Em condições típicas, onde o deleter padrão e o 
alocador padrão são usados e onde o std::shared_ptr é criado por 
std::make_shared , o bloco de controle tem apenas cerca de três palavras e 
sua alocação é essencialmente gratuita. (Ele é incorporado à alocação de 
memória do objeto para o qual está sendo apontado. Para obter detalhes, 
consulte o Item 21. ) Desreferenciar um std::shared_ptr não é mais caro do 
que desreferenciar um ponteiro bruto. Executar uma operação que requer uma 
manipulação de contagem de referência (por exemplo, construção de cópia 
ou atribuição de cópia, destruição) envolve uma ou duas operações atômicas, 
mas essas operações normalmente são mapeadas para instruções de 
máquina individuais, portanto, embora possam ser caras em comparação com 
instruções não atômicas, elas ainda são apenas instruções únicas. O 
mecanismo de função virtual no bloco de controle geralmente é usado apenas 
uma vez por objeto gerenciado por std::shared_ptr s: quando o objeto é 
destruído. 
Em troca desses custos bastante modestos, você obtém gerenciamento 
automático da vida útil dos recursos alocados dinamicamente. Na maioria das 
vezes, usar std::shared_ptr é muito preferível a tentar gerenciar manualmente 
o tempo de vida de um objeto com propriedade compartilhada. Se você estiver 
em dúvida se pode pagar pelo uso de std::shared_ptr , reconsidere se você 
realmente precisa de propriedade compartilhada. Se a propriedade exclusiva 
servir ou mesmo puder servir, std::unique_ptr é uma escolha melhor. Seu perfil 
de desempenho é próximo ao dos ponteiros brutos, e “atualizar” de 
std::unique_ptr para std:: shared_ptr é fácil, porque um std::shared_ptr pode 
ser criado a partir de um std:: unique_ptr . 
O contrário não é verdade. Depois de transferir o gerenciamento vitalício de 
um recurso para std::shared_ptr , não há como mudar de ideia. Mesmo que a 
contagem de referência seja uma, você não pode recuperar a propriedade do 
recurso para, digamos, ter um std::unique_ptr gerenciando-o. O contrato de 
propriedade entre um recurso e os std::shared_ptr s que apontam para ele é 
do tipo 'até que a morte nos separe. Sem divórcio, sem anulação, sem 
dispensas. 
 
 Ponto 19 | 155 
Outra coisa que std::shared_ptr s não pode fazer é trabalhar com arrays. Ainda 
em outra diferença de std::unique_ptr , std::shared_ptr tem uma API projetada 
apenas para ponteiros para objetos únicos. Não há std::shared_ptr . De 
vez em quando, programadores “inteligentes” tropeçam na ideia de usar um 
std::shared_ptr para apontar para um array, especificando um deleter 
personalizado para executar uma exclusão de array (ou seja, delete [] ). Isso 
pode ser compilado, mas é uma ideia horrível. Por um lado, std::shared_ptr 
não oferece operator[] , portanto, a indexação na matriz requer expressões 
estranhas baseadas na aritmética de ponteiros. Por outro lado, std::shared_ptr 
suporta conversões de ponteiro derivado para base que fazem sentido para 
objetos únicos, mas que abrem lacunas no sistema de tipos quando aplicadas 
a matrizes. (Por esse motivo, a API std::unique_ptr proíbe tais 
conversões.) Mais importante ainda, dada a variedade de alternativas do C++ 
11 para matrizes integradas (por exemplo, std::array , std::vector , std::string 
), declarar um ponteiro inteligente para um array burro é quase sempre um 
sinal de design ruim. 
Coisas para lembrar 
• std::shared_ptr s oferecem conveniência que se aproxima da coleta de 
lixo para o gerenciamento vitalício compartilhado de recursos 
arbitrários. 
• Comparados a std::unique_ptr, os objetos std::shared_ptr são 
normalmente duas vezes maiores, geram sobrecarga para blocos de 
controle e exigem manipulações de contagem de referência atômica. 
• A destruição de recursos padrão é feita por delete , mas há suporte para 
exclusões personalizadas. O tipo do deleter não tem efeito no tipo de 
std::shared_ptr . 
• Evite criar std::shared_ptr s a partir de variáveis do tipo ponteiro bruto. 
Item 20: Use std::weak_ptr para 
std::shared_ptr como ponteiros 
que podem oscilar. 
Paradoxalmente, pode ser conveniente ter um ponteiro inteligente que atue 
como um std::shared_ptr (consulte o Item 19 ), mas que não participe da 
 
156 | Artigo 19 
propriedade compartilhada do recurso apontado. Em outras palavras, um 
ponteiro como std::shared_ptr que não afeta a contagem de referências de um 
objeto. Esse tipo de ponteiro inteligente tem que lidar com um problema 
desconhecido para std::shared_ptr s: a possibilidade de que aquilo para o qual 
ele aponta tenha sido destruído. Um ponteiro verdadeiramente inteligente 
lidaria com esse problema rastreando quando ele fica pendurado , ou seja, 
quando o objeto para o qual deveria apontar não existe mais. Esse é 
exatamente o tipo de ponteiro inteligente que std::weak_ptr é. 
Você pode estar se perguntando como um std::weak_ptr pode ser útil. Você 
provavelmente se perguntará ainda mais ao examinar a API std::weak_ptr . 
Parece tudo menos inteligente. std::weak_ptr s não podem ser 
desreferenciados, nem podem ser testados quanto à nulidade. Isso ocorre 
porque std::weak_ptr não é um ponteiro inteligente independente. É um 
aumento de std::shared_ptr . 
O relacionamento começa no nascimento. std::weak_ptr s normalmente são 
criados a partir de std::shared_ptr s. Eles apontam para o mesmo local que os 
std::shared_ptr s que os inicializam, mas não afetam a contagem de referência 
do objeto para o qual apontam: 
auto spw = // após a construção do spw, std::make_shared(); 
// o widget apontado 
 
 | 157 
 // contagem de referências (RC) é 1. (Veja 
 // Item 21 para informações sobre 
 //std::make_shared.) 
… 
std::weak_ptr wpw(spw); // wpw aponta para o mesmo 
widget 
 // como spw. RC permanece 1 
… 
spw = nullptr; // RC vai para 0, e o // Widget é 
destruído. 
 // wpw agora está pendurado 
std::weak_ptr s que estão pendentes expiraram . Você pode testar isso 
diretamente, 
if (wpw. expired() )… // se wpw não apontar // para um 
objeto… mas muitas vezes o que você deseja é verificar se um std::weak_ptr 
expirou e, se não expirou (ou seja, se não estiver pendente), acessar o objeto 
para o qual ele aponta. É mais fácil desejar do que fazer. Como std::weak_ptr 
s não possui operações de desreferenciação, não há como escrever o código. 
Mesmo se houvesse, separar a verificação e a desreferência introduziria uma 
condição de corrida: entre a chamada para expirado e a ação de 
desreferenciação, outro thread poderia reatribuir ou destruir o último 
std::shared_ptr apontando para o objeto, fazendo com que esse objeto fosse 
destruído. Nesse caso, sua desreferência produziria um comportamento 
indefinido. 
O que você precisa é de uma operação atômica que verifique se std::weak_ptr 
expirou e, caso contrário, dê acesso ao objeto para o qual ele aponta. Isso é 
feito criando um std::shared_ptr a partir de std::weak_ptr . A operação vem em 
duas formas, dependendo do que você gostaria que acontecesse se 
std::weak_ptr expirou quando você tentou criar um std::shared_ptr a partir 
dele. Uma forma é std:: fraco_ptr::lock , que retorna um std::shared_ptr . O 
std::shared_ptr é nulo se o std::weak_ptr expirou: 
std::shared_ptr spw1 = wpw. trancar() ; // se o wpw expirou, 
// spw1 é nulo 
spw2 automático = wpw. trancar() ; // o mesmo que acima, 
// mas usa auto A outra forma é o construtor std::shared_ptr tomando um 
std::weak_ptr como argumento. Neste caso, se std::weak_ptr expirou, uma 
exceção é lançada: 
 
158 | 
std::shared_ptr spw3(wpw); // se o wpw expirou, 
//lança std::bad_weak_ptr 
Artigo 20 
Mas você provavelmente ainda está se perguntando como std::weak_ptr s 
pode ser útil. Considere uma função de fábrica que produz ponteiros 
inteligentes para objetos somente leitura com base em um ID exclusivo. De 
acordo com o conselho do Item 18 em relação aos tipos de retorno da função 
de fábrica, ele retorna um std::unique_ptr : std::unique_ptr 
loadWidget(WidgetID id); 
Se loadWidget for uma chamada cara (por exemplo, porque executa E/S de 
arquivo ou banco de dados) e é comum que IDs sejam usados repetidamente, 
uma otimização razoável seria escrever uma função que faça o que 
loadWidget faz, mas também armazene em cache seus resultados. Entupir o 
cache com cada Widget que já foi solicitado pode levar a problemas de 
desempenho próprios, portanto, outra otimização razoável seria destruir os 
Widget s armazenados em cache quando eles não estiverem mais em uso. 
Para esta função de fábrica de cache, um tipo de retorno std::unique_ptr não 
é uma boa opção. Os chamadores certamente devem receber ponteiros 
inteligentes para objetos armazenados em cache, e os chamadores 
certamente devem determinar o tempo de vida desses objetos, mas o cache 
também precisa de um ponteiro para os objetos. Os ponteiros do cache 
precisam ser capazes de detectar quando eles ficam pendurados, porque 
quando os clientes da fábrica terminarem de usar um objeto retornado pela 
fábrica, esse objeto será destruído e a entrada de cache correspondente ficará 
pendurada. Os ponteiros armazenados em cache devem, portanto, ser 
std::weak_ptrs —ponteiros que podem detectar quando estão pendurados. 
Isso significa que o tipo de retorno da fábrica deve ser std::shared_ptr , porque 
std::weak_ptr s pode detectar quando eles ficam pendurados apenas quando 
a vida útil de um objeto é gerenciada por std::shared_ptr s. 
Aqui está uma implementação rápida e suja de uma versão de cache de 
loadWidget : 
std::shared_ptr fastLoadWidget(ID do widget) 
{ 
static std::unordered_map > cache; 
 
 | 159 
auto objPtr = cache[id].lock(); // objPtr é std::shared_ptr 
// para o objeto armazenado em cache (ou nulo //se 
o objeto não estiver em cache) 
if (!objPtr) { // se não estiver em cache, objPtr = 
loadWidget(id); // carrega cache[id] = objPtr; //armazena em 
cache 
} 
retornar objPtr; } 
Artigo 20 
Esta implementação emprega um dos contêineres de tabela hash do C++ 11 
( std::unor dered_map ), embora não mostre as funções de hashing e 
comparação de igualdade WidgetID que também teriam que estar presentes. 
A implementação de fastLoadWidget ignora o fato de que o cache pode 
acumular std::weak_ptr s expirados correspondentes a Widget s que não 
estão mais em uso (e, portanto, foram destruídos). A implementação pode ser 
refinada, mas em vez de gastar tempo em um problema que não fornece 
informações adicionais sobre std::weak_ptr s, vamos considerar um segundo 
caso de uso: o padrão de design Observer. Os componentes primários desse 
padrão são sujeitos (objetos cujo estado pode mudar) e observadores (objetos 
a serem notificados quando ocorrerem mudanças de estado). Na maioria das 
implementações, cada sujeito contém um membro de dados que contém 
ponteiros para seus observadores. Isso torna mais fácil para os sujeitos 
emitirem notificações de mudança de estado. Os sujeitos não têm interesse 
em controlar o tempo de vida de seus observadores(isto é, quando eles são 
destruídos), mas têm grande interesse em garantir que, se um observador for 
destruído, os sujeitos não tentem acessá-lo posteriormente. Um design 
razoável é que cada sujeito mantenha um contêiner de std::weak_ptr s para 
seus observadores, possibilitando assim ao sujeito determinar se um ponteiro 
está pendurado antes de usá-lo. 
Como um exemplo final da utilidade de std::weak_ptr , considere uma 
estrutura de dados com objetos A , B e C nela, onde A e C compartilham a 
propriedade de B e, portanto, mantêm std::shared_ptr s nela: 
 
160 | 
std::shared_ptr 
Suponha que seria útil também ter um ponteiro de B de volta para A . Que tipo 
de ponteiro deveria ser esse? 
 
Existem três opções: 
• Um ponteiro bruto. Com esta abordagem, se A for destruído, mas C 
continuar apontando para B , B conterá um ponteiro para A que ficará 
pendurado. B não será capaz de detectar isso, então B pode 
inadvertidamente desreferenciar o ponteiro pendente. Isso produziria um 
comportamento indefinido. 
• Um std::shared_ptr . Neste design, A e B contêm std::shared_ptr s entre 
si. O ciclo std::shared_ptr resultante ( A aponta para B e B aponta para A 
) irá 
Artigo 20 
evitar que A e B sejam destruídos. Mesmo que A e B sejam inacessíveis 
a partir de outras estruturas de dados do programa (por exemplo, porque 
C não aponta mais para B ), cada um terá uma contagem de referência 
de um. Se isso acontecer, A e B terão sido vazados, para todos os efeitos 
práticos: será impossível para o programa acessá-los, mas os seus 
recursos nunca serão recuperados. 
• Um std::weak_ptr . Isso evita os dois problemas acima. Se A for 
destruído, o ponteiro de B de volta para ele ficará pendurado, mas B será 
capaz de detectar isso. Além disso, embora A e B apontem um para o 
outro, o ponteiro de B não afetará a contagem de referência de A e, 
portanto, não poderá impedir que A seja destruído quando std::shared_ptr 
s não apontar mais para ele. 
Usar std::weak_ptr é claramente a melhor dessas opções. No entanto, é 
importante notar que a necessidade de empregar std::weak_ptr s para quebrar 
ciclos prospectivos de std:: shared_ptr s não é muito comum. Em estruturas 
de dados estritamente hierárquicas, como árvores, os nós filhos normalmente 
 
 
 
 
 
 
 
 | 161 
pertencem apenas aos seus pais. Quando um nó pai é destruído, seus nós 
filhos também devem ser destruídos. Links de pais para filhos são geralmente 
melhor representados por std::unique_ptr s. Os backlinks dos filhos para os 
pais podem ser implementados com segurança como ponteiros brutos, porque 
um nó filho nunca deve ter uma vida útil maior que seu pai. Portanto, não há 
risco de um nó filho desreferenciar um ponteiro pai pendente. 
É claro que nem todas as estruturas de dados baseadas em ponteiros são 
estritamente hierárquicas e, quando for esse o caso, bem como em situações 
como cache e implementação de listas de observadores, é bom saber que 
std::weak_ptr está pronto. 
Do ponto de vista da eficiência, a história de std::weak_ptr é essencialmente 
a mesma de std::shared_ptr . Os objetos std::weak_ptr são do mesmo 
tamanho que os objetos std:: shared_ptr , eles usam os mesmos blocos de 
controle que std:: shared_ptr s (consulte o Item 19 ) e operações como 
construção, destruição e atribuição envolvem contagem de referência atômica 
manipulações. Isso provavelmente surpreende você, porque escrevi no início 
deste item que std::weak_ptr s não participam da contagem de referências. 
Só que não foi bem isso que escrevi. O que escrevi foi que std::weak_ptr s 
não participam da propriedade compartilhada de objetos e, portanto, não 
afetam a contagem de referência do objeto apontado . Na verdade, há uma 
segunda contagem de referência no bloco de controle, e é essa segunda 
contagem de referência que std::weak_ptr s manipula. Para obter detalhes, 
continue no Item 21 . 
Artigo 20 
 
162 | Artigo 21 
Coisas para lembrar 
• Use std::weak_ptr para ponteiros do tipo std::shared_ptr que podem 
oscilar. 
• Os casos de uso potenciais para std::weak_ptr incluem cache, listas de 
observadores e prevenção de ciclos std::shared_ptr . 
Item 21: Prefira std::make_unique e 
std::make_shared ao uso direto de 
new . 
Vamos começar nivelando o campo de jogo para std::make_unique e std:: 
make_shared . std::make_shared faz parte do C++ 11, mas, infelizmente, 
std::make_ unique não faz. Ele se juntou à Biblioteca Padrão a partir do 
C++14. Se você estiver usando C++ 11, não tenha medo, porque uma versão 
básica de std::make_unique é fácil de escrever você mesmo. Olhe aqui: 
template 
std::unique_ptr make_unique(Ts&&... params) 
{ 
return std::unique_ptr(new T(std::forward(params)...)); } 
Como você pode ver, make_unique apenas encaminha perfeitamente seus 
parâmetros para o construtor do objeto que está sendo criado, constrói um 
std::unique_ptr a partir do ponteiro bruto que new produz e retorna o 
std::unique_ptr assim criado. Esta forma da função não suporta arrays ou 
deletores personalizados (veja o Item 18 ), mas demonstra que com apenas 
um pouco de esforço, você pode criar make_unique se precisar. 9Apenas 
lembre-se de não colocar sua versão no namespace std , porque você não vai 
querer que ela entre em conflito com uma versão fornecida pelo fornecedor ao 
atualizar para uma implementação da Biblioteca Padrão C++ 14. 
std::make_unique e std::make_shared são duas das três funções make : 
funções que recebem um conjunto arbitrário de argumentos, encaminham-nos 
perfeitamente para o construtor para um objeto alocado dinamicamente e 
retornam um ponteiro inteligente para esse objeto. A terceira função make é 
 
9make_unique completo com o menor esforço possível, procure o documento de padronização que deu origem 
a ele e copie a implementação que você encontrará lá. O documento que você deseja é N3656 de Stephan T. 
Lavavej, datado de 18/04/2013. 
 
 Ponto 21 | 163 
std::allocate_shared . Ele age exatamente como std::make_shared , exceto 
que seu primeiro argumento é um objeto alocador a ser usado para a alocação 
dinâmica de memória. 
Mesmo a comparação mais trivial entre a criação de um ponteiro inteligente 
usando ou não uma função make revela a primeira razão pela qual usar tais 
funções é preferível. Considerar: 
auto upw1(std::make_unique()); // com make func 
std::unique_ptr upw2(new Widget ); // sem make func 
auto spw1(std::make_shared()); //com make função 
std::shared_ptr spw2(novo Widget ); // sem make func Destaquei 
a diferença essencial: as versões que usam new repetem o tipo que está 
sendo criado, mas as funções make não. A repetição de tipos vai contra um 
princípio fundamental da engenharia de software: a duplicação de código deve 
ser evitada. A duplicação no código-fonte aumenta o tempo de compilação, 
pode levar a um código-objeto inchado e geralmente torna a base de código 
mais difícil de trabalhar. Muitas vezes evolui para um código inconsistente, e 
a inconsistência em uma base de código geralmente leva a bugs. Além disso, 
digitar algo duas vezes exige mais esforço do que digitar uma vez, e quem 
não gosta de reduzir a carga de digitação? 
A segunda razão para preferir funções make tem a ver com segurança de 
exceções. Suponha que temos uma função para processar um Widget de 
acordo com alguma prioridade: void processWidget(std::shared_ptr 
spw, int prioridade); Passar o std::shared_ptr por valor pode parecer suspeito, 
mas o Item 41 explica que se processWidget sempre fizer uma cópia do 
std::shared_ptr (por exemplo, armazenando-o em uma estrutura de dados que 
rastreia Widget s que foram processados), isso pode ser uma escolha de 
design razoável. 
Agora suponha que temos uma função para calcular a prioridade relevante, 
int computaPrioridade();e usamos isso em uma chamada para processWidget que usa new em vez de 
std::make_shared : 
 
164 | Artigo 21 
processWidget(std::shared_ptr(new Widget), // potencial 
computaPriority()); // recurso // vazar! 
Como o comentário indica, esse código pode vazar o widget criado por new . 
Mas como? Tanto o código de chamada quanto a função chamada usam 
std::shared_ptr s e std::shared_ptr s são projetados para evitar vazamentos 
de recursos. Eles destroem automaticamente o que apontam quando o último 
std::shared_ptr apontando para lá desaparece. Se todo mundo está usando 
std::shared_ptr s em todos os lugares, como esse código pode vazar? A 
resposta tem a ver com a tradução do código-fonte em código-objeto pelos 
compiladores. Em tempo de execução, os argumentos de uma função devem 
ser avaliados antes que a função possa ser invocada, portanto, na chamada 
para processWidget , as seguintes coisas devem ocorrer antes que 
processWidget possa iniciar a execução: 
• A expressão “ novo Widget ” deve ser avaliada, ou seja, um Widget deve 
ser criado no heap. 
• O construtor do std::shared_ptr responsável por gerenciar o 
ponteiro produzido por new deve ser executado. 
• computaPriority deve ser executado. 
Os compiladores não são obrigados a gerar código que os execute nesta 
ordem. “ new Widget ” deve ser executado antes que o construtor 
std::shared_ptr possa ser chamado, porque o resultado desse new é usado 
como um argumento para esse construtor, mas compute Priority pode ser 
executado antes dessas chamadas, depois delas, ou, crucialmente, entre 
eles. Ou seja, os compiladores podem emitir código para executar as 
operações nesta ordem: 
1. Execute “ novo widget ”. 
2. Execute computaPrioridade . 
3. Execute o construtor std::shared_ptr . 
Se tal código for gerado e, em tempo de execução, computePriority produzir 
uma exceção, o Widget alocado dinamicamente da Etapa 1 vazará, porque 
nunca será armazenado no std::shared_ptr que deveria começar a gerenciá-
lo na Etapa 3. 
Usar std::make_shared evita esse problema. O código de chamada ficaria 
assim: 
 
 Ponto 21 | 165 
processWidget( std::make_shared() , // sem potencial 
computePriority()); //vazamento de recurso 
Em tempo de execução, std::make_shared ou computePriority serão 
chamados primeiro. Se for std::make_shared , o ponteiro bruto para o Widget 
alocado dinamicamente é armazenado com segurança no std::shared_ptr 
retornado antes que computePriority seja chamado. Se compu tePriority gerar 
uma exceção, o destruidor std::shared_ptr fará com que o widget que ele 
possui seja destruído. E se computaPriority for chamado primeiro e gerar uma 
exceção, std::make_shared não será invocado e, portanto, não haverá 
nenhum widget alocado dinamicamente com o qual se preocupar. 
Se substituirmos std::shared_ptr e std::make_shared por std::unique_ptr e 
std::make_unique , exatamente o mesmo raciocínio se aplica. Usar 
std::make_unique em vez de new é, portanto, tão importante para escrever 
código seguro contra exceções quanto usar std::make_shared . 
Um recurso especial de std::make_shared (em comparação com o uso direto 
de new ) é a eficiência aprimorada. Usar std::make_shared permite que os 
compiladores gerem código menor e mais rápido que emprega estruturas de 
dados mais enxutas. Considere o seguinte uso direto de new : 
std::shared_ptr spw(new Widget); 
É óbvio que este código implica uma alocação de memória, mas na verdade 
executa duas. O item 19 explica que todo std::shared_ptr aponta para um 
bloco de controle contendo, entre outras coisas, a contagem de referência 
para o objeto apontado. A memória para este bloco de controle é alocada no 
construtor std::shared_ptr . O uso direto de new requer, então, uma alocação 
de memória para o Widget e uma segunda alocação para o bloco de controle. 
Se std::make_shared for usado, auto spw = 
std::make_shared(); 
uma alocação é suficiente. Isso ocorre porque std::make_shared aloca um 
único pedaço de memória para armazenar o objeto Widget e o bloco de 
controle. Essa otimização reduz o tamanho estático do programa, pois o 
código contém apenas uma chamada de alocação de memória, e aumenta a 
velocidade do código executável, pois a memória é alocada apenas uma vez. 
Além disso, o uso de std::make_shared elimina a necessidade de algumas 
informações contábeis no bloco de controle, reduzindo potencialmente o 
consumo total de memória do programa. 
 
166 | Artigo 21 
A análise de eficiência para std::make_shared é igualmente aplicável a 
std::allo cate_shared , portanto, as vantagens de desempenho de 
std::make_shared se estendem a essa função também. 
Os argumentos para preferir funções make ao uso direto de new são fortes. 
Apesar de suas vantagens de engenharia de software, segurança de exceção 
e eficiência, a orientação deste item é preferir as funções make , e não confiar 
exclusivamente nelas. Isso porque há circunstâncias em que eles não podem 
ou não devem ser usados. 
Por exemplo, nenhuma das funções make permite a especificação de 
deletores personalizados 
(consulte os itens 18 e 19 ), mas ambos std::unique_ptr e std::shared_ptr têm 
construtores que o fazem. Dado um deleter personalizado para um Widget , 
auto widgetDeleter = [](Widget* pw) {… }; criar um 
ponteiro inteligente usando-o é simples usando new : 
std::unique_ptr upw( novo 
Widget , widgetDeleter ); 
std::shared_ptr spw( novo Widget , widgetDeleter ); Não 
há como fazer a mesma coisa com uma função make . 
Uma segunda limitação das funções make decorre de um detalhe sintático de 
suas implementações. O item 7 explica que ao criar um objeto cujo tipo 
sobrecarrega construtores com e sem parâmetros std::initializer_list , a criação 
do objeto usando colchetes prefere o construtor std::initializer_list , enquanto 
a criação do objeto usando parênteses chama o construtor não 
std::initializer_list . As funções make encaminham perfeitamente seus 
parâmetros para o construtor de um objeto, mas elas fazem isso usando 
parênteses ou colchetes? Para alguns tipos, a resposta a esta pergunta faz 
uma grande diferença. Por exemplo, nessas chamadas, auto upv = 
std::make_unique>(10, 20); spv automático = 
std::make_shared>(10, 20); os ponteiros inteligentes 
resultantes apontam para std::vector s com 10 elementos, cada um com valor 
20, ou para std::vector s com dois elementos, um com valor 10 e outro com 
valor 20? Ou o resultado é indeterminado? 
 
 Ponto 21 | 167 
A boa notícia é que não é indeterminado: ambas as chamadas criam 
std::vector s de tamanho 10 com todos os valores definidos como 20. Isso 
significa que dentro das funções make , o código de encaminhamento perfeito 
usa parênteses, não colchetes. A má notícia é que se você quiser construir 
seu objeto apontado usando um inicializador reforçado, você deve usar new 
diretamente. Usar uma função make exigiria a capacidade de encaminhar com 
perfeição um inicializador contraventado, mas, como explica o Item 30 , 
inicializadores com contraventamento não podem ser encaminhados com 
perfeição. No entanto, o Item 30 também descreve uma solução alternativa: 
use a dedução automática de tipo para criar um objeto std::ini tializer_list a 
partir de um inicializador entre chaves (consulte o Item 2 ) e, em seguida, 
passe o objeto criado automaticamente pela função make : 
// cria std::initializer_list auto initList = 
{ 10, 20 }; 
// cria std::vector usando std::initializer_list ctor auto spv = 
std::make_shared>( initList ); 
Para std::unique_ptr , esses dois cenários (deletadores personalizados e 
inicializadores reforçados) são os únicos em que suas funções make são 
problemáticas. Para std::shared_ptr e suas funções make , existem mais duas. 
Ambos são casos extremos,mas alguns desenvolvedores vivem no limite e 
você pode ser um deles. 
Algumas classes definem suas próprias versões do operador novo e operador 
excluir . A presença dessas funções implica que as rotinas de alocação e 
desalocação de memória global para objetos desses tipos são inadequadas. 
Freqüentemente, rotinas específicas de classe são projetadas apenas para 
alocar e desalocar pedaços de memória precisamente do tamanho dos 
objetos da classe, por exemplo, operador novo e operador delete for class 
Widget geralmente são projetados apenas para lidar com a alocação e 
desalocação de pedaços de memória de tamanho exato sizeof(Widget) . 
Essas rotinas são inadequadas para o suporte de std::shared_ptr para 
alocação personalizada (via std::allocate_shared ) e desalocação (por meio 
de exclusões personalizadas), porque a quantidade de memória que 
std::allocate_shared solicita não é o tamanho do objeto alocado 
dinamicamente, é o tamanho desse objeto mais o tamanho de um bloco de 
controle. Conseqüentemente, o uso de funções make para criar objetos de 
tipos com versões específicas de classe do operador novo e operador excluir 
normalmente é uma má ideia. 
 
168 | Artigo 21 
As vantagens de tamanho e velocidade de std::make_shared em relação ao 
uso direto do novo radical do bloco de controle de std::shared_ptr sendo 
colocado no mesmo pedaço de memória que o objeto gerenciado. Quando a 
contagem de referências desse objeto chega a zero, o objeto é destruído (ou 
seja, seu destruidor é chamado). No entanto, a memória que ocupa não pode 
ser liberada até que o bloco de controle também seja destruído, porque o 
mesmo pedaço de memória alocada dinamicamente contém ambos. 
Como observei, o bloco de controle contém informações contábeis além da 
própria contagem de referência. A contagem de referência rastreia quantos 
std::shared_ptr s se referem ao bloco de controle, mas o bloco de controle 
contém uma segunda contagem de referência, que registra quantos 
std::weak_ptr s se referem ao bloco de controle. Esta segunda contagem de 
referência é conhecida como contagem fraca . 10Quando um std::weak_ptr 
verifica se expirou (consulte o Item 19 ), ele faz isso examinando a contagem 
de referência (não a contagem fraca) no bloco de controle ao qual se refere. 
Se a contagem de referência for zero (ou seja, se o objeto apontado não tiver 
std::shared_ptr s referentes a ele e, portanto, tiver sido destruído), o 
std::weak_ptr expirou. Caso contrário, não aconteceu. 
Enquanto std::weak_ptr s se referirem a um bloco de controle (ou seja, a 
contagem fraca for maior que zero), esse bloco de controle deverá continuar 
a existir. E enquanto existir um bloco de controle, a memória que o contém 
deve permanecer alocada. A memória alocada por um std::shared_ptr A 
função make , então, não pode ser desalocada até o último std::shared_ptr e 
o último std::weak_ptr referente a ele foi destruído. 
Se o tipo de objeto for muito grande e o tempo entre a destruição do último 
std::shared_ptr e o último std::weak_ptr for significativo, pode ocorrer um 
atraso entre o momento em que um objeto é destruído e quando a memória 
que ele ocupava é liberada: class ReallyBigType {…}; 
auto pBigObj = //cria muito grande std::make_shared 
(); //objeto via 
//std::make_shared 
 
10Na prática, o valor da contagem fraca nem sempre é igual ao número de std::weak_ptr s referentes ao 
bloco de controle, porque os implementadores da biblioteca encontraram maneiras de inserir informações 
adicionais na contagem fraca que facilitam uma melhor geração de código. Para os propósitos deste item, vamos 
ignorar isso e assumir que o valor da contagem fraca é o número de std::weak_ptr s referentes ao bloco 
de controle. 
 
 Ponto 21 | 169 
… // cria std::shared_ptrs e std::weak_ptrs para 
 // objeto grande, use-os para trabalhar com ele 
… // final std::shared_ptr para o objeto destruído aqui, 
 // mas std::weak_ptrs permanece 
… // durante este período, a memória anteriormente ocupada 
 // por objeto grande permanece alocado 
… // final std::weak_ptr para objeto destruído aqui; 
 // memória para bloco de controle e objeto é liberada Com o uso direto 
de new , a memória para o objeto ReallyBigType pode ser liberada assim que 
o último std::shared_ptr dele for destruído: 
classe ReallyBigType {…}; // como antes 
std::shared_ptr pBigObj( novo ReallyBigType); 
//cria muito grande 
 //objeto via new 
… // como antes, crie std::shared_ptrs e 
 // std::weak_ptrs para objetar, use-os com ele 
… // final std::shared_ptr para o objeto destruído aqui, 
 // mas std::weak_ptrs permanece; 
 // a memória do objeto é desalocada 
… // durante este período, apenas memória para o 
 // bloco de controle permanece alocado 
… // final std::weak_ptr para objeto destruído aqui; 
 //memória para bloco de controle é liberada 
Caso você se encontre em uma situação em que o uso de std::make_shared 
seja impossível ou inapropriado, você deverá se proteger contra os tipos de 
problemas de segurança de exceção que vimos anteriormente. A melhor 
maneira de fazer isso é garantir que, ao usar new diretamente, você passe 
imediatamente o resultado para um construtor de ponteiro inteligente em uma 
instrução que não faz mais nada . Isso evita que os compiladores gerem 
código que possa emitir uma exceção entre o uso de new e a invocação do 
construtor do ponteiro inteligente que gerenciará o novo objeto ed. 
 
170 | Artigo 21 
Como exemplo, considere uma pequena revisão na chamada de exceção 
insegura para a função Widget do processo que examinamos anteriormente. 
Desta vez, especificaremos um deleter personalizado: 
void processWidget(std::shared_ptr spw, // como antes int 
prioridade); 
void cusDel(Widget *ptr); // personalizado // 
deleter Aqui está a chamada de exceção insegura: 
processWidget( // como antes, std::shared_ptr(new Widget, 
cusDel), // potencial computaPriority() // recurso ); // vazar! 
Lembre-se: se computaPriority for chamado depois de “ new Widget ”, mas 
antes do construtor std::shared_ptr , e se computaPriority gerar uma exceção, 
o widget alocado dinamicamente será vazado. 
Aqui, o uso de um deleter personalizado impede o uso de std::make_shared , 
então a maneira de evitar o problema é colocar a alocação do Widget e a 
construção do std::shared_ptr em sua própria instrução e, em seguida, chamar 
processWidget com o resultado std::shared_ptr . Aqui está a essência da 
técnica, porém, como veremos em breve, podemos ajustá-la para melhorar 
seu desempenho: std::shared_ptr spw(new Widget, cusDel); 
processWidget(spw,computePriority()); // correto, mas não 
// ótimo; Veja abaixo 
Isso funciona porque std::shared_ptr assume a propriedade do ponteiro bruto 
passado para seu construtor, mesmo que esse construtor produza uma 
exceção. Neste exemplo, se o construtor de spw lançar uma exceção (por 
exemplo, devido à incapacidade de alocar memória dinamicamente para um 
bloco de controle), ainda é garantido que cusDel será invocado no ponteiro 
resultante de “ new Ferramenta ". 
O pequeno problema de desempenho é que, na chamada de exceção 
insegura, estamos passando um rvalue para processWidget , 
processWidget( 
 std::shared_ptr(new Widget, cusDel) , // arg é rvalue 
computaPrioridade() ); 
mas na chamada segura para exceções, estamos passando um lvalue: 
processWidget( spw , computaPriority()); // arg é lvalue Como o parâmetro 
std::shared_ptr de processWidget é passado por valor, a construção a partir 
de um rvalue envolve apenasuma movimentação, enquanto a construção a 
 
 Ponto 21 | 171 
partir de um lvalue requer uma cópia. Para std::shared_ptr , a diferença pode 
ser significativa, porque copiar um std::shared_ptr requer um incremento 
atômico de sua contagem de referência, enquanto mover um std::shared_ptr 
não requer nenhuma manipulação de contagem de referência. Para que o 
código seguro para exceções atinja o nível de desempenho do código não 
seguro para exceções, precisamos aplicar std::move a spw para transformá-
lo em um rvalue (consulte o Item 23 ): 
processWidget( std::move( spw ) , // eficiente e computePriority()); // 
exceção segura 
Isso é interessante e vale a pena saber, mas normalmente também é 
irrelevante, porque você raramente terá um motivo para não usar uma função 
make . E a menos que você tenha um motivo convincente para fazer o 
contrário, usar uma função make é o que você deve fazer. 
Coisas para lembrar 
• Em comparação com o uso direto de new , as funções make eliminam 
a duplicação de código-fonte, melhoram a segurança de exceções e, 
para std::make_shared e std::allo cate_shared , geram código menor e 
mais rápido. 
• Situações em que o uso de funções make é inapropriado incluem a 
necessidade de especificar deletores personalizados e o desejo de 
passar inicializadores reforçados. 
• Para std::shared_ptr s, situações adicionais em que as funções make 
podem ser desaconselhadas incluem (1) classes com gerenciamento de 
memória personalizado e (2) sistemas com problemas de memória, 
objetos muito grandes e std::weak_ptr s que sobrevivem ao std 
correspondente ::shared_ptrs . 
Item 22: Ao usar o idioma Pimpl, defina 
funções de membro especiais no 
arquivo de implementação. 
Se você já teve que lidar com tempos de construção excessivos, você está 
familiarizado com o idioma Pimpl (“ponteiro para implementação”) . Essa é a 
 
172 | Artigo 21 
técnica pela qual você substitui os membros de dados de uma classe por um 
ponteiro para uma classe de implementação (ou estrutura), coloca o 
 
 Ponto 22 | 173 
membros de dados que costumavam estar na classe primária na classe de 
implementação e acessam esses membros de dados indiretamente por meio 
do ponteiro. Por exemplo, suponha que o widget tenha esta aparência: 
class Widget { // no cabeçalho "widget.h" public: 
Ferramenta(); 
… privado: std::string nome; 
std::vector dados; 
Dispositivo g1, g2, g3; // Gadget é algum usuário- 
}; //tipo definido 
Como os membros de dados do Widget são dos tipos std::string , std::vector 
e Gadget , os cabeçalhos desses tipos devem estar presentes para que o 
Widget seja compilado, e isso significa que os clientes do Widget devem # 
incluir , e gadget.h . Esses cabeçalhos aumentam o tempo 
de compilação para clientes Widget , além de tornarem esses clientes 
dependentes do conteúdo dos cabeçalhos. Se o conteúdo de um cabeçalho 
for alterado, 
de widget devem ser recompilados. Os cabeçalhos padrão e 
não mudam com muita frequência, mas pode ser que gadget.h esteja sujeito 
a revisões frequentes. 
Aplicar o idioma Pimpl em C++ 98 poderia fazer com que o Widget substituísse 
seus membros de dados por um ponteiro bruto para uma estrutura que foi 
declarada, mas não definida: 
class Widget { // ainda no cabeçalho "widget.h" public: 
Ferramenta(); 
~Widget(); // dtor é necessário—veja abaixo 
… 
privado: estrutura Impl; //declara estrutura de 
implementação 
 Impl *pImpl; // e ponteiro para ele 
}; 
Como Widget não menciona mais os tipos std::string , std::vector e Gadget , 
os clientes Widget não precisam mais #include os cabeçalhos para esses 
tipos. Isso acelera a compilação e também significa que, se algo nesses 
cabeçalhos mudar, os clientes Widget não serão afetados. 
Um tipo que foi declarado, mas não definido, é conhecido como tipo 
incompleto . Widget::Impl é um desses tipos. Existem poucas coisas que você 
 
174 | Artigo 22 
pode fazer com um tipo incompleto, mas declarar um ponteiro para ele é uma 
delas. O Pimpl Idiom tira vantagem disso. 
A Parte 1 do Pimpl Idiom é a declaração de um membro de dados que é um 
ponteiro para um tipo incompleto. A Parte 2 é a alocação e desalocação 
dinâmica do objeto que contém os membros de dados que costumavam estar 
na classe original. O código de alocação e desalocação vai no arquivo de 
implementação, por exemplo, para Widget , em widget.cpp : 
#include "widget.h" // em impl. arquivo "widget.cpp" 
#incluir "gadget.h" 
#include #include 
 
struct Widget::Impl { // definição de Widget::Impl std::string name; //com 
membros de dados anteriormente 
std::vector dados; // no widget 
Dispositivo g1, g2, g3; 
}; 
Widget::Widget() // aloca membros de dados para 
: pImpl( new Impl ) // este objeto Widget 
{} 
Widget::~Widget() // destrói membros de dados para 
{ excluir pImpl; } // este objeto 
Aqui estou mostrando as diretivas #include para deixar claro que as 
dependências gerais nos cabeçalhos de std::string , std::vector e Gadget 
continuam a existir. No entanto, essas dependências foram movidas de 
widget.h (que é visível e usado por clientes Widget ) para widget.cpp (que é 
visível e usado apenas pelo implementador de Widget ). Também destaquei o 
código que aloca e desaloca dinamicamente o objeto Impl . A necessidade de 
desalocar este objeto quando um Widget é destruído é o que necessita do 
destruidor de Widget . 
Mas eu mostrei o código C++ 98, e isso cheira a um milênio passado. Ele usa 
ponteiros brutos e exclusão bruta e nova e é tudo tão...cru. Este capítulo é 
construído sobre a ideia de que ponteiros inteligentes são preferíveis a 
ponteiros brutos, e se o que queremos é alocar dinamicamente um objeto 
Widget::Impl dentro do construtor Widget e destruí-lo ao mesmo tempo que o 
Widget é, std:: unique_ptr (veja Item 18 ) é precisamente a ferramenta que 
 
 Ponto 22 | 175 
precisamos. Substituir o ponteiro pImpl bruto por um std::unique_ptr produz 
este código para o arquivo de cabeçalho, 
class Widget { // em "widget.h" public: 
Ferramenta(); 
… privado: 
estrutura 
Impl; 
 std::unique_ptr pImpl; // usa ponteiro inteligente }; // em vez 
do ponteiro bruto e isto para o arquivo de implementação: 
#include "widget.h" // em "widget.cpp" 
#incluir "gadget.h" 
#include #include 
 
struct Widget::Impl { // como antes 
std::string nome; std::vector 
dados; 
Dispositivo g1, g2, g3; 
}; 
Widget::Widget() // por Item 21 , crie 
: pImpl( std::make_unique() ) // std::unique_ptr 
{} // via std::make_unique 
Você notará que o destruidor de widget não está mais presente. Isso porque 
não temos código para inserir nele. std::unique_ptr exclui automaticamente o 
que aponta quando (o std::unique_ptr ) é destruído, portanto, não precisamos 
excluir nada nós mesmos. Esse é um dos atrativos dos ponteiros inteligentes: 
eles eliminam a necessidade de sujarmos as mãos com a liberação manual 
de recursos. 
Este código compila, mas, infelizmente, o uso mais trivial do cliente não: 
#incluir "widget.h" 
Widget com; //erro! 
A mensagem de erro que você recebe depende do compilador que você está 
usando, mas o texto geralmente menciona algo sobre a aplicação de sizeof 
 
176 | Artigo 22 
ou delete a um tipo incompleto. Essas operações não estão entre as coisas 
que você pode fazer com esses tipos. 
Essa aparente falha do Pimpl Idiom usando std::unique_ptr s é alarmante, 
porque (1) std::unique_ptr é anunciado como compatível com tipos 
incompletos e (2) o Pimpl Idiom é um dos casos de uso mais comuns de 
std::unique_ptr s . Felizmente, fazer o código funcionar é fácil. Tudo o que é 
necessário é uma compreensão básica da causa do problema. 
O problema surge devido ao código gerado quando w é destruído (por 
exemplo, sai do escopo). Nesse ponto, seu destruidor é chamado. Na 
definiçãoda classe usando std::unique_ptr , não declaramos um destruidor, 
porque não tínhamos nenhum código para colocar nele. De acordo com as 
regras usuais para funções-membro especiais geradas pelo compilador 
(consulte o Item 17 ), o compilador gera um destruidor para nós. Dentro desse 
destruidor, o compilador insere código para chamar o destruidor do membro 
de dados do Widget pImpl . pImpl é um std::unique_ptr , ou 
seja, um std::unique_ptr usando o deleter padrão. O deleter padrão é uma 
função que usa delete no ponteiro bruto dentro de std::unique_ptr . Antes de 
usar delete , no entanto, as implementações normalmente fazem com que o 
deleter padrão empregue o static_assert do C++ 11 para garantir que o 
ponteiro bruto não aponte para um tipo incompleto. Quando o compilador gera 
código para a destruição do widget w , geralmente encontra um static_assert 
que falha, e geralmente é isso que leva à mensagem de erro. Esta mensagem 
está associada ao ponto onde w é destruído, porque o destruidor do Widget , 
como todas as funções-membro especiais geradas pelo compilador, está 
implicitamente inline . A mensagem em si geralmente se refere à linha onde w 
é criado, porque é o código-fonte que cria explicitamente o objeto que leva à 
sua posterior destruição implícita. 
Para corrigir o problema, você só precisa ter certeza de que no ponto onde o 
código para destruir o std::unique_ptr é gerado, Widget::Impl é 
um tipo completo. O tipo fica completo quando sua definição é vista e 
Widget::Impl é definido dentro de widget.cpp . A chave para uma compilação 
bem-sucedida, então, é fazer com que o compilador veja o corpo do destruidor 
do Widget (ou seja, o local onde o compilador irá gerar código para destruir o 
membro de dados std::unique_ptr ) apenas dentro de widget.cpp após Widget: 
:Impl foi definido. 
Organizar isso é simples. Declare o destruidor do Widget em widget.h , mas 
não o defina lá: 
class Widget { // como antes, em "widget.h" public: 
 
 Ponto 22 | 177 
Ferramenta(); 
 ~Widget(); // declaração apenas 
… 
privado: // como antes 
estrutura Impl; 
std::unique_ptr pImpl; }; 
Defina-o em widget.cpp após Widget::Impl ter sido definido: 
#include "widget.h" // como antes, em "widget.cpp" 
#incluir "gadget.h" 
#include #include struct Widget::Impl { // como 
antes, definição de std::string name; // Widget::Impl 
std::vector dados; 
Dispositivo g1, g2, g3; 
}; 
Widget::Widget() // como antes 
: pImpl(std::make_unique()) 
{} 
Widget::~Widget() // ~Definição do widget 
{} 
Isso funciona bem e requer o mínimo de digitação, mas se você quiser 
enfatizar que o destruidor gerado pelo compilador faria a coisa certa - que a 
única razão pela qual você o declarou foi para fazer com que sua definição 
fosse gerada no arquivo de implementação do Widget , você pode definir o 
corpo do destruidor com “ = padrão ": 
Widget::~Widget() = padrão; // mesmo efeito acima 
Classes que usam o idioma Pimpl são candidatas naturais ao suporte de 
movimentação, porque as operações de movimentação geradas pelo 
compilador fazem exatamente o que é desejado: executar uma movimentação 
no std::unique_ptr subjacente . Como explica o Item 17 , a declaração de um 
destruidor no Widget evita que os compiladores gerem as operações de 
movimentação, portanto, se você quiser suporte à movimentação, deverá 
declarar as funções você mesmo. Dado que as versões geradas pelo 
compilador se comportariam corretamente, você provavelmente ficará tentado 
a implementá-las da seguinte maneira: 
class Widget { // ainda em público: // "widget.h" 
 
178 | Artigo 22 
Ferramenta(); 
~Widget(); 
 Widget(Widget&& rhs) = padrão; // ideia certa, Widget& 
operador=(Widget&& rhs) = padrão; // Código errado! 
 
… 
privado: // como antes 
estrutura Impl; 
std::unique_ptr pImpl; }; 
Essa abordagem leva ao mesmo tipo de problema que declarar a classe sem 
um destruidor, e pela mesma razão fundamental. O operador de atribuição de 
movimentação gerado pelo compilador precisa destruir o objeto apontado por 
pImpl antes de reatribuí-lo, mas no arquivo de cabeçalho do widget , pImpl 
aponta para um tipo incompleto. A situação é diferente para o construtor de 
movimento. O problema é que os compiladores normalmente geram código 
para destruir o pImpl no caso de surgir uma exceção dentro do construtor de 
movimentação, e a destruição do pImpl requer que o Impl seja concluído. 
Como o problema é o mesmo de antes, a solução também é: mova a definição 
das operações de movimentação para o arquivo de implementação: 
class Widget { // ainda em "widget.h" public: 
Ferramenta(); 
~Widget(); 
 Widget(Widget&& rhs); // declarações 
 Widget& operador=(Widget&& rhs); // apenas 
… 
privado: // como antes 
estrutura Impl; 
std::unique_ptr pImpl; }; 
#include // como antes, 
… // em "widget.cpp" struct Widget::Impl { … }; // como antes 
Widget::Widget() // como antes 
: pImpl(std::make_unique()) 
{} 
 
 Ponto 22 | 179 
Widget::~Widget() = padrão; // como antes 
Widget::Widget(Widget&& rhs) = padrão; // defini- 
Widget& Widget::operator=(Widget&& rhs) = padrão; // ções 
O idioma Pimpl é uma forma de reduzir as dependências de compilação entre 
a implementação de uma classe e os clientes da classe, mas, 
conceitualmente, o uso do idioma não altera o que a classe representa. A 
classe Widget original continha membros de dados std::string , std::vector e 
Gadget e, assumindo que Gadget s, como std::string s e s td::vector s, podem 
ser copiados, faria sentido para Widget para apoiar as operações de cópia. 
Temos que escrever essas funções nós mesmos, porque (1) os compiladores 
não gerarão operações de cópia para classes com tipos somente de 
movimentação como std::unique_ptr e (2) mesmo que o fizessem, as funções 
geradas copiariam apenas o std:: unique_ptr (ou seja, realizar uma cópia 
superficial ) e queremos copiar o que o ponteiro aponta (ou seja, realizar uma 
cópia profunda ). 
Num ritual que já é familiar, declaramos as funções no arquivo de cabeçalho 
e as implementamos no arquivo de implementação: 
class Widget { // ainda em "widget.h" public: … // outras funções, como 
antes 
 Widget(const Widget& rhs); // declarações 
 Widget& operador=(const Widget& rhs); // apenas 
privado: // como antes 
estrutura Impl; 
std::unique_ptr pImpl; }; 
#include "widget.h" // como antes, 
… // em "widget.cpp" struct Widget::Impl { … }; // como antes 
Widget::~Widget() = default; // outras funções, como antes 
Widget::Widget(const Widget& rhs) //copia o ctor 
: pImpl(std::make_unique(*rhs.pImpl)) 
{} 
Widget& Widget::operator=(const Widget& rhs) //operador de 
cópia= 
{ 
 
180 | Artigo 22 
 *pImpl = *rhs.pImpl; 
retorne *isto; } 
Ambas as implementações de funções são convencionais. Em cada caso, 
simplesmente copiamos os campos da estrutura Impl do objeto de origem ( 
rhs ) para o objeto de destino ( *this ). Em vez de copiar os campos um por 
um, aproveitamos o fato de que os compiladores criarão as operações de 
cópia para Impl e essas operações copiarão cada campo automaticamente. 
Assim, implementamos as operações de cópia de Widget chamando as 
operações de cópia geradas pelo compilador de Widget::Impl . No construtor 
de cópia, observe que ainda seguimos o conselho do Item 21 para preferir o 
uso de std::make_unique ao uso direto de new . 
Para fins de implementação do idioma Pimpl, std::unique_ptr é o ponteiro 
inteligente a ser usado, porque o ponteiro pImpl dentro de um objeto (por 
exemplo, dentro de um Widget ) tem propriedade exclusiva do objeto de 
implementação correspondente (por exemplo, o objeto Widget::Impl ). Ainda 
assim, é interessante notar que se usássemos std::shared_ptr emvez de 
std::unique_ptr para pImpl , descobriríamos que o conselho deste item não se 
aplica mais. Não haveria necessidade de declarar um destruidor em Widget e, 
sem um destruidor declarado pelo usuário, os compiladores gerariam 
alegremente as operações de movimentação, que fariam exatamente o que 
gostaríamos que fizessem. Ou seja, dado este código em widget.h , 
class Widget { // em "widget.h" public: 
Ferramenta(); 
… // sem declarações para dtor 
 // ou mova as operações para privadas: 
estrutura Impl; 
 std::shared_ptr pImpl; // std::shared_ptr }; // em vez de 
std::unique_ptr e este código do cliente que #include s widget.h , Widget 
w1; automático w2(std::move(w1)); //mover-construir w2 
w1 = std::move(w2); //mover-atribuir w1 
tudo seria compilado e executado como esperávamos: w1 seria construído por 
padrão, seu valor seria movido para w2 , esse valor seria movido de volta para 
w1 e então ambos w1 e w2 seriam destruídos (causando assim o apontado 
para Widget::Impl objeto a ser destruído). 
A diferença de comportamento entre std::unique_ptr e std::shared_ptr para 
ponteiros pImpl decorre das diferentes maneiras pelas quais esses ponteiros 
 
 Ponto 22 | 181 
inteligentes suportam exclusões personalizadas. Para std::unique_ptr , o tipo 
de deleter faz parte do tipo de ponteiro inteligente e isso permite que os 
compiladores gerem estruturas de dados de tempo de execução menores e 
código de tempo de execução mais rápido. Uma consequência desta maior 
eficiência é que os tipos apontados devem ser completos quando funções 
especiais geradas pelo compilador (por exemplo, destruidores ou operações 
de movimentação) são usadas. Para std::shared_ptr , o tipo do deleter não faz 
parte do tipo do ponteiro inteligente. Isso exige estruturas de dados de tempo 
de execução maiores e código um pouco mais lento, mas os tipos apontados 
não precisam estar completos quando funções especiais geradas pelo 
compilador são empregadas. 
Para o idioma Pimpl, não há realmente uma compensação entre as 
características de std::unique_ptr e std::shared_ptr , porque o relacionamento 
entre classes como Widget e classes como Widget::Impl é propriedade 
exclusiva, e isso torna std:: unique_ptr a ferramenta adequada para o trabalho. 
No entanto, vale a pena saber que em outras situações - situações em que 
existe propriedade compartilhada (e std::shared_ptr é, portanto, uma escolha 
de design adequada), não há necessidade de passar pelos obstáculos de 
definição de função que o uso de std::unique_ptr implica. 
Coisas para lembrar 
• O Pimpl Idiom diminui o tempo de construção, reduzindo as 
dependências de compilação entre clientes de classe e implementações 
de classe. 
• Para std::unique_ptr Ponteiros pImpl declaram funções de membro 
especiais no cabeçalho da classe, mas as implementam no arquivo de 
implementação. Faça isso mesmo que as implementações de função 
padrão sejam aceitáveis. 
• O conselho acima se aplica a std::unique_ptr , mas não a 
std::shared_ptr . 
 
182 
CAPÍTULO 5 
Referências Rvalue, 
Semântica de Movimento e 
Encaminhamento Perfeito 
Quando você aprende sobre eles pela primeira vez, a semântica de 
movimento e o encaminhamento perfeito parecem bastante simples: 
• A semântica de movimentação permite que os compiladores 
substituam operações de cópia dispendiosas por movimentações 
menos dispendiosas. Da mesma forma que os construtores de cópia e 
os operadores de atribuição de cópia fornecem controle sobre o que 
significa copiar objetos, os construtores de movimentação e os 
operadores de atribuição de movimentação oferecem controle sobre a 
semântica da movimentação. A semântica de movimentação também 
permite a criação de tipos somente de movimentação, como 
std::unique_ptr , std::future e std::thread . 
• O encaminhamento perfeito torna possível escrever modelos de 
função que recebem argumentos arbitrários e os encaminham para 
outras funções, de modo que as funções de destino recebam 
exatamente os mesmos argumentos que foram passados para o 
encaminhamento 
funções. 
 
 Ponto 23 | 183 
As referências Rvalue são a cola que une esses dois recursos bastante 
díspares. Eles são o mecanismo subjacente da linguagem que faz mover a 
semântica e 
encaminhamento perfeito possível. 
Quanto mais experiência você tiver com esses recursos, mais perceberá que 
sua impressão inicial foi baseada apenas na ponta metafórica do proverbial 
iceberg. O mundo da semântica de movimentação, encaminhamento perfeito 
e referências de valor é mais matizado do que parece. std::move não move 
nada, por exemplo, e o encaminhamento perfeito é imperfeito. As operações 
de movimentação nem sempre são mais baratas que a cópia; quando são, 
nem sempre são tão baratos quanto você esperaria; e nem sempre são 
chamados em um contexto onde a movimentação é válida. A construção “ type 
&& ” nem sempre representa uma referência de rvalue. 
Não importa o quanto você se aprofunde nesses recursos, pode parecer que 
sempre há mais para descobrir. Felizmente, há um limite para a sua 
profundidade. Este capítulo o levará ao alicerce. Assim que você chegar, esta 
parte do C++ 11 fará muito mais sentido. Você conhecerá as convenções de 
uso de std::move e std::forward , por exemplo. Você se sentirá confortável com 
a natureza ambígua do “ tipo && ”. Você entenderá as razões dos perfis 
comportamentais surpreendentemente variados das operações de 
movimentação. Todas essas peças se encaixarão. Nesse ponto, você estará 
de volta ao ponto de partida, porque a semântica de movimentação, o 
encaminhamento perfeito e as referências de valor parecerão mais uma vez 
bastante simples. Mas desta vez, eles permanecerão assim. 
Nos itens deste capítulo, é especialmente importante ter em mente que um 
parâmetro é sempre um lvalue, mesmo que seu tipo seja uma referência de 
rvalue. Ou seja, dado 
vazio f( Widget&& w ); 
o parâmetro w é um lvalue, embora seu tipo seja rvalue-reference-to- Widget 
. (Se isso o surpreender, revise a visão geral de lvalues e rvalues que começa 
na página 2. ) 
Item 23: Entenda std::move e 
std::forward . 
 
184 | Artigo 22 
É útil abordar std::move e std::forward em termos do que eles não fazem . 
std::move não move nada. std::forward não encaminha nada. Em tempo de 
execução, nenhum deles faz nada. Eles não geram código executável. Nem 
um único byte. 
std::move e std::forward são apenas funções (na verdade, modelos de função) 
que executam conversões. std::move converte incondicionalmente seu 
argumento em um rvalue, enquanto std::forward executa essa conversão 
apenas se uma condição específica for atendida. É isso. A explicação leva a 
um novo conjunto de questões, mas, fundamentalmente, essa é a história 
completa. 
Para tornar a história mais concreta, aqui está um exemplo de implementação 
de std::move em C++11. Não está totalmente em conformidade com os 
detalhes do Padrão, mas está muito próximo. 
template // no namespace std 
nome do tipo remove_reference::type&& 
mover (parâmetro T&&) 
{ 
usando ReturnType = // declaração de alias; nome do tipo 
remove_reference::type&&; // veja o item 9 
retornar static_cast(param) ; 
} 
Destaquei duas partes do código para você. Um é o nome da função, porque 
a especificação do tipo de retorno é bastante barulhenta e não quero que você 
se perca com o barulho. O outro é o elenco que compõe a essência da função. 
Como você pode ver, std::move pega uma referência a um objeto (uma 
referência universal, para ser mais preciso – veja o Item 24 ) e retorna uma 
referência ao mesmo objeto. 
A parte “ && ” do tipo de retorno da função implica que std::move retorna uma 
referência de rvalue, mas, como o Item 28 explica, se o tipo T for uma 
referência de lvalue, T&& se tornaria uma referência de lvalue. Para evitar que 
isso aconteça, o tipo trait (vejaItem 9 ) std::remove_reference é aplicado a T 
, garantindo assim que “ && ” seja aplicado a um tipo que não é uma referência. 
Isso garante que std::move realmente retorne uma referência de rvalue, e isso 
é importante, porque as referências de rvalue retornadas de funções são 
rvalues. Assim, std::move lança seu argumento para um rvalue, e isso é tudo 
que faz. 
 
 Ponto 23 | 185 
Além disso, std::move pode ser implementado com menos complicações em 
C++14. Graças à dedução do tipo de retorno da função (consulte o Item 3 ) e 
ao modelo de alias da Biblioteca Padrão std::remove_reference_t (consulte o 
Item 9 ), std::move pode ser escrito desta forma: 
modelo // C++14; ainda em decltype(auto) move(T&& 
param) // namespace std 
{ 
usando ReturnType = remove_reference_t 
&&; retornar static_cast(param); } 
Mais fácil para os olhos, não? 
Como std::move não faz nada além de lançar seu argumento para um rvalue, 
houve sugestões de que um nome melhor para ele poderia ser algo como 
rvalue_cast . Seja como for, o nome que temos é std::move , por isso é 
importante lembrar o que std::move faz e o que não faz. Ele lança. Ele não se 
move. 
É claro que rvalues são candidatos à movimentação, portanto, aplicar 
std::move a um objeto informa ao compilador que o objeto é elegível para ser 
movido. É por isso que std::move tem esse nome: para facilitar a designação 
de objetos dos quais podem ser movidos. 
Na verdade, os rvalues geralmente só são candidatos à mudança. Suponha 
que você esteja escrevendo uma classe que representa anotações. O 
construtor da classe usa um parâmetro std::string que compreende a anotação 
e copia o parâmetro para um membro de dados. De acordo com as 
informações do Item 41 , você declara um parâmetro por valor: 
anotação de classe { public: anotação explícita ( std::string text); // 
parâmetro a ser copiado, 
 
186 | 
… // assim por Item 41 , 
}; // passa por valor 
Mas o construtor de Annotation precisa apenas ler o valor de text . Não é 
necessário modificá-lo. De acordo com a tradição consagrada de usar const 
sempre que possível, você revisa sua declaração de forma que text seja const 
: 
anotação de classe { public: anotação explícita ( 
const std::string text) 
… 
}; 
Para evitar pagar por uma operação de cópia ao copiar texto em um membro 
de dados, você permanece fiel ao conselho do Item 41 e aplica std::move a 
text , produzindo assim um rvalue: 
class Annotation { public: explicit Annotation(const std::string text) : 
value( std::move(text) ) // "mover" o texto para o valor; este código { … 
} // não faz o que parece! 
 
… 
privado: std::string 
valor; }; 
Este código compila. Este código vincula. Este código é executado. Este 
código define o valor do membro de dados para o conteúdo de text . A única 
coisa que separa este código de uma realização perfeita da sua visão é que o 
texto não é movido para valor , ele é copiado . Claro, o texto é convertido em 
um rvalue por std::move , mas o texto é declarado como um const std::string , 
portanto, antes da conversão, text é um lvalue const std::string , e o resultado 
da conversão é um rvalue const std::string , mas durante tudo isso, a 
constância permanece. 
Considere o efeito que ocorre quando os compiladores precisam determinar 
qual construtor std::string chamar. Existem duas possibilidades: 
class string { // std::string é na verdade um public: // typedef para 
std::basic_string 
… 
string(const string& rhs); // copia o ctor string(string&& rhs); 
//mover o ctor 
… 
}; 
 
 Ponto 23 | 187 
Artigo 23 
Na lista de inicialização de membros do construtor Annotation , o resultado de 
std::move(text) é um rvalue do tipo const std::string . Esse rvalue não pode ser 
passado para o construtor de movimento de std::string , porque o construtor 
de movimento leva uma referência de rvalue para um não- const std::string . 
O rvalue pode, no entanto, ser passado para o construtor de cópia, porque um 
lvalue-reference-to- const pode ser vinculado a um const rvalue. A 
inicialização do membro, portanto, invoca o construtor de cópia em std::string 
, mesmo que o texto tenha sido convertido em um rvalue! Tal comportamento 
é essencial para manter a const -correção. Mover um valor para fora de um 
objeto geralmente modifica o objeto, portanto a linguagem não deve permitir 
que objetos const sejam passados para funções (como construtores de 
movimentação) que possam modificá-los. 
Há duas lições a serem tiradas deste exemplo. Primeiro, não declare objetos 
const se quiser poder sair deles. Solicitações de movimentação em objetos 
const são transformadas silenciosamente em operações de cópia. Em 
segundo lugar, std::move não apenas não move nada, como nem garante que 
o objeto que está lançando será elegível para ser movido. A única coisa que 
você sabe com certeza sobre o resultado da aplicação de std::move a um 
objeto é que ele é um rvalue. 
A história de std::forward é semelhante à de std::move , mas enquanto 
std::move lança incondicionalmente seu argumento para um rvalue, 
std::forward faz isso apenas sob certas condições. std::forward é uma 
conversão condicional . Para entender quando ele é lançado e quando não, 
lembre-se de como std::forward é normalmente usado. O cenário mais comum 
é um modelo de função que usa um parâmetro de referência universal que 
deve ser passado para outra função: 
processo vazio (const Widget& lvalArg); // processa valores void 
process(Widget&& rvalArg); //processa rvalores 
template // modelo que passa void logAndProcess( T&& 
param ) // parâmetro para processar 
{ 
auto now = // obtém a hora atual std::chrono::system_clock::now(); 
makeLogEntry("Chamando 'processo'", 
agora); processo( std::forward(param) ); 
} 
 
188 | 
Considere duas chamadas para logAndProcess , uma com lvalue e a outra 
com rvalue: Widget w; 
logAndProcess(w); // chama com lvalue logAndProcess(std::move(w)); 
//chama com rvalue 
Dentro de logAndProcess , o parâmetro param é passado para a função 
process . o processo está sobrecarregado para lvalues e rvalues. Quando 
chamamos logAndProcess com um lvalue, esperamos naturalmente que 
lvalue seja encaminhado para o processo como um lvalue, e quando 
chamamos logAndProcess com um rvalue, esperamos que a sobrecarga de 
rvalue do processo seja invocada. 
Mas param , como todos os parâmetros de função, é um lvalue. Cada 
chamada para process dentro de logAndProcess irá, portanto, invocar a 
sobrecarga lvalue para process . Para evitar isso, precisamos de um 
mecanismo para que param seja convertido em um rvalue se e somente se o 
argumento com o qual param foi inicializado – o argumento passado para 
logAndProcess – for um rvalue. Isso é exatamente o que std::forward faz. É 
por isso que std::forward é uma conversão condicional : ela converte para um 
rvalue somente se seu argumento foi inicializado com um 
valor. 
Você pode estar se perguntando como std::forward pode saber se seu 
argumento foi inicializado com um rvalue. No código acima, por exemplo, 
como std::forward pode dizer se param foi inicializado com um lvalue ou um 
rvalue? A resposta breve é que essa informação está codificada no parâmetro 
de modelo T do logAndProcess . Esse parâmetro é passado para std::forward 
, que recupera as informações codificadas. Para obter detalhes sobre como 
isso funciona exatamente, consulte o Item 28 . 
Dado que std::move e std::forward se resumem a conversões, a única 
diferença é que std::move sempre lança, enquanto std::forward apenas às 
vezes o faz, você pode perguntar se podemos dispensar std::move e apenas 
use std::forward em qualquer lugar. De uma perspectiva puramente técnica, a 
resposta é sim: std::forward pode fazer tudo. std::move não é necessário. É 
claro que nenhuma das funções é realmente necessária , porque poderíamos 
escrever conversões em todos os lugares, masespero que concordemos que 
isso seria, bem, nojento. 
As atrações de std::move são conveniência, menor probabilidade de erro e 
maior clareza. Considere uma classe onde queremos rastrear quantas vezes 
o construtor de movimento é chamado. Um contador estático que é 
incrementado durante a construção do movimento é tudo o que precisamos. 
 
 Ponto 23 | 189 
Supondo que os únicos dados não estáticos na classe sejam std::string , aqui 
está a maneira convencional (ou seja, usando std::move ) para implementar o 
construtor de movimentação: 
classe Widget { público: 
Widget(Widget&& rhs) 
: s( std::move (rhs.s)) { 
++moveCtorCalls; } 
… 
Artigo 23 
privado: estático std::size_t 
moveCtorCalls; 
std::strings; }; 
Para implementar o mesmo comportamento com std::forward , o código ficaria 
assim: 
classe Widget { público: 
Widget(Widget&& rhs) // não convencional, 
: s( std::forward (rhs.s)) // indesejável 
{ ++moveCtorCalls; } // implementação 
… 
}; 
Observe primeiro que std::move requer apenas um argumento de função ( 
rhs.s ), enquanto std::forward requer um argumento de função ( rhs.s ) e um 
argumento de tipo de modelo ( std::string ). Em seguida, observe que o tipo 
que passamos para std::forward deve ser uma não-referência, porque essa é 
a convenção para codificação de que o argumento que está sendo passado é 
um rvalue (consulte o Item 28 ). Juntos, isso significa que std::move requer 
menos digitação do que std::forward , e nos poupa o trabalho de passar um 
argumento de tipo que codifica que o argumento que estamos passando é um 
rvalue. Também elimina a possibilidade de passarmos um tipo incorreto (por 
exemplo, std::string& , o que resultaria na construção de cópia do membro de 
dados em vez de construção de movimento). 
Mais importante ainda, o uso de std::move transmite uma conversão 
incondicional para um rvalue, enquanto o uso de std::forward indica uma 
conversão para um rvalue apenas para referências às quais os rvalues foram 
 
190 | 
vinculados. São duas ações muito diferentes. O primeiro normalmente 
configura um movimento, enquanto o segundo apenas passa - encaminha - 
um objeto para outra função de uma forma que retém seu valor ou valor 
original. Como essas ações são tão diferentes, é bom termos duas funções (e 
nomes de funções) diferentes para distingui-las. 
Coisas para lembrar 
• std::move executa uma conversão incondicional para um rvalue. Por si 
só, não move nada. 
• std::forward converte seu argumento em um rvalue somente se esse 
argumento estiver vinculado a um rvalue. 
• Nem std::move nem std::forward fazem nada em tempo de execução. 
 
 | 191 
Item 24: Distinguir referências 
universais de referências de 
valor. 
Já foi dito que a verdade libertará você, mas nas circunstâncias certas, uma 
mentira bem escolhida pode ser igualmente libertadora. Este item é uma 
mentira. Porém, como estamos lidando com software, vamos evitar a palavra 
“mentira” e, em vez disso, dizer que este item compreende uma “abstração”. 
Para declarar uma referência de rvalue para algum tipo T , você escreve T&& 
. Portanto, parece razoável supor que se você vir “ T&& ” no código-fonte, você 
está olhando para uma referência de rvalue. Infelizmente, não é tão simples: 
void f(Widget && parâmetro); // referência de valor Widget && var1 
= Widget(); // referência de valor auto && var2 = var1; // não é 
referência de valor 
modelo 
void f(std::vector && param); // referência de valor 
modelo 
void f(T && param); // não é referência de valor 
Na verdade, “ T&& ” tem dois significados diferentes. Uma é a referência de 
valor, é claro. Essas referências se comportam exatamente da maneira que 
você espera: elas se vinculam apenas a rvalues, e sua principal razão de ser 
é identificar objetos dos quais podem ser movidos. 
O outro significado para “ T&& ” é referência de valor ou referência de valor. 
Tais referências se parecem com referências de valor no código-fonte (ou 
seja, “ T&& ”), mas podem se comportar como se fossem referências de valor 
(ou seja, “ T& ”). Sua natureza dupla permite que eles se vinculem a rvalues 
(como referências de rvalue), bem como a lvalues (como referências de 
lvalue). Além disso, eles podem se vincular a objetos const ou não- const , a 
objetos voláteis ou não- voláteis , até mesmo a objetos que são const e 
voláteis . Eles podem se ligar a praticamente qualquer coisa . Essas 
 
192 | Artigo 24 
referências flexíveis sem precedentes merecem um nome próprio. Eu os 
chamo de referências universais .11 
As referências universais surgem em dois contextos. O mais comum são os 
parâmetros do modelo de função, como este exemplo do código de amostra 
acima: 
modelo 
void f(T && param); // param é uma referência universal O segundo contexto 
são declarações automáticas , incluindo este do código de exemplo acima: 
auto && var2 = var1; // var2 é uma referência universal 
O que esses contextos têm em comum é a presença da dedução de tipo . No 
modelo f , o tipo de param está sendo deduzido e na declaração de var2 , o 
tipo de var2 está sendo deduzido. Compare isso com os exemplos a seguir 
(também do código de exemplo acima), onde falta a dedução de tipo. Se você 
vir “ T&& ” sem dedução de tipo, você está vendo uma referência de valor: 
void f(Widget && parâmetro); // nenhum tipo de dedução; 
// param é uma referência de rvalue 
Widget && var1 = Widget(); // nenhum tipo de dedução; 
 // var1 é uma referência de rvalue 
Como as referências universais são referências, elas devem ser inicializadas. 
O inicializador de uma referência universal determina se ela representa uma 
referência rvalue ou uma referência lvalue. Se o inicializador for um rvalue, a 
referência universal corresponderá a uma referência de rvalue. Se o 
inicializador for um lvalue, a referência universal corresponderá a uma 
referência lvalue. Para referências universais que são parâmetros de função, 
o inicializador é fornecido no site de chamada: 
modelo void f(T&& param); // param é uma 
referência universal 
Widget com; 
f( C ); // lvalor passado para f; o tipo do parâmetro é // 
Widget& (ou seja, uma referência lvalue) 
f( std::move(w) ); // rvalor passado para f; o tipo do parâmetro é 
// Widget&& (ou seja, uma referência de valor) 
 
11 O item 25 explica que as referências universais quase sempre devem ter std::forward aplicado a elas e, 
à medida que este livro vai para impressão, alguns membros da comunidade C++ começaram a se referir às 
referências universais como referências de encaminhamento . 
 
 | 193 
Para que uma referência seja universal, a dedução de tipo é necessária, mas 
não é suficiente. A forma da declaração de referência também deve estar 
correta, e essa forma é bastante restrita. Deve ser precisamente “ T&& ”. Veja 
novamente este exemplo do código de amostra que vimos anteriormente: 
modelo 
void f( std::vector&& param); // param é uma referência de rvalue 
Quando f é invocado, o tipo T será deduzido (a menos que o chamador o 
especifique explicitamente, um caso extremo com o qual não nos 
preocuparemos). Mas a forma do tipo de param declara‐ 
Artigo 24 
ção não é “ T&& ”, é “ std::vector&& ”. Isso exclui a possibilidade de param 
ser uma referência universal. param é, portanto, uma referência de rvalue, 
algo que seus compiladores ficarão felizes em confirmar se você tentar passar 
um lvalue para f : 
std::vetor v; 
f(v); //erro! não é possível vincular lvalue a // 
referência de valor 
Mesmo a simples presença de um qualificador const é suficiente para 
desqualificar uma referência de ser universal: 
modelo 
void f(ocorre porque os 
rvalues indicam objetos elegíveis para operações de movimentação, enquanto 
 
 | 3 
os lvalues geralmente não o fazem. Em conceito (embora nem sempre na 
prática), rvalues correspondem a objetos temporários retornados de funções, 
enquanto lvalues correspondem a objetos aos quais você pode se referir, seja 
por nome ou seguindo um ponteiro ou referência de lvalue. 
Uma heurística útil para determinar se uma expressão é um lvalue é perguntar 
se você pode obter seu endereço. Se você puder, normalmente é. Se você 
não puder, geralmente é um valor. Um recurso interessante dessa heurística 
é que ela ajuda você a lembrar que o tipo de uma expressão é independente 
de a expressão ser um lvalue ou um rvalue. Ou seja, dado um tipo T , você 
pode ter lvalues do tipo T bem como rvalues do tipo T . É especialmente 
importante lembrar disso ao lidar com um parâmetro do tipo de referência 
rvalue, porque o parâmetro em si é um lvalue: 
widget de classe { 
público: 
Widget( Widget&& rhs ); // rhs é um lvalue , embora tenha 
… // um tipo de referência rvalue 
}; 
Aqui, seria perfeitamente válido colocar o endereço de rhs dentro do construtor 
move do Widget , então rhs é um lvalue, mesmo que seu tipo seja uma 
referência de rvalue. (Por raciocínio semelhante, todos os parâmetros são 
lvalores.) 
Esse trecho de código demonstra várias convenções que normalmente sigo: 
• O nome da classe é Widget . Eu uso o Widget sempre que quero me referir 
a um tipo arbitrário definido pelo usuário. A menos que eu precise mostrar 
detalhes específicos da classe, eu uso o Widget sem declará-lo. 
• Eu uso o nome do parâmetro rhs (“lado direito”). É meu nome de 
parâmetro preferido para as operações de movimentação (ou seja, 
construtor de movimentação e operador de atribuição de movimentação) 
e operações de cópia (ou seja, construtor de cópia e operador de 
atribuição de cópia). Também o uso para o parâmetro direito dos 
operadores binários: 
Operador de matriz+(const Matrix& lhs, const Matrix& rhs ); 
Não é nenhuma surpresa, espero, que lhs signifique “lado esquerdo”. 
• Eu aplico formatação especial a partes de código ou comentários para 
chamar sua atenção para eles. No construtor de movimento do widget 
acima, destaquei a declaração de rhs e a parte do comentário observando 
 
4 | 
que rhs é um lvalue. O código destacado não é inerentemente bom nem 
inerentemente ruim. É simplesmente um código ao qual você deve prestar 
atenção especial. 
• Eu uso “ … ” para indicar “outro código poderia ir aqui”. Essas reticências 
estreitas são diferentes das reticências largas (“ ... ”) usadas no código-
fonte dos modelos variados do C++ 11. Isso parece confuso, mas não é. 
Por exemplo: 
template // estes são C++ void 
processVals(const Ts& ... params) // código fonte { // 
reticências 
 … // isso significa "alguns 
 // o código vai aqui" 
} 
A declaração de processVals mostra que uso typename ao declarar 
parâmetros de tipo em modelos, mas isso é apenas uma preferência 
pessoal; a classe de palavras-chave funcionaria igualmente bem. Nas 
ocasiões em que mostro trechos de código de um padrão C++, declaro 
parâmetros de tipo usando class , porque é isso que os padrões fazem. 
Quando um objeto é inicializado com outro objeto do mesmo tipo, o novo 
objeto é considerado uma cópia do objeto inicializador, mesmo que a cópia 
tenha sido criada por meio do construtor de movimentação. Lamentavelmente, 
não há terminologia em C++ que distinga entre um objeto que é uma cópia 
construída por cópia e outro que é uma cópia construída por movimentação: 
void someFunc(Widget w); //parâmetro w de someFunc 
// é passado pelo valor Widget wid; //wid é algum widget 
algumaFunc(wid); // nesta chamada para someFunc, 
// w é uma cópia de wid que é 
 // criado via cópia de construção 
algumaFunc(std::move(wid)); // nesta chamada para SomeFunc, 
// w é uma cópia de wid que é 
 //criado via construção de movimento 
Cópias de rvalues geralmente são construídas por movimentação, enquanto 
cópias de lvalues são geralmente construídas por cópia. Uma implicação é 
que se você souber apenas que um objeto é uma cópia de outro objeto, não 
será possível dizer quão caro foi construir a cópia. No código acima, por 
 
 | 5 
exemplo, não há como dizer o quão caro é criar o parâmetro w sem saber se 
rvalues ou lvalues são passados para someFunc . (Você também precisa 
saber o custo de mover e copiar Widgets .) 
Em uma chamada de função, as expressões passadas no site da chamada 
são os argumentos da função . Os argumentos são usados para inicializar os 
parâmetros da função . Na primeira chamada para someFunc acima, o 
argumento é wid . Na segunda chamada, o argumento é std::move(wid) . Em 
ambas as chamadas, o parâmetro é w . A distinção entre argumentos e 
parâmetros é importante, porque os parâmetros são lvalores, mas os 
argumentos com os quais são inicializados podem ser rvalores ou lvalores. 
Isso é especialmente relevante durante o processo de encaminhamento 
perfeito , em que um argumento passado para uma função é passado para 
uma segunda função, de modo que a rvaloridade ou lvaloridade do argumento 
original seja preservada. (O encaminhamento perfeito é discutido em detalhes 
no Item 30. ) Funções bem projetadas são seguras contra exceções , o que 
significa que oferecem pelo menos a garantia básica de segurança contra 
exceções (isto é, a garantia básica ). Tais funções garantem aos chamadores 
que, mesmo que uma exceção seja lançada, as invariantes do programa 
permanecerão intactas (ou seja, nenhuma estrutura de dados será 
corrompida) e nenhum recurso será vazado. As funções que oferecem a 
garantia forte de segurança de exceção (ou seja, a garantia forte ) asseguram 
aos chamadores que, se surgir uma exceção, o estado do programa 
permanecerá como era antes da chamada. 
Quando me refiro a um objeto de função , geralmente me refiro a um objeto 
de um tipo que suporta uma função de membro operador() . Em outras 
palavras, um objeto que atua como uma função. Ocasionalmente eu uso o 
termo em um sentido um pouco mais geral para significar qualquer coisa que 
possa ser invocada usando a sintaxe de uma chamada de função não-
membro (ou seja, “ função 
Nome(argumentos) ”). Esta definição mais ampla abrange não apenas objetos 
que suportam operator() , mas também funções e ponteiros de função 
semelhantes a C. (A definição mais restrita vem do C++ 98, a mais ampla do 
C++ 11.) Generalizar ainda mais adicionando ponteiros de função de membro 
produz o que é conhecido como objetos chamáveis . Geralmente, você pode 
ignorar as distinções sutis e simplesmente pensar em objetos de função e 
objetos que podem ser chamados como coisas em C++ que podem ser 
invocadas usando algum tipo de sincronização de chamada de função. 
imposto. 
 
6 | 
Objetos de função criados por meio de expressões lambda são conhecidos 
como encerramentos . Raramente é necessário distinguir entre expressões 
lambda e os fechamentos que elas criam, por isso costumo me referir a ambas 
como lambdas . Da mesma forma, raramente distingo entre modelos de 
função (ou seja, modelos que geram funções) e funções de modelo (ou seja, 
as funções geradas a partir de modelos de função). O mesmo vale para 
modelos de classe e 
classes de modelo . 
Muitas coisas em C++ podem ser declaradas e definidas. As declarações 
introduzem nomes e tipos sem fornecer detalhes, como onde o 
armazenamento está localizado ou como as coisas são implementadas: extern 
int x; // declaração do objeto class Widget; // declaração de classe bool func(const 
Widget& w); //declaração da função 
classe enum Cor; // declaração de enumconst T&& param); // param é uma referência de valor Se você estiver 
em um modelo e vir um parâmetro de função do tipo “ T&& ”, você pode pensar 
que pode assumir que é uma referência universal. Você não pode. Isso porque 
estar em um template não garante a presença de dedução de tipo. Considere 
esta função membro push_back em std::vector : 
template> // da classe C++ 
vector { // Padrões public: void push_back( T&& x); 
… 
}; O parâmetro push_back certamente tem a forma correta para uma 
referência universal, mas não há dedução de tipo neste caso. Isso ocorre 
porque push_back não pode existir sem uma instanciação vetorial específica 
da qual faça parte, e o tipo dessa instanciação determina totalmente a 
declaração para push_back . Isto é, dizendo 
std::vector v; 
faz com que o modelo std::vector seja instanciado da seguinte forma: 
 
194 | Artigo 24 
class vector> { public: void push_back( 
Widget&& x); // referência de valor 
… 
}; 
Agora você pode ver claramente que push_back não emprega dedução de 
tipo. Este push_back para vector (existem dois – a função está 
sobrecarregada) sempre declara um parâmetro do tipo rvalue-reference-to- T 
. 
Em contraste, a função membro emplace_back conceitualmente semelhante 
em std::vec tor emprega dedução do tipo: 
template> // ainda da classe 
vector { // C++ public: // Padrões 
template void 
emplace_back( Args&& ... args); 
… 
}; 
Aqui, o parâmetro de tipo Args é independente do parâmetro de tipo do vetor 
T , portanto Args deve ser deduzido toda vez que emplace_back for chamado. 
(Ok, Args é na verdade um pacote de parâmetros, não um parâmetro de tipo, 
mas para os propósitos desta discussão, podemos tratá-lo como se fosse um 
parâmetro de tipo.) 
O fato do parâmetro de tipo de emplace_back ser denominado Args , mas 
ainda ser uma referência universal, reforça meu comentário anterior de que é 
a forma de uma referência universal que deve ser “ T&& ”. Não há exigência 
de que você use o nome T . Por exemplo, o modelo a seguir usa uma 
referência universal, porque o formato (“ type && ”) está correto e o tipo de 
param será deduzido (novamente, excluindo o caso extremo em que o 
chamador especifica explicitamente o tipo): 
template // parâmetro é um void someFunc( 
MyTemplateType&& param); // referência universal Comentei anteriormente 
que variáveis automáticas também podem ser referências universais. Para ser 
mais preciso, variáveis declaradas com o tipo auto&& são referências 
universais, pois ocorre a dedução do tipo e elas possuem a forma correta (“ 
T&& ”). referências universais automáticas não são tão comuns quanto 
referências universais usadas para parâmetros de modelo de função, mas 
surgem de vez em quando no C++ 11. Eles aparecem muito mais no C++ 14, 
porque as expressões lambda do C++ 14 podem declarar parâmetros auto&& 
. Por exemplo, se você quiser escrever um lambda C++ 14 para registrar o 
tempo gasto em uma invocação de função arbitrária, poderá fazer o seguinte: 
 
 | 195 
auto timeFuncInvocation = 
[]( auto&& func, auto&& ... params) // C++14 
{ iniciar 
temporizador; 
std::forward(func)( // invoca func 
std::forward(params)... // em parâmetros 
); pare o cronômetro e registre o tempo 
decorrido; }; 
Se a sua reação ao “ std::forward ” o código dentro 
do lambda é, “O que…?!”, isso provavelmente significa apenas que você ainda 
não leu o Item 33 . Não se preocupe com isso. O importante neste item são 
os parâmetros auto&& que 
Artigo 24 
o lambda declara. func é uma referência universal que pode ser vinculada a 
qualquer objeto que pode ser chamado, lvalue ou rvalue. args é zero ou mais 
referências universais (isto é, um pacote de parâmetros de referência 
universal) que pode ser vinculado a qualquer número de objetos de tipos 
arbitrários. O resultado, graças às referências universais automáticas , é que 
timeFuncInvocation pode cronometrar praticamente qualquer execução de 
função. (Para obter informações sobre a diferença entre “qualquer” e 
“praticamente qualquer”, consulte o Item 30. ) 
Tenha em mente que todo este Item – a base das referências universais – é 
uma mentira... er, uma “abstração”. A verdade subjacente é conhecida como 
colapso de referência , tema ao qual o item 28 é dedicado. Mas a verdade não 
torna a abstração menos útil. Distinguir entre referências de rvalue e 
referências universais ajudará você a ler o código-fonte com mais precisão 
(“Esses T&& que estou analisando se vinculam apenas a rvalues ou a tudo?”) 
e evitará ambiguidades quando você se comunicar com seus colegas (“Eu 
estou usando uma referência universal aqui, não uma referência de valor…”). 
Também permitirá que você entenda os itens 25 e 26 , que dependem da 
distinção. Portanto, abrace a abstração. Deleite-se com isso. Assim como as 
leis do movimento de Newton (que são tecnicamente incorretas) são 
normalmente tão úteis e mais fáceis de aplicar do que a teoria da relatividade 
geral de Einstein (“a verdade”), também a noção de referências universais é 
normalmente preferível a trabalhar nos detalhes de referência em colapso. 
Coisas para lembrar 
 
196 | Artigo 24 
• Se um parâmetro de modelo de função tiver tipo T&& para um tipo 
deduzido T , ou se um objeto for declarado usando auto&& , o parâmetro 
ou objeto será uma referência universal. 
• Se a forma da declaração de tipo não for exatamente type && , ou se a 
dedução de tipo não ocorrer, type && denota uma referência de rvalue. 
• As referências universais correspondem às referências de rvalue se 
forem inicializadas com rvalues. Eles correspondem a referências lvalue 
se forem inicializados com lval- 
sim. 
Item 25: Use std::move em referências 
de rvalue, std::forward em 
referências universais. 
As referências Rvalue são vinculadas apenas a objetos candidatos à 
movimentação. Se você tiver um parâmetro de referência rvalue, você sabe 
que o objeto ao qual ele está vinculado pode ser movido: 
widget de classe { 
Widget( Widget&& rhs); // rhs definitivamente se refere a um 
 
 Ponto 25 | 197 
… // objeto elegível para movimentação 
}; 
Sendo esse o caso, você desejará passar esses objetos para outras funções 
de uma forma que permita que essas funções aproveitem o valor do objeto. A 
maneira de fazer isso é converter parâmetros vinculados a esses objetos em 
rvalues. Como o item 23 explica, não é apenas isso que std::move faz, é para 
isso que foi criado: 
classe Widget { público: 
Widget(Widget&& rhs) // rhs é referência de valor 
: nome( std::move(rhs.nome) ), p( std::move(rhs.p) ) 
{…} 
… 
privado: std::string 
nome; 
std::shared_ptr p; }; 
Uma referência universal, por outro lado (ver Item 24 ), pode estar vinculada 
a um objeto elegível para movimentação. As referências universais devem ser 
convertidas em rvalues somente se tiverem sido inicializadas com rvalues. O 
item 23 explica que é exatamente isso que std::for ward faz: 
classe Widget { público: 
modelo 
void setName(T&& newName) // novoNome é { name = 
std::forward(newName) ; } // referência universal 
… 
}; 
Resumindo, as referências de rvalue devem ser convertidas 
incondicionalmente em rvalues (via std::move ) ao encaminhá-las para outras 
funções, porque estão sempre vinculadas a rvalues, e as referências 
universais devem ser convertidas condicionalmente em rvalues (via 
std::forward ) ao encaminhá-los, porque às vezes eles estão vinculados a 
rvalues. 
O item 23 explica que o uso de std::forward em referências de rvalue pode ser 
feito para exibir o comportamento adequado, mas o código-fonte é prolixo, 
sujeito a erros e não idiomático, portanto, você deve evitar o uso de 
std::forward com referências decom escopo 
// (ver Artigo 10 ) 
As definições fornecem os locais de armazenamento ou detalhes 
de implementação: int x; //definição do objeto 
class Widget { // definição de classe 
… 
}; 
bool func(const Widget& w) { return w.size() e operador* ), embora o Item 20 explique 
que std::weak_ptr é uma exceção. 
Nos comentários do código-fonte, às vezes abrevio “construtor” como ctor e 
“destruidor” como dtor . 
Relatando bugs e sugerindo melhorias 
Fiz o possível para preencher este livro com informações claras, precisas e 
úteis, mas certamente há maneiras de melhorá-lo. Se você encontrar erros de 
qualquer tipo (técnico, expositivo, gramatical, tipográfico, etc.), ou se tiver 
sugestões de como o livro poderia ser melhorado, envie um email para 
emc++@aristeia.com . Novas impressões me dão a oportunidade de revisar 
Effective Modern C++ e não consigo resolver problemas que não conheço! 
 
8 | 
Para ver a lista dos problemas que conheço, consulte a página de erratas do 
livro , http://www.aristeia.com/BookErrata/emc++-errata.html . 
http://www.aristeia.com/BookErrata/emc++-errata.html
http://www.aristeia.com/BookErrata/emc++-errata.html
 
 
 
 
10 
CAPÍT
ULO 1 
Ded
uzindo 
Tipos 
C++ 98 tinha um único conjunto de regras para dedução de tipo: aquele para 
modelos de função. C++ 11 modifica um pouco esse conjunto de regras e 
adiciona mais dois, um para auto e outro para decltype . O C++ 14 estende 
então os contextos de uso nos quais auto e decltype podem ser empregados. 
A aplicação cada vez mais difundida da dedução de tipo liberta você da tirania 
de soletrar tipos que são óbvios ou redundantes. Isso torna o software C++ 
mais adaptável, porque a alteração de um tipo em um ponto do código-fonte 
se propaga automaticamente por meio da dedução de tipo para outros locais. 
No entanto, isso pode tornar o código mais difícil de raciocinar, porque os tipos 
deduzidos pelos compiladores podem não ser tão aparentes quanto você 
gostaria. 
Sem uma compreensão sólida de como funciona a dedução de tipos, a 
programação eficaz em C++ moderno é praticamente impossível. Existem 
muitos contextos onde ocorre a dedução de tipo: em chamadas para modelos 
 
 Ponto 1 | 11 
de função, na maioria das situações onde auto aparece, em expressões 
decltype e, a partir do C++ 14, onde a enigmática construção decltype(auto) é 
empregada. 
Este capítulo fornece informações sobre a dedução de tipo que todo 
desenvolvedor C++ exige. Ele explica como funciona a dedução do tipo de 
modelo, como o auto se baseia nisso e como o decltype segue seu próprio 
caminho. Ele ainda explica como você pode forçar os compiladores a tornar 
visíveis os resultados de suas deduções de tipo, permitindo assim garantir que 
os compiladores estejam deduzindo os tipos que você deseja. 
Item 1: Entenda a dedução do tipo de 
modelo. 
Quando os usuários de um sistema complexo ignoram como ele funciona, mas 
estão satisfeitos com o que faz, isso diz muito sobre o design do sistema. Por 
esta medida, a dedução do tipo de modelo em C++ é um tremendo sucesso. 
Milhões de programadores passaram argumentos para funções de modelo 
com resultados completamente satisfatórios, embora muitos desses 
programadores teriam dificuldade em fornecer mais do que a mais vaga 
descrição de como os tipos usados por essas funções foram deduzidos. 
Se esse grupo inclui você, tenho boas e más notícias. A boa notícia é que a 
dedução de tipo para modelos é a base para um dos recursos mais atraentes 
do C++ moderno: auto . Se você ficou satisfeito com a forma como o C++ 98 
deduziu tipos para modelos, você está pronto para ficar satisfeito com a forma 
como o C++ 11 deduz tipos para auto . A má notícia é que quando as regras 
de dedução do tipo de modelo são aplicadas no contexto de auto , elas às 
vezes parecem menos intuitivas do que quando aplicadas a modelos. Por 
esse motivo, é importante compreender verdadeiramente os aspectos da 
dedução do tipo de modelo em que o auto se baseia. Este item cobre o que 
você precisa saber. 
Se você estiver disposto a ignorar uma pitada de pseudocódigo, podemos 
pensar em um modelo de função parecido com este: 
template 
void f( ParamType 
param); 
Uma chamada pode ser assim: 
f( expr ); //chama f com alguma expressão 
 
12 | Item 1 
Durante a compilação, os compiladores usam expr para deduzir dois tipos: um 
para T e outro para ParamType . Esses tipos são frequentemente diferentes, 
porque ParamType geralmente contém adornos, por exemplo, const ou 
qualificadores de referência. Por exemplo, se o modelo for declarado assim, 
modelo 
void f( const T& param); // ParamType é const T& 
e temos esta 
chamada, int x = 0; 
f( x ); //chama f com um int 
T é deduzido como int , mas ParamType é deduzido como const int& . 
É natural esperar que o tipo deduzido para T seja o mesmo tipo do argumento 
passado para a função, ou seja, que T seja o tipo de expr . No exemplo acima, 
é esse o caso: x é um int e T é deduzido como int . Mas nem sempre funciona 
assim. O tipo deduzido para T depende não apenas do tipo de expr , mas 
também da forma de ParamType . Existem três casos: 
• ParamType é um ponteiro ou tipo de referência, mas não uma referência 
universal. (As referências universais estão descritas no Item 24. Neste 
ponto, tudo o que você precisa saber é que elas existem e que não são 
iguais às referências lvalue ou referências rvalue.) 
• ParamType é uma referência universal. 
• ParamType não é umponteiro nem uma referência. 
Temos, portanto, três tipos de cenários de dedução para examinar. Cada um 
será baseado em nosso formulário geral para modelos e chamadas para ele: 
template void f( ParamType param); f( expr ); 
//deduz T e ParamType de expr 
Caso 1: ParamType é uma referência ou 
ponteiro, mas não uma referência 
universal 
A situação mais simples é quando ParamType é um tipo de referência ou um 
tipo de ponteiro, mas não uma referência universal. Nesse caso, o tipo de 
dedução funciona assim: 
 
 Ponto 1 | 13 
1. Se o tipo de expr for uma referência, ignore a parte de referência. 
2. Em seguida, combine o tipo de expr com o ParamType para determinar T 
. 
Por exemplo, se este for o nosso modelo, 
modelo 
vazio f ( T& param); // parâmetro é uma referência 
e temos essas declarações de variáveis, 
interno x = 27; // x é um int const int cx = x; //cx é 
um const int 
const int& rx = x; // rx é uma referência a x como const int os tipos deduzidos 
para param e T em várias chamadas são os seguintes: 
f(x); //T é int , o tipo do parâmetro é int& 
f(cx); //T é const int , // o tipo do parâmetro é 
const int& 
f(rx); //T é const int , 
 // o tipo do parâmetro é const int& 
Na segunda e terceira chamadas, observe que como cx e rx designam valores 
const , T é deduzido como const int , produzindo assim um tipo de parâmetro 
const int& . Isso é importante para quem liga. Quando eles passam um objeto 
const para um parâmetro de referência, eles esperam que esse objeto 
permaneça inalterado, ou seja, que o parâmetro seja uma referência para 
const . É por isso que passar um objeto const para um modelo que usa um 
parâmetro T& é seguro: a constância do objeto se torna parte do tipo deduzido 
para T . 
No terceiro exemplo, observe que mesmo que o tipo de rx seja uma referência, 
T é deduzido como não-referência. Isso ocorre porque a referência de rx é 
ignorada durante a dedução de tipo. 
Todos esses exemplos mostram parâmetros de referência lvalue, mas a 
dedução de tipo funciona exatamente da mesma maneira para parâmetros de 
referência rvalue. É claro que apenas argumentos rvalue podem ser passados 
para parâmetros de referência rvalue, mas essa restrição não tem nada a ver 
com dedução de tipo. 
Se mudarmos o tipo do parâmetro de f de T& para const T& , as coisas mudam 
um pouco, mas não de uma forma realmente surpreendente. A constância de 
 
14 | Item 1 
cx e rx continua a ser respeitada, mas como agora estamos assumindo que 
param é uma referência a const , não há mais necessidade de const ser 
deduzido como parte de T : 
modelo 
void f( const T& param); // param agora é um ref-to- const 
interno x = 27; // como antes const int cx = x; // como antes const int& rx 
= x; // como antes f(x); // T é int , o tipo do parâmetro é const int& f(cx); // T é 
int , o tipo do parâmetro é const int& f(rx); // T é int , o tipo do param é const 
int& Como antes, a referência de rx é ignorada durante a dedução de tipo 
. 
Se param fosse um ponteiro (ou um ponteiro para const ) em vez de uma 
referência, as coisas funcionariam essencialmente da mesma maneira: 
modelo 
void f( T* parâmetro); // param agora é um ponteiro 
interno x = 27; // como antes 
const int *px = &x; // px é um ptr para x como um const int 
f(&x); //T é int , o tipo do parâmetro é int* 
f(px); //T é const int , // o tipo do parâmetro é 
const int* 
A esta altura, você pode estar bocejando e cochilando, porque as regras de 
dedução de tipo do C++ funcionam tão naturalmente para parâmetros de 
referência e de ponteiro, que vê-los na forma escrita é realmente chato. Tudo 
é simplesmente óbvio! O que é exatamente o que você deseja em um sistema 
de dedução de tipo. 
Caso 2: ParamType é uma referência universal 
As coisas são menos óbvias para modelos que utilizam parâmetros de 
referência universais. Tais parâmetros são declarados como referências de 
rvalue (ou seja, em um modelo de função que usa um parâmetro de tipo T , o 
tipo declarado de uma referência universal é T&& ), mas eles se comportam 
de maneira diferente quando argumentos lvalue são passados. A história 
completa é contada no Item 24 , mas aqui está a versão do título: 
 
 Ponto 1 | 15 
• Se expr for um lvalue, tanto T quanto ParamType serão deduzidos como 
referências de lvalue. Isso é duplamente incomum. Primeiro, é a única 
situação na dedução de tipo de modelo em que T é deduzido como uma 
referência. Segundo, embora ParamType seja declarado usando a sintaxe 
para uma referência de rvalue, seu tipo deduzido é uma referência de 
lvalue. 
• Se expr for um rvalue, aplicam-se as regras “normais” (isto é, Caso 1). 
Por exemplo: 
modelo 
vazio f ( T&& param); // param agora é uma referência universal 
interno x = 27; // como antes const int cx = x; // 
como antes const int& rx = x; // como antes 
f(x); // x é lvalue, então T é int& , // o tipo do 
parâmetro também é int& 
f(cx); // cx é lvalue, então T é const int& , // o tipo do 
parâmetro também é const int& 
f(rx); // rx é lvalue, então T é const int& , // o tipo do 
parâmetro também é const int& 
f(27); // 27 é rvalue, então T é int , 
 // o tipo do parâmetro é, portanto, int&& 
O item 24 explica exatamente por que esses exemplos funcionam dessa 
maneira. O ponto principal aqui é que as regras de dedução de tipo para 
parâmetros de referência universais são diferentes daquelas para parâmetros 
que são referências lvalue ou referências rvalue. Em particular, quando 
referências universais estão em uso, a dedução de tipo distingue entre 
argumentos lvalue e argumentos rvalue. Isso nunca acontece com referências 
não universais. Caso 3: ParamType não é um ponteiro 
nem uma referência 
Quando ParamType não é um ponteiro nem uma referência, estamos lidando 
com passagem por valor: 
modelo 
vazio f ( parâmetro T ); // parâmetro agora é passado por valor 
 
16 | Item 1 
Isso significa que param será uma cópia de tudo o que for passado – um objeto 
completamente novo. O fato de param ser um novo objeto motiva as regras 
que governam como T é deduzido de expr : 
1. Como antes, se o tipo de expr for uma referência, ignore a parte da 
referência. 
2. Se, depois de ignorar a referência de expr , expr for const , ignore isso 
também. Se for volátil , ignore isso também. ( objetos voláteis são incomuns. 
Eles geralmente são usados apenas para implementar drivers de dispositivos. 
Para obter detalhes, consulte o Item 40. ) Portanto: 
interno x = 27; // como antes const int cx = x; // como antes const int& rx = x; // 
como antes f(x); // Os tipos de T e param são ambos int f(cx); // Os tipos T e param 
são novamente int f(rx); // Os tipos T e param ainda são int Observe que, embora 
cx e rx representem valores const , param não é const . Isso faz sentido. param 
é um objeto completamente independente de cx e rx — uma cópia de cx ou rx 
. O fato de cx e rx não poderem ser modificados não diz nada sobre se param 
pode ser. É por isso que a constância de expr (e a volatilidade , se houver) é 
ignorada ao deduzir um tipo para param : só porque expr não pode ser 
modificado não significa que uma cópia dele não possa ser. 
É importante reconhecer que const (e volátil ) são ignorados apenas para 
parâmetros por valor. Como vimos, para parâmetros que são referências ou 
ponteiros para const , a constância de expr é preservada durante a dedução 
de tipo. Mas considere o caso em que expr é um ponteiro const para um objeto 
const e expr é passado para um parâmetro byvalue : 
modelo 
vazio f ( parâmetro T ); // param ainda é passado por valor 
const char* const ptr = // ptr é um ponteiro const para o objeto const 
"Diversãocom ponteiros"; 
f(ptr); // passa arg do tipo const char * const Aqui, o const à direita do 
asterisco declara ptr como const : ptr não pode apontar para um local diferente, 
nem pode ser definido como nulo. (O const à esquerda do asterisco indica que 
o que ptr aponta – a cadeia de caracteres – é const , portanto não pode ser 
modificado.) Quando ptr é passado para f , os bits que compõem o ponteiro 
são copiados para param . Como tal, o próprio ponteiro ( ptr ) será passado 
 
 Ponto 1 | 17 
por valor . De acordo com a regra de dedução de tipo para parâmetros por 
valor, a constância de ptr será ignorada e o tipo deduzido para parâmetro será 
const char* , ou seja, um ponteiro modificável para uma string de caracteres 
const . A constância do que ptr aponta é preservada durante a dedução de 
tipo, mas a constância do próprio ptr é ignorada ao copiá-lo para criar o novo 
ponteiro, param . 
Argumentos de matriz 
Isso cobre praticamente a dedução do tipo de modelo convencional, mas há 
um caso de nicho que vale a pena conhecer. Acontece que os tipos de array 
são diferentes dos tipos de ponteiro, embora às vezes pareçam 
intercambiáveis. Um dos principais contribuintes para esta ilusão é que, em 
muitos contextos, uma matriz decai num ponteiro para o seu primeiro 
elemento. Essa decadência é o que permite que códigos como este sejam 
compilados: 
const char nome[] = "JP Briggs"; // o tipo do nome é 
// const char[13] 
const char * ptrToName = nome; // array decai para ponteiro Aqui, o ponteiro 
const char* ptrToName está sendo inicializado com name , que é um const 
caractere[13] . Esses tipos ( const char* e const char[13] ) não são iguais, mas 
devido à regra de decaimento de array para ponteiro, o código é compilado. 
Mas e se um array for passado para um modelo usando um parâmetro por 
valor? O que acontece depois? 
modelo 
vazio f (parâmetro T); // modelo com parâmetro por valor 
f(nome); // quais tipos são deduzidos para T e param? 
Começamos com a observação de que não existe parâmetro de função que 
seja um array. Sim, sim, a sintaxe é legal, 
void minhaFunc(int param [] ); 
mas a declaração do array é tratada como uma declaração de ponteiro, o que 
significa que myFunc poderia ser declarado equivalentemente assim: void 
myFunc(int * param); //mesma função acima 
Essa equivalência de parâmetros de array e ponteiro é um pouco de folhagem 
que brota das raízes C na base do C++ e promove a ilusão de que os tipos de 
array e ponteiro são iguais. 
 
18 | Item 1 
Como as declarações de parâmetros de matriz são tratadas como se fossem 
parâmetros de ponteiro, o tipo de matriz que é passado para uma função de 
modelo por valor é deduzido como sendo um tipo de ponteiro. Isso significa 
que na chamada ao template f , seu parâmetro de tipo T é deduzido como 
const char* : f(nome); // o nome é um array, mas T deduzido como const char* 
Mas agora vem uma bola curva. Embora as funções não possam declarar 
parâmetros que sejam verdadeiramente arrays, elas podem declarar 
parâmetros que sejam referências a arrays! Então, se modificarmos o modelo 
f para tomar seu argumento por referência, 
modelo 
vazio f(T & parâmetro); // modelo com parâmetro por referência 
e passamos um array para ele, 
f(nome); //passa matriz para f 
o tipo deduzido para T é o tipo real do array! Esse tipo inclui o tamanho da 
matriz, portanto, neste exemplo, T é deduzido como const Caracteres [13] , e 
o tipo do parâmetro de f (uma referência a este array) é const Caracteres 
(&)[13] . Sim, a sintaxe parece tóxica, mas saber disso lhe dará muitos pontos 
com as poucas almas que se importam. 
Curiosamente, a capacidade de declarar referências a arrays permite a 
criação de um modelo que deduz o número de elementos que um array 
contém: 
// retorna o tamanho de um array como uma constante em tempo de 
compilação. (O 
// parâmetro do array não tem nome, porque nos preocupamos apenas 
com 
// o número de elementos que ele contém.) 
template // veja informações constexpr 
std::size_t arraySize( T (&)[N] ) noexcept // abaixo em { // constexpr 
retornar N ; // e } // noexcept Como o item 15 explica, declarar esta função 
constexpr disponibiliza seu resultado durante a compilação. Isso torna 
possível declarar, digamos, um array com o mesmo número de elementos que 
um segundo array cujo tamanho é calculado a partir de um inicializador entre 
chaves: 
int keyVals[] = { 1, 3, 7, 9, 11, 22, 35 }; //keyVals tem 
//7 elementos 
 
 Ponto 1 | 19 
int mapeadoVals[ arraySize(keyVals) ]; // o mesmo acontece 
//Vals mapeados 
É claro que, como um desenvolvedor C++ moderno, você naturalmente 
prefere um std::array a um array integrado: 
std::array mappedVals; // mapeadoVals' 
// size is 7 Quanto ao arraySize ser declarado noexcept , isso ajuda os 
compiladores a gerar um código melhor. Para obter detalhes, consulte o item 
14 . 
Argumentos de função 
Matrizes não são as únicas coisas em C++ que podem decair em ponteiros. 
Os tipos de função podem decair em ponteiros de função, e tudo o que 
discutimos sobre a dedução de tipo para matrizes se aplica à dedução de tipo 
para funções e seu decaimento em ponteiros de função. Como resultado: 
void algumaFunc(int, double); // someFunc é uma função; 
// o tipo é void(int, double) 
modelo 
vazio f1 (parâmetro T); // em f1, parâmetro passado por valor 
modelo 
void f2(T& param); // em f2, parâmetro passado por ref 
f1(algumaFunc); // parâmetro deduzido como ptr-to-func; 
// o tipo é void (*)(int, double) 
f2(algumaFunc); // parâmetro deduzido como ref-to-func; // 
type is void (&)(int, double) Isso raramente faz alguma diferença na prática, mas 
se você quiser saber sobre decaimento de array para ponteiro, também deve 
saber sobre decaimento de função para ponteiro. 
Então aí está: as regras relacionadas automaticamente para dedução de tipo 
de modelo. Observei no início que eles são bastante diretos e, na maior parte, 
são. No entanto, o tratamento especial concedido aos lvalues ao deduzir tipos 
para referências universais turva um pouco a água, e as regras de decaimento 
para ponteiro para matrizes e funções provocam uma turbidez ainda maior. Às 
vezes você simplesmente quer pegar seus compiladores e exigir: “Diga-me 
que tipo você está deduzindo!” Quando isso acontecer, vá para o Item 4 , 
porque ele é dedicado a persuadir os compiladores a fazer exatamente isso. 
 
20 | Item 1 
Coisas para lembrar 
• Durante a dedução do tipo de modelo, os argumentos que são 
referências são tratados como não-referências, ou seja, sua referência 
é ignorada. 
• Ao deduzir tipos para parâmetros de referência universais, os 
argumentos lvalue recebem tratamento especial. 
• Ao deduzir tipos para parâmetros por valor, argumentos const e/ou 
voláteis são tratados como não- const e não- voláteis . 
• Durante a dedução do tipo de modelo, os argumentos que são nomes 
de matrizes ou funções decaem em ponteiros, a menos que sejam 
usados para inicializar referências. 
Item 2: Entenda a dedução automática . 
Se você leu o Item 1 sobre dedução por tipo de modelo, já sabe quase tudo o 
que precisa saber sobre dedução por tipo automático , porque, com apenas 
uma exceção curiosa, a dedução por tipo automático é uma dedução por tipo 
de modelo. Mas como pode ser isso? A dedução do tipo de modelo envolve 
modelos, funções e parâmetros, mas o modo automático não lida com 
nenhuma dessas coisas. 
Isso é verdade, mas não importa. Há um mapeamento direto entre a dedução 
do tipo de modelo e a dedução automática do tipo.Há literalmente uma 
transformação algorítmica de um para outro. 
No Item 1 , a dedução do tipo de modelo é explicada usando este modelo de 
função geral 
template 
void f( ParamType param); e 
esta chamada geral: 
f( expr ); // chama f com alguma expressão Na chamada para f , os 
compiladores usam expr para deduzir tipos para T e ParamType . 
 
 Ponto 2 | 21 
Quando uma variável é declarada usando auto , auto desempenha o papel de 
T no modelo e o especificador de tipo da variável atua como ParamType . Isto 
é mais fácil de mostrar do que descrever, então considere este exemplo: auto 
x = 27; 
Aqui, o especificador de tipo para x é simplesmente automático por si só. Por 
outro lado, nesta declaração, 
const auto cx=x; 
o especificador de tipo é const automático . E aqui, 
const automático& rx = x; 
o especificador de tipo é const automático& . Para deduzir tipos para x , cx e 
rx nestes exemplos, os compiladores agem como se houvesse um modelo 
para cada declaração, bem como uma chamada para esse modelo com a 
expressão de inicialização correspondente: 
template // modelo conceitual para void func_for_x( T 
param); //deduzindo o tipo de x 
func_for_x(27); // chamada conceitual: parâmetros 
// o tipo deduzido é o tipo de x 
template // modelo conceitual para void func_for_cx( 
const T param); //deduzindo o tipo de cx 
func_for_cx(x); // chamada conceitual: parâmetros 
// tipo deduzido é o tipo de cx 
template // modelo conceitual para void func_for_rx( 
const T& param); //deduzindo o tipo de rx 
func_for_rx(x); // chamada conceitual: parâmetros // tipo 
deduzido é o tipo de rx Como eu disse, deduzir tipos para auto é, com apenas 
uma exceção (que discutiremos em breve), o mesmo que deduzir tipos para 
templates. 
O item 1 divide a dedução do tipo de modelo em três casos, com base nas 
características de ParamType , o especificador de tipo para param no modelo 
de função geral. Em uma declaração de variável usando auto , o especificador 
de tipo toma o lugar de ParamType , portanto há três casos para isso também: 
• Caso 1: O especificador de tipo é um ponteiro ou referência, mas não uma 
referência universal. 
 
22 | 
• Caso 2: O especificador de tipo é uma referência universal. 
• Caso 3: O especificador de tipo não é um ponteiro nem uma referência. 
Já vimos exemplos dos casos 1 e 3: 
automático x = 27; // caso 3 (x não é nem ptr nem referência) const 
auto cx = x; // caso 3 (cx também não é) 
const automático& rx = x; // caso 1 (rx é uma referência não universal) 
O caso 2 funciona como esperado: 
automático&& uref1 = x; // x é int e lvalue, 
// então o tipo do uref1 é int& 
auto&& uref2 = cx; //cx é const int e lvalue, // 
então o tipo do uref2 é const int& 
auto&& uref3 = 27; // 27 é int e rvalue, // 
então o tipo do uref3 é int&& 
O item 1 conclui com uma discussão sobre como nomes de arrays e funções 
decaem em ponteiros para especificadores de tipo sem referência. Isso 
também acontece na dedução automática de tipo: 
const char name[] = // o tipo do nome é const char[13] "RN Briggs"; 
auto arr1 = nome; // o tipo do arr1 é const char * 
auto& arr2 = nome; // o tipo do arr2 é // 
const char ( & )[13] 
void algumaFunc(int, double); // someFunc é uma função; 
// o tipo é void(int, double) 
automática1 = algumaFunc; // o tipo da func1 é 
// vazio ( * )(int, duplo) 
auto& func2 = algumaFunc; // o tipo de func2 é 
// vazio ( & )(int, duplo) 
 
 Ponto 2 | 23 
Item 2 
Como você pode ver, a dedução automática de tipo funciona como a dedução 
de tipo de modelo. São essencialmente dois lados da mesma moeda. 
Exceto pela única maneira em que diferem. Começaremos observando que 
se você quiser declarar um int com um valor inicial de 27, o C++ 98 oferece 
duas opções sintáticas: 
interno x1 = 27; 
interno x2(27); 
C++ 11, por meio de seu suporte para inicialização uniforme, adiciona estes: 
intx3 ={27}; int 
x4{27}; 
Ao todo, quatro sintaxes, mas apenas um resultado: um int com valor 27. 
Mas como o item 5 explica, há vantagens em declarar variáveis usando auto 
em vez de tipos fixos, então seria bom substituir int por auto nas declarações 
de variáveis acima. A substituição textual direta produz este código: 
automático x1 = 
27; automático 
x2(27); 
automático x3 = 
{27}; automático 
x4{27}; 
Todas essas declarações são compiladas, mas não têm o mesmo significado 
daquelas que substituem. As duas primeiras declarações, de fato, declaram 
uma variável do tipo int com valor 27. As duas segundas, entretanto, declaram 
uma variável do tipo std::initial izer_list contendo um único elemento com 
valor 27! 
automático x1 = 27; // o tipo é int , o valor é 27 auto x2(27); // 
idem 
automático x3 = {27}; // o tipo é std::initializer_list , 
// o valor é { 27 } 
automático x4{27}; // idem 
Isso se deve a uma regra de dedução de tipo especial para auto . Quando o 
inicializador de uma variável declarada automaticamente está entre colchetes, 
o tipo deduzido é std::initial izer_list . Se tal tipo não puder ser deduzido (por 
 
24 | 
exemplo, porque os valores no inicializador entre chaves são de tipos 
diferentes), o código será rejeitado: 
automático x5 = {1, 2, 3,0 }; //erro! não posso deduzir T para 
// std::initializer_list 
Como o comentário indica, a dedução de tipo falhará neste caso, mas é 
importante reconhecer que na verdade existem dois tipos de dedução de tipo. 
Um tipo decorre do uso de auto : o tipo de x5 deve ser deduzido. Como o 
inicializador de x5 está entre colchetes, x5 deve ser deduzido como 
std::initializer_list . Mas std::initial izer_list é um modelo. As instanciações são 
std::initializer_list para algum tipo T , e isso significa que o tipo de T 
também deve ser deduzido. Essa dedução se enquadra no âmbito do segundo 
tipo de dedução que ocorre aqui: a dedução do tipo modelo. Neste exemplo, 
essa dedução falha porque os valores no inicializador entre chaves não têm 
um único tipo. 
O tratamento de inicializadores com chaves é a única maneira pela qual a 
dedução de tipo automático e a dedução de tipo de modelo diferem. Quando 
uma variável declarada automaticamente é inicializada com um inicializador 
entre chaves, o tipo deduzido é uma instanciação de std::initializer_list . Mas 
se o modelo correspondente for passado pelo mesmo inicializador, a dedução 
de tipo falhará e o código será rejeitado: 
automático x = {11, 23, 9} ; // o tipo de x é // 
std::initializer_list 
template // template com parâmetro void f( T 
param); //declaração equivalente a 
//declaração de x 
f( { 11, 23, 9 } ); //erro! não é possível deduzir o tipo para T 
No entanto, se você especificar no modelo que param é um 
std::initializer_list para algum T desconhecido , a dedução do tipo de 
modelo deduzirá o que T é: 
modelo 
void f( std::initializer_list initList); 
f( { 11, 23, 9 } ); //T deduzido como int e initList's // o 
tipo é std::initializer_list 
Portanto, a única diferença real entre a dedução de tipo automático e de 
modelo é que auto assume que um inicializador reforçado representa um 
std::initializer_list , mas modelo 
 
 Ponto 2 | 25 
tipo dedução não. 
Você pode estar se perguntando por que a dedução automática de tipo tem 
uma regra especial para inicializadores com chaves, mas a dedução de tipo 
de modelo não. Eu mesmo me pergunto isso. Infelizmente, não consegui 
encontrar uma explicação convincente. Mas a regra é

Mais conteúdos dessa disciplina