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 é