Qual é o objetivo do retorno normal?

[dcl.attr.noreturn] fornece o seguinte exemplo:

[[ noreturn ]] void f() {
    throw "error";
    // OK
}

mas eu não entendo qual é o objetivo [[noreturn]], porque o tipo de retorno da função já é void.

Então, qual é o objetivo do noreturnatributo? Como é que deve ser usado?

O atributo noreturn deve ser usado para funções que não retornam ao chamador. Isso não significa funções nulas (que retornam ao chamador - elas simplesmente não retornam um valor), mas funções em que o fluxo de controle não retornará à função de chamada após o término da função (por exemplo, funções que saem do aplicativo, para sempre ou faça exceções, como no seu exemplo).

Isso pode ser usado pelos compiladores para fazer algumas otimizações e gerar melhores avisos. Por exemplo, se ftiver o atributo noreturn, o compilador poderá avisá-lo sobre o g()código morto quando você escrever f(); g();. Da mesma forma, o compilador saberá não avisá-lo sobre a falta de instruções de retorno após as chamadas para f().

noreturnnão informa ao compilador que a função não retorna nenhum valor. Diz ao compilador que o fluxo de controle não retornará ao chamador . Isso permite que o compilador faça uma variedade de otimizações - ele não precisa salvar nem restaurar nenhum estado volátil da chamada, pode eliminar o código morto para eliminar qualquer código que, de outra forma, seguiria a chamada, etc.

Isso significa que a função não será concluída. O fluxo de controle nunca atingirá a instrução após a chamada para f():

void g() {
   f();
   // unreachable:
   std::cout << "No! That's impossible" << std::endl;
}

As informações podem ser usadas pelo compilador / otimizador de diferentes maneiras. O compilador pode adicionar um aviso de que o código acima é inacessível e pode modificar o código real de g()maneiras diferentes, por exemplo, para dar suporte a continuações.

As respostas anteriores explicaram corretamente o que é noreturn, mas não por que ele existe. Eu não acho que os comentários de "otimização" sejam o principal objetivo: as funções que não retornam são raras e geralmente não precisam ser otimizadas. Antes, acho que a principal razão de ser do noreturn é evitar avisos falso-positivos. Por exemplo, considere este código:

int f(bool b){
    if (b) {
        return 7;
    } else {
        abort();
    }
 }

Se abort () não tivesse sido marcado como "noreturn", o compilador pode ter avisado sobre esse código ter um caminho em que f não retorna um número inteiro conforme o esperado. Mas como abort () está marcado como sem retorno, ele sabe que o código está correto.

Digite teoricamente falando, voidé o que é chamado em outros idiomas unitou top. Seu equivalente lógico é True . Qualquer valor pode ser legitimamente convertido para void(todo tipo é um subtipo de void). Pense nisso como um conjunto de "universo"; não há operações em comum a todos os valores no mundo, para que não haja operações válidas em um valor do tipo void. Dito de outra maneira, dizer que algo pertence ao conjunto do universo não fornece nenhuma informação - você já sabe disso. Portanto, o seguinte é válido:

(void)5;
(void)foo(17); // whatever foo(17) does

Mas a tarefa abaixo não é:

void raise();
void f(int y) {
    int x = y!=0 ? 100/y : raise(); // raise() returns void, so what should x be?
    cout << x << endl;
}

[[noreturn]], Por outro lado, é chamado às vezes empty, Nothing, Bottomou Bote é o equivalente lógico de Falso . Ele não possui valores, e uma expressão desse tipo pode ser convertida para (ou seja, é subtipo de) qualquer tipo. Este é o conjunto vazio. Observe que se alguém lhe disser "o valor da expressão foo () pertence ao conjunto vazio" é altamente informativo - informa que essa expressão nunca concluirá sua execução normal; irá abortar, jogar ou travar. É exatamente o oposto de void.

Portanto, o seguinte não faz sentido (pseudo-C ++, pois noreturnnão é do tipo C ++ de primeira classe)

void foo();
(noreturn)5; // obviously a lie; the expression 5 does "return"
(noreturn)foo(); // foo() returns void, and therefore returns

Mas a atribuição abaixo é perfeitamente legítima, pois throwé entendida pelo compilador como não retornando:

void f(int y) {
    int x = y!=0 ? 100/y : throw exception();
    cout << x << endl;
}

Em um mundo perfeito, você pode usar noreturncomo valor de retorno para a função raise()acima:

noreturn raise() { throw exception(); }
...
int x = y!=0 ? 100/y : raise();

Infelizmente, o C ++ não permite isso, provavelmente por razões práticas. Em vez disso, oferece a capacidade de usar [[ noreturn ]]atributos que ajudam a orientar otimizações e avisos do compilador.