Jogue a palavra-chave na assinatura da função

Qual é a razão técnica pela qual é considerado uma má prática usar a throwpalavra-chave C ++ em uma assinatura de função?

bool some_func() throw(myExc)
{
  ...
  if (problem_occurred) 
  {
    throw myExc("problem occurred");
  }
  ...
}

Não, não é considerado uma boa prática. Pelo contrário, é geralmente considerado uma má ideia.

http://www.gotw.ca/publications/mill22.htm entra em muito mais detalhes sobre o porquê, mas o problema é parcialmente que o compilador não consegue impor isso, portanto, ele deve ser verificado em tempo de execução, o que geralmente é indesejável. E não é bem suportado em nenhum caso. (O MSVC ignora as especificações de exceção, exceto throw (), que ele interpreta como garantia de que nenhuma exceção será lançada.

O Jalf já está vinculado a ele, mas o GOTW explica muito bem por que as especificações de exceção não são tão úteis quanto se poderia esperar:

int Gunc() throw();    // will throw nothing (?)
int Hunc() throw(A,B); // can only throw A or B (?)

Os comentários estão corretos? Nem tanto. Gunc()pode de fato jogar algo e Hunc()pode muito bem jogar algo diferente de A ou B! O compilador apenas garante derrotá-los sem sentido, se o fizerem ... ah, e vencer seu programa sem sentido também, na maioria das vezes.

Isso é exatamente o que acontece, você provavelmente acabará com uma ligação terminate()e seu programa sofrerá uma morte rápida, mas dolorosa.

A conclusão do GOTW é:

Então, aqui está o que parece ser o melhor conselho que nós, como comunidade, aprendemos até hoje:

• Moral nº 1: nunca escreva uma especificação de exceção.
• Moral 2: Exceto possivelmente uma vazia, mas se eu fosse você, evitaria isso.

Para adicionar um pouco mais de valor a todas as outras respostas a essa pergunta, deve-se investir alguns minutos na pergunta: Qual é a saída do código a seguir?

#include <iostream>
void throw_exception() throw(const char *)
{
    throw 10;
}
void my_unexpected(){
    std::cout << "well - this was unexpected" << std::endl;
}
int main(int argc, char **argv){
    std::set_unexpected(my_unexpected);
    try{
        throw_exception();
    }catch(int x){
        std::cout << "catch int: " << x << std::endl;
    }catch(...){
        std::cout << "catch ..." << std::endl;
    }
}

Resposta: Conforme observado aqui , o programa chama std::terminate()e, portanto, nenhum dos manipuladores de exceção será chamado.

Detalhes: A primeira my_unexpected()função é chamada, mas como ela não lança novamente um tipo de exceção correspondente para o throw_exception()protótipo da função, no final, std::terminate()é chamada. Portanto, a saída completa fica assim:

user @ user: ~ / tmp $ g ++ -o exceto.teste exceto.test.cpp
usuário @ usuário: ~ / tmp $ ./except.test
bem - isso foi
encerrado inesperadamente chamado depois de lançar uma instância de 'int'
Abortado (núcleo despejado)

O único efeito prático do especificador throw é que, se algo diferente myExcfor lançado por sua função, std::unexpectedserá chamado (em vez do mecanismo de exceção não tratado normal).

Para documentar o tipo de exceção que uma função pode lançar, normalmente faço o seguinte:

bool
some_func() /* throw (myExc) */ {
}

Quando as especificações de lançamento foram adicionadas à linguagem, foi com as melhores intenções, mas a prática sustentou uma abordagem mais prática.

Com C ++, minha regra geral é usar apenas especificações de lançamento para indicar que um método não pode ser lançado. Esta é uma garantia forte. Caso contrário, suponha que ele possa jogar qualquer coisa.

Bem, enquanto pesquisava sobre essa especificação de lançamento, dei uma olhada neste artigo: - ( http://blogs.msdn.com/b/larryosterman/archive/2006/03/22/558390.aspx )

Também estou reproduzindo uma parte dela aqui, para que possa ser usada no futuro, independentemente do fato do link acima funcionar ou não.

   class MyClass
   {
    size_t CalculateFoo()
    {
        :
        :
    };
    size_t MethodThatCannotThrow() throw()
    {
        return 100;
    };
    void ExampleMethod()
    {
        size_t foo, bar;
        try
        {
            foo = CalculateFoo();
            bar = foo * 100;
            MethodThatCannotThrow();
            printf("bar is %d", bar);
        }
        catch (...)
        {
        }
    }
};

Quando o compilador vê isso, com o atributo "throw ()", ele pode otimizar completamente a variável "bar", porque sabe que não há como lançar uma exceção a partir de MethodThatCannotThrow (). Sem o atributo throw (), o compilador precisa criar a variável "bar", porque se MethodThatCannotThrow lança uma exceção, o manipulador de exceções pode / dependerá do valor da variável de barra.

Além disso, ferramentas de análise de código-fonte como o prefast podem (e usarão) a anotação throw () para melhorar seus recursos de detecção de erros - por exemplo, se você tiver um try / catch e todas as funções que você chamar estiverem marcadas como throw (), você não precisa do try / catch (sim, isso tem um problema se você chamar mais tarde uma função que poderia lançar).

Uma especificação no throw em uma função embutida que retorna apenas uma variável de membro e não pode lançar exceções pode ser usada por alguns compiladores para fazer pessimizações (uma palavra inventada para o oposto de otimizações) que podem ter um efeito prejudicial no desempenho. Isso é descrito na literatura do Boost: especificação de exceção

Com alguns compiladores, uma especificação de não uso em funções não em linha pode ser benéfica se as otimizações corretas forem feitas e o uso dessa função impactar o desempenho da maneira que justifica.

Para mim, parece que usá-lo ou não é uma ligação feita por um olhar muito crítico como parte de um esforço de otimização de desempenho, talvez usando ferramentas de criação de perfil.

Uma citação do link acima para aqueles com pressa (contém um exemplo de efeitos indesejados indesejados da especificação de throw em uma função embutida de um compilador ingênuo):

Justificativa da especificação de exceção

As especificações de exceção [ISO 15.4] às vezes são codificadas para indicar quais exceções podem ser lançadas ou porque o programador espera que elas melhorem o desempenho. Mas considere o seguinte membro de um ponteiro inteligente:

T & operador * () const throw () {return * ptr; }

Esta função não chama outras funções; ele manipula apenas tipos de dados fundamentais como ponteiros. Portanto, nenhum comportamento de tempo de execução da especificação de exceção pode ser invocado. A função é completamente exposta ao compilador; na verdade, é declarado em linha. Portanto, um compilador inteligente pode deduzir facilmente que as funções são incapazes de gerar exceções e fazer as mesmas otimizações que teria feito com base na especificação de exceção vazia. Um compilador "burro", no entanto, pode fazer todos os tipos de pessimizações.

Por exemplo, alguns compiladores desativam o inlining se houver uma especificação de exceção. Alguns compiladores adicionam blocos try / catch. Tais pessimizações podem ser um desastre de desempenho que torna o código inutilizável em aplicativos práticos.

Embora inicialmente atraente, uma especificação de exceção tende a ter conseqüências que requerem uma reflexão muito cuidadosa para serem entendidas. O maior problema com as especificações de exceção é que os programadores as usam como se tivessem o efeito que o programador gostaria, em vez do efeito que realmente têm.

Uma função não embutida é o único local em que uma especificação de exceção "não lança nada" pode ter algum benefício em alguns compiladores.