Quando devo realmente usar noexcept?

A noexceptpalavra-chave pode ser aplicada adequadamente a muitas assinaturas de funções, mas não tenho certeza sobre quando devo considerar usá-la na prática. Com base no que li até agora, a adição de última hora noexceptparece abordar algumas questões importantes que surgem quando os construtores de movimento jogam. No entanto, ainda não consigo fornecer respostas satisfatórias para algumas perguntas práticas que me levaram a ler mais sobre isso noexceptem primeiro lugar.

1. Existem muitos exemplos de funções que eu sei que nunca serão lançadas, mas para as quais o compilador não pode determinar isso sozinho. Devo acrescentar noexceptà declaração da função em todos esses casos?

   Ter que pensar se eu preciso acrescentar ou não noexceptapós cada declaração de função reduziria bastante a produtividade do programador (e, francamente, seria uma chatice). Para quais situações devo ter mais cuidado com o uso noexcepte para quais situações posso me safar do implícito noexcept(false)?

2. Quando posso realisticamente esperar observar uma melhora no desempenho após o uso noexcept? Em particular, dê um exemplo de código para o qual um compilador C ++ é capaz de gerar um melhor código de máquina após a adição de noexcept.

   Pessoalmente, eu me preocupo com noexcepto aumento da liberdade fornecida ao compilador para aplicar com segurança certos tipos de otimizações. Os compiladores modernos se beneficiam noexceptdessa maneira? Caso contrário, posso esperar que alguns deles o façam no futuro próximo?

Eu acho que é muito cedo para dar uma resposta para as "melhores práticas", pois não houve tempo suficiente para usá-lo na prática. Se isso fosse perguntado sobre os especificadores de lançamento logo após serem lançados, as respostas seriam muito diferentes agora.

Ter que pensar se preciso anexar ou não noexceptapós cada declaração de função reduziria bastante a produtividade do programador (e, francamente, seria uma dor).

Bem, use-o quando for óbvio que a função nunca será lançada.

Quando posso realisticamente esperar observar uma melhora no desempenho após o uso noexcept? [...] Pessoalmente, eu me preocupo por noexceptcausa do aumento da liberdade fornecida ao compilador para aplicar com segurança certos tipos de otimizações.

Parece que os maiores ganhos de otimização são de otimizações de usuários, e não de compiladores, devido à possibilidade de verificar noexcepte sobrecarregar. A maioria dos compiladores segue um método de manipulação de exceção sem penalidade, se não jogar, então duvido que isso mude muito (ou qualquer coisa) no nível do código da máquina, embora talvez reduza o tamanho binário removendo o código de manipulação.

Usar noexceptnos quatro grandes (construtores, atribuição, não destruidores, como já são noexcept) provavelmente causará as melhores melhorias, pois as noexceptverificações são 'comuns' no código do modelo, como em stdcontêineres. Por exemplo, std::vectornão usará a movimentação da sua classe a menos que esteja marcada noexcept(ou o compilador pode deduzir isso de outra forma).

Como eu continuo repetindo esses dias: semântica primeiro .

Adicionando noexcept, noexcept(true)e noexcept(false)é antes de tudo sobre semântica. Incidentalmente, condiciona várias otimizações possíveis.

Como programador de leitura de código, a presença de noexcepté semelhante à de const: ela me ajuda a entender melhor o que pode ou não acontecer. Portanto, vale a pena gastar algum tempo pensando se você sabe ou não se a função será lançada. Para um lembrete, qualquer tipo de alocação de memória dinâmica pode ser lançada.

Ok, agora vamos às possíveis otimizações.

As otimizações mais óbvias são realmente realizadas nas bibliotecas. O C ++ 11 fornece uma série de características que permitem saber se uma função é noexceptou não, e a própria implementação da Biblioteca Padrão usará essas características para favorecer noexceptoperações nos objetos definidos pelo usuário que eles manipulam, se possível. Como mover semântica .

O compilador pode raspar apenas um pouco de gordura (talvez) dos dados de manipulação de exceção, porque precisa levar em conta o fato de que você pode ter mentido. Se uma função marcada noexcepté lançada, então std::terminateé chamada.

Essa semântica foi escolhida por dois motivos:

• beneficiando imediatamente, noexceptmesmo quando as dependências ainda não o usam (compatibilidade com versões anteriores)
• permitindo a especificação de noexceptquando chamar funções que podem ser lançadas teoricamente, mas não são esperadas para os argumentos fornecidos

Isso realmente faz uma diferença (potencialmente) enorme para o otimizador no compilador. Os compiladores realmente têm esse recurso há anos através da instrução throw () vazia após uma definição de função, bem como extensões de propriedade. Posso garantir que os compiladores modernos aproveitam esse conhecimento para gerar um código melhor.

Quase toda otimização no compilador usa algo chamado "gráfico de fluxo" de uma função para raciocinar sobre o que é legal. Um gráfico de fluxo consiste no que geralmente é chamado de "blocos" da função (áreas de código que possuem uma única entrada e uma única saída) e arestas entre os blocos para indicar para onde o fluxo pode saltar. Noexcept altera o gráfico de fluxo.

Você pediu um exemplo específico. Considere este código:

void foo(int x) {
    try {
        bar();
        x = 5;
        // Other stuff which doesn't modify x, but might throw
    } catch(...) {
        // Don't modify x
    }

    baz(x); // Or other statement using x
}

O gráfico de fluxo para esta função é diferente se barestiver rotulado noexcept(não há como a execução saltar entre o final da barinstrução catch). Quando rotulado como noexcept, o compilador tem certeza de que o valor de x é 5 durante a função baz - diz-se que o bloco x = 5 "domina" o bloco baz (x) sem a borda da bar()instrução catch.

Em seguida, ele pode fazer algo chamado "propagação constante" para gerar código mais eficiente. Aqui, se baz estiver alinhado, as instruções que usam x também podem conter constantes e, em seguida, o que costumava ser uma avaliação em tempo de execução pode ser transformada em uma avaliação em tempo de compilação, etc.

De qualquer forma, a resposta curta: noexceptpermite que o compilador gere um gráfico de fluxo mais rígido, e o gráfico de fluxo é usado para raciocinar sobre todos os tipos de otimizações comuns do compilador. Para um compilador, as anotações de usuários dessa natureza são impressionantes. O compilador tentará descobrir essas coisas, mas geralmente não pode (a função em questão pode estar em outro arquivo de objeto não visível para o compilador ou usar transitivamente alguma função que não é visível) ou, quando o faz, existe alguma exceção trivial que pode ser lançada e que você nem conhece, portanto, não pode rotulá-la implicitamente como noexcept(alocar memória pode gerar bad_alloc, por exemplo).

noexceptpode melhorar drasticamente o desempenho de algumas operações. Isso não acontece no nível de geração de código de máquina pelo compilador, mas selecionando o algoritmo mais eficaz: como outros mencionados, você faz essa seleção utilizando a função std::move_if_noexcept. Por exemplo, o crescimento de std::vector(por exemplo, quando chamamos reserve) deve fornecer uma forte garantia de exceção-segurança. Se ele sabe que To construtor de movimento não joga, ele pode simplesmente mover todos os elementos. Caso contrário, ele deve copiar todos os Ts. Isso foi descrito em detalhes neste post .

Quando posso realisticamente, exceto observar uma melhora no desempenho após o uso noexcept? Em particular, dê um exemplo de código para o qual um compilador C ++ é capaz de gerar melhor código de máquina após a adição de noexcept.

Hum, nunca? Nunca é um tempo? Nunca.

noexcepté para otimizações de desempenho do compilador da mesma maneira que constpara otimizações de desempenho do compilador. Ou seja, quase nunca.

noexcepté usado principalmente para permitir que "você" detecte em tempo de compilação se uma função pode gerar uma exceção. Lembre-se: a maioria dos compiladores não emite código especial para exceções, a menos que ele realmente exija algo. Então noexceptnão é uma questão de dar as dicas de compilador sobre como otimizar uma função tanto como dando -lhe dicas sobre como usar uma função.

Modelos como move_if_noexceptirão detectar se o construtor de movimentação está definido com noexcepte retornará um em const&vez de um &&do tipo, se não estiver. É uma maneira de dizer para mudar, se é muito seguro fazê-lo.

Em geral, você deve usar noexceptquando achar que será realmente útil fazê-lo. Algum código seguirá caminhos diferentes se is_nothrow_constructiblefor verdadeiro para esse tipo. Se você estiver usando o código que fará isso, sinta-se à vontade para noexceptos construtores apropriados.

Resumindo: use-o para mover construtores e construções semelhantes, mas não sinta que precisa ficar louco com isso.

Nas palavras de Bjarne ( The C ++ Programming Language, 4ª edição , página 366):

Onde rescisão for uma resposta aceitável, uma exceção não capturada conseguirá isso porque se transforma em uma chamada de terminação () (§13.5.2.5). Além disso, um noexceptespecificador (§13.5.1.1) pode tornar esse desejo explícito.

Os sistemas tolerantes a falhas são bem-sucedidos em vários níveis. Cada nível lida com o maior número possível de erros sem ficar muito distorcido e deixa o restante em níveis mais altos. Exceções suportam essa visão. Além disso, terminate()suporta essa visão fornecendo um escape se o próprio mecanismo de tratamento de exceções estiver corrompido ou se tiver sido usado de maneira incompleta, deixando assim as exceções não detectadas. Da mesma forma, noexceptfornece uma fuga simples para erros em que tentar recuperar parece inviável.

double compute(double x) noexcept;     {
    string s = "Courtney and Anya";
    vector<double> tmp(10);
    // ...
}

O construtor de vetor pode falhar ao adquirir memória para seus dez duplos e lançar a std::bad_alloc. Nesse caso, o programa termina. Ele termina incondicionalmente invocando std::terminate()(§30.4.1.3). Não invoca destruidores de chamar funções. É definido pela implementação se os destruidores dos escopos entre o throwe o noexcept(por exemplo, para s em compute ()) são chamados. O programa está prestes a terminar, portanto, não devemos depender de nenhum objeto. Ao adicionar um noexceptespecificador, indicamos que nosso código não foi gravado para lidar com um arremesso.

1. Existem muitos exemplos de funções que eu sei que nunca serão lançadas, mas para as quais o compilador não pode determinar isso sozinho. Devo acrescentar noexcept à declaração da função em todos esses casos?

noexcepté complicado, pois faz parte da interface de funções. Especialmente, se você estiver escrevendo uma biblioteca, o código do seu cliente pode depender da noexceptpropriedade. Pode ser difícil alterá-lo mais tarde, pois você pode quebrar o código existente. Isso pode ser menos preocupante quando você está implementando código que é usado apenas pelo seu aplicativo.

Se você tem uma função que não pode ser noexceptexecutada , pergunte-se se ela gostaria de permanecer ou isso restringiria futuras implementações? Por exemplo, você pode querer introduzir uma verificação de erro de argumentos ilegais lançando exceções (por exemplo, para testes de unidade) ou pode depender de outro código de biblioteca que possa alterar sua especificação de exceção. Nesse caso, é mais seguro ser conservador e omitir noexcept.

Por outro lado, se você tem certeza de que a função nunca deve ser lançada e está correto que faz parte da especificação, você deve declará-la noexcept. No entanto, lembre-se de que o compilador não poderá detectar violações noexceptse a sua implementação mudar.

2. Para quais situações devo ter mais cuidado com o uso de noexcept e para quais situações posso me safar com o implícito noexcept (false)?

Existem quatro classes de funções nas quais você deve se concentrar porque elas provavelmente terão o maior impacto:

1. mover operações (mover operador de atribuição e mover construtores)
2. operações de swap
3. desalocadores de memória (exclusão do operador, exclusão do operador [])
4. destruidores (embora estes sejam implicitamente, a noexcept(true)menos que você os faça noexcept(false))

Essas funções geralmente devem ser noexcepte é mais provável que as implementações da biblioteca possam fazer uso da noexceptpropriedade. Por exemplo, std::vectorpode usar operações de movimentação sem arremesso sem sacrificar fortes garantias de exceção. Caso contrário, ele terá que voltar aos elementos de cópia (como no C ++ 98).

Esse tipo de otimização está no nível algorítmico e não depende de otimizações do compilador. Pode ter um impacto significativo, especialmente se os elementos forem caros de copiar.

3. Quando posso realisticamente esperar observar uma melhora no desempenho depois de usar o noexcept? Em particular, dê um exemplo de código para o qual um compilador C ++ é capaz de gerar melhor código de máquina após a adição de noexcept.

A vantagem da noexceptespecificação contra nenhuma exceção ou throw()é que o padrão permite aos compiladores mais liberdade quando se trata de empilhar o desenrolamento. Mesmo no throw()caso, o compilador precisa desenrolar completamente a pilha (e deve fazê-lo na ordem inversa exata das construções do objeto).

No noexceptcaso, por outro lado, não é necessário fazer isso. Não é necessário que a pilha precise ser desenrolada (mas o compilador ainda pode fazê-lo). Essa liberdade permite uma otimização adicional do código, pois diminui a sobrecarga de ser sempre capaz de relaxar a pilha.

A pergunta relacionada sobre noexcept, desenrolamento de pilha e desempenho entra em mais detalhes sobre a sobrecarga quando é necessário desenrolar a pilha.

Eu também recomendo o livro de Scott Meyers "Effective Modern C ++", "Item 14: Declarar funções como" Exceto se não emitirem exceções "para leitura posterior.

Existem muitos exemplos de funções que eu sei que nunca serão lançadas, mas para as quais o compilador não pode determinar isso sozinho. Devo acrescentar noexcept à declaração da função em todos esses casos?

Quando você diz "Eu sei que eles nunca serão lançados", você quer dizer que, examinando a implementação da função, você sabe que a função não será lançada. Eu acho que essa abordagem é de dentro para fora.

É melhor considerar se uma função pode lançar exceções para fazer parte do design da função: tão importante quanto a lista de argumentos e se um método é um mutador (... const). Declarar que "essa função nunca gera exceções" é uma restrição na implementação. Omitir isso não significa que a função possa gerar exceções; isso significa que a versão atual da função e todas as versões futuras podem gerar exceções. É uma restrição que dificulta a implementação. Mas alguns métodos devem ter a restrição de serem praticamente úteis; mais importante, para que possam ser chamados de destruidores, mas também para a implementação de código de "reversão" em métodos que fornecem a garantia de exceção forte.