Como terminar o código C++

RAII e Desembrulhamento da pilha

C++ faz uso de um idioma chamado RAII, O que em termos simples significa que os objetos devem realizar a inicialização no construtor e limpeza no destruidor. Por exemplo:std::ofstream classe [maio] abrir o arquivo durante o construtor, em seguida, o usuário executa operações de saída nele, e finalmente no final de seu ciclo de vida, geralmente determinado por seu escopo, o destruidor é chamado que essencialmente fecha o arquivo e descarrega qualquer conteúdo escrito no disco.

Por exemplo, considere este código

#include <fstream>
#include <exception>
#include <memory>

void inner_mad()
{
    throw std::exception();
}

void mad()
{
    std::unique_ptr<int> ptr(new int);
    inner_mad();
}

int main()
{
    std::ofstream os("file.txt");
    os << "Content!!!";

    int possibility = /* either 1, 2, 3 or 4 */;

    if(possibility == 1)
        return 0;
    else if(possibility == 2)
        throw std::exception();
    else if(possibility == 3)
        mad();
    else if(possibility == 4)
        exit(0);
}

• Possibilidade 1: retorno essencialmente deixa o escopo da função atual, então ele sabe sobre o fim do ciclo de vida de {[[4]} assim chamando o seu destruidor e fazendo a limpeza adequada, fechando e limpando o arquivo para o disco.
• possibilidade 2: abrir uma excepção também cuida do ciclo de vida dos objectos no âmbito actual, fazendo assim uma limpeza adequada...
• Possibilidade 3: acção! Mesmo que a exceção seja lançada em inner_mad, o unwinder irá embora a pilha de mad e main para realizar uma limpeza adequada, todos os objetos vão ser destruídos corretamente, incluindo ptr e os.
• Possibilidade 4: bem, aqui? exit é uma função C e não é consciente nem compatível com os idiomas c++. It não realiza limpeza nos seus objectos, incluindo os no mesmo âmbito. Para que o seu ficheiro não seja fechado correctamente e por esta razão, o conteúdo pode nunca ser escrito nele!
• outras possibilidades: ele vai deixar o escopo principal, realizando um implícito {[[12]} e, portanto, ter o mesmo efeito que a possibilidade 1, ou seja, uma limpeza adequada.

Mas não tenha tanta certeza sobre o que eu acabei de lhe dizer (principalmente possibilidades 2 e 3); continue lendo e vamos descobrir como realizar uma limpeza adequada baseada em exceção.

Possíveis Formas De Terminar

Regressar de main!

Você deve fazer isso sempre que possível; sempre prefere retornar do seu programa, retornando um status de saída adequado do main.

A pessoa que ligou do seu programa, e possivelmente o sistema operacional, pode querer saber se o que o seu programa era suposto fazer foi feito com sucesso ou não. Por esta mesma razão você deve retornar ou zero ou EXIT_SUCCESS para sinalizar que o programa terminou com sucesso e EXIT_FAILURE para sinalizar o programa terminado sem sucesso, qualquer outra forma de valor de retorno é definida pela implementação (§18.5/8).

No entanto, você pode estar muito fundo na pilha de chamadas, e devolver tudo isso pode ser doloroso...

[não] abrir uma excepção

1. Em algumas situações, o tratamento de excepções deve ser abandonado por técnicas menos subtis de tratamento de erros. [Nota: estas situações são:

   [...]

   - quando o mecanismo de tratamento de exceções não é possível encontrar um manipulador para uma exceção lançada (15.3), ou quando a busca por um manipulador (15.3) encontra o bloco Mais externo de uma função com uma noexcept-Especificação que não permite a exceção (15.4), ou [...]

   [...]

2. Em tais casos, std:: terminate () é chamado (18.8.3). Na situação em que não é encontrado nenhum manipulador correspondente, é definido pela implementação se a pilha está ou não desligada antes da DST:: terminate () é chamada [...]

, uma vez que não identificada exceções não podem realizar desenrolar a pilha (e, consequentemente, não executar a limpeza adequada), devemos capturar a exceção principal e, em seguida, retornar a um estado de saída (EXIT_SUCCESS ou EXIT_FAILURE).

int main()
{
    /* ... */
    try
    {
        // Insert code that will return by throwing a exception.
    }
    catch(const std::exception&)  // Consider using a custom exception type for intentional
    {                             // throws. A good idea might be a `return_exception`.
        return EXIT_FAILURE;
    }
    /* ... */
}

[Não] DST::exit

Isto não execute qualquer tipo de pilha de descompressão, e nenhum objeto vivo na pilha irá chamar o seu respectivo destruidor para realizar a limpeza.

Isto é imposto em §3.6.1/4 [básico.Comece.init]:

Terminar o programa sem sair do bloco atual (por exemplo, chamando a função std:: exit (int) (18.5)) não destrói nenhum objeto com duração de armazenamento automático (12.4) . Se std:: exit é chamado para terminar um programa durante a destruição de um objeto com duração estática ou de armazenamento de thread, o programa tem um comportamento indefinido.

Outras [más] alternativas