Como finalizar o código C ++

Gostaria que meu código C ++ parasse de executar se uma determinada condição fosse atendida, mas não sei como fazer isso. Portanto, a qualquer momento, se uma ifafirmação for verdadeira, encerre o código da seguinte maneira:

if (x==1)
{
    kill code;
}

Existem várias maneiras, mas primeiro você precisa entender por que a limpeza de objetos é importante e, portanto, o motivo std::exité marginalizado entre os programadores de C ++.

RAII e desbobinamento de pilha

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

O que acontece se você não chegar ao destruidor para liberar e fechar o arquivo? Quem sabe! Mas, possivelmente, ele não gravará todos os dados que deveria gravar no arquivo.

Por exemplo, considere este código

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

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

void mad()
{
    auto ptr = std::make_unique<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);
}

O que acontece em cada possibilidade é:

• Possibilidade 1: Return essencialmente deixa o escopo da função atual, para que ele saiba sobre o final do ciclo de vida os, chamando seu destruidor e fazendo a limpeza adequada, fechando e liberando o arquivo para o disco.
• Possibilidade 2: lançar uma exceção também cuida do ciclo de vida dos objetos no escopo atual, fazendo assim uma limpeza adequada ...
• Possibilidade 3: Aqui o desenrolar da pilha entra em ação! Mesmo que a exceção seja lançada inner_mad, o desbobinador passará pela pilha made mainrealizará a limpeza adequada, todos os objetos serão destruídos corretamente, incluindo ptre os.
• Possibilidade 4: Bem, aqui? exité uma função C e não está ciente nem é compatível com os idiomas C ++. Ele não executa a limpeza em seus objetos, inclusive osno mesmo escopo. Portanto, seu arquivo não será fechado corretamente e, por esse motivo, o conteúdo poderá nunca ser gravado nele!
• Outras possibilidades: deixará o escopo principal apenas, executando um implícito return 0e, portanto, tendo o mesmo efeito que a possibilidade 1, ou seja, limpeza adequada.

Mas não tenha tanta certeza do que acabei de lhe contar (principalmente as possibilidades 2 e 3); continue lendo e descobriremos como executar uma limpeza adequada baseada em exceções.

Possíveis maneiras de terminar

Retorno do main!

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

O chamador do seu programa e, possivelmente, o sistema operacional, pode querer saber se o que seu programa deveria fazer foi feito com êxito ou não. Por esse mesmo motivo, você deve retornar zero ou EXIT_SUCCESSsinalizar que o programa foi finalizado com êxito e EXIT_FAILUREsinalizar que o programa foi finalizado sem êxito, qualquer outra forma de valor de retorno é definida pela implementação ( §18.5 / 8 ).

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

[Não] lance uma exceção

Lançar uma exceção executará a limpeza adequada do objeto usando o desenrolamento da pilha, chamando o destruidor de cada objeto em qualquer escopo anterior.

Mas aqui está o problema ! É definido pela implementação se o desenrolamento da pilha é executado quando uma exceção lançada não é tratada (pela cláusula catch (...)) ou mesmo se você tem uma noexceptfunção no meio da pilha de chamadas. Isto é afirmado em §15.5.1 [exceto.terminar] :

1. Em algumas situações, o tratamento de exceções deve ser abandonado para técnicas de tratamento de erros menos sutis. [Nota: Essas situações são:

   [...]

   - quando o mecanismo de tratamento de exceções não puder encontrar um manipulador para uma exceção lançada (15.3), ou quando a procura de um manipulador (15.3) encontrar o bloco mais externo de uma função com uma noexceptespecificação que não permita a exceção (15.4), ou [...]

   [...]

2. Nesses casos, std :: terminate () é chamado (18.8.3). Na situação em que nenhum manipulador correspondente é encontrado, é definido como implementação se a pilha é ou não desenrolada antes que std :: terminate () seja chamado [...]

Então nós temos que pegá-lo!

Lance uma exceção e pegue-a na principal!

Como as exceções não capturadas podem não executar o desenrolamento da pilha (e consequentemente não executam a limpeza adequada) , devemos capturar a exceção no main e retornar um status de saída ( EXIT_SUCCESSou EXIT_FAILURE).

Portanto, uma configuração possivelmente boa seria:

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] std :: exit

Isso não realiza nenhum tipo de desenrolamento da pilha, e nenhum objeto ativo na pilha chama seu respectivo destruidor para executar a limpeza.

Isso é imposto em §3.6.1 / 4 [basic.start.init] :

Encerrar 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 automática de armazenamento (12.4) . Se std :: exit for chamado para encerrar um programa durante a destruição de um objeto com duração de armazenamento estático ou de encadeamento, o programa terá um comportamento indefinido.

Pense nisso agora, por que você faria uma coisa dessas? Quantos objetos você danificou dolorosamente?

Outras alternativas [tão ruins]

Existem outras maneiras de encerrar um programa (além de travar) , mas elas não são recomendadas. Apenas para fins de esclarecimento, eles serão apresentados aqui. Observe como o término normal do programa não significa o desenrolamento da pilha, mas um estado aceitável para o sistema operacional.

• std::_Exit causa um encerramento normal do programa, e é isso.
• std::quick_exitcausa uma finalização normal do programa e chama os std::at_quick_exitmanipuladores, nenhuma outra limpeza é executada.
• std::exitcausa um encerramento normal do programa e chama os std::atexitmanipuladores. Outros tipos de limpeza são executados, como chamar destruidores de objetos estáticos.
• std::abortcausar um encerramento anormal do programa, nenhuma limpeza será realizada. Isso deve ser chamado se o programa for finalizado de uma maneira realmente inesperada. Ele não fará nada além de sinalizar o SO sobre o término anormal. Alguns sistemas executam um dump principal nesse caso.
• std::terminatechama o std::terminate_handlerque chama std::abortpor padrão.

Como Martin York mencionou, a saída não realiza a limpeza necessária, como o retorno.

É sempre melhor usar o retorno no local de saída. Caso você não esteja no main, onde quer que você saia do programa, volte ao main primeiro.

Considere o exemplo abaixo. Com o programa a seguir, um arquivo será criado com o conteúdo mencionado. Mas se o retorno for comentado e a saída não comentada (0), o compilador não garante que o arquivo terá o texto necessário.

int main()
{
    ofstream os("out.txt");
    os << "Hello, Can you see me!\n";
    return(0);
    //exit(0);
}

Não é só isso, ter vários pontos de saída em um programa tornará a depuração mais difícil. Use exit somente quando isso puder ser justificado.

Chame a std::exitfunção   

As pessoas estão dizendo "saída de chamada (código de retorno)", mas esta é uma forma incorreta. Em programas pequenos, tudo bem, mas há vários problemas com isso:

1. Você terá vários pontos de saída do programa
2. Torna o código mais complicado (como usar goto)
3. Ele não pode liberar memória alocada em tempo de execução

Realmente, a única vez que você deve sair do problema é com esta linha em main.cpp:

return 0;

Se você estiver usando exit () para lidar com erros, deve aprender sobre exceções (e exceções de aninhamento), como um método muito mais elegante e seguro.

return 0;coloque isso onde quiser int main()e o programa será fechado imediatamente.

O programa será encerrado quando o fluxo de execução atingir o final da função principal.

Para finalizá-lo antes disso, você pode usar a função exit (int status), em que status é um valor retornado para o que iniciou o programa. 0 normalmente indica um estado sem erro

Retorne um valor seu mainou use a exitfunção Ambos assumem um int. Realmente não importa qual valor você devolve, a menos que tenha um processo externo observando o valor de retorno.

Se houver um erro em algum lugar profundo do código, lance uma exceção ou defina o código de erro. É sempre melhor lançar uma exceção em vez de definir códigos de erro.

Geralmente você usaria o exit()método com um status de saída apropriado .

Zero significaria uma corrida bem-sucedida. Um status diferente de zero indica que ocorreu algum tipo de problema. Esse código de saída é usado pelos processos pai (por exemplo, scripts de shell) para determinar se um processo foi executado com êxito.

Além de chamar exit (error_code) - que chama manipuladores atexit, mas não destruidores de RAII etc. -, cada vez mais eu uso exceções.

Cada vez mais meu programa principal se parece

int main(int argc, char** argv) 
{
    try {
        exit( secondary_main(argc, argv );
    }
    catch(...) {
        // optionally, print something like "unexpected or unknown exception caught by main"
        exit(1);
    }
}

onde primary_main em onde todas as coisas originalmente foram colocadas - ou seja, o main original é renomeado como secundário_main e o stub main acima é adicionado. Isso é apenas um detalhe, para que não haja muito código entre a bandeja e a captura principal.

Se desejar, pegue outros tipos de exceção.
Eu gosto bastante de capturar tipos de erro de string, como std :: string ou char *, e imprimir aqueles no manipulador de captura principal.

Usar exceções como essa pelo menos permite que os destruidores de RAII sejam chamados, para que eles possam fazer a limpeza. O que pode ser agradável e útil.

No geral, o tratamento de erros em C - saída e sinais - e o tratamento de erros em C ++ - exceções de tentar / capturar / lançar - são executados juntos na melhor das hipóteses.

Então, onde você detecta um erro

throw "error message"

ou algum tipo de exceção mais específico.

Se a sua declaração if estiver em loop, você pode usar

 break; 

Se você deseja escapar de algum código e continuar em loop, use:

continuar;

Se sua instrução if não estiver em Loop, você pode usar:

 return 0;

Or 




  exit();

A exit()função Cara ... é definida em stdlib.h

Então você precisa adicionar um pré-processador.

Coloque include stdlib.hna seção de cabeçalho

Em seguida, use exit();onde quiser, mas lembre-se de colocar um número intermediário entre parênteses de saída.

por exemplo:

exit(0);

Se a condição que estou testando for realmente uma má notícia, eu faço o seguinte:

*(int*) NULL= 0;

Isso me dá um bom coredump de onde posso examinar a situação.

Para quebrar uma condição, use o retorno (0);

Então, no seu caso, seria:

    if(x==1)
    {
        return 0;
    }