Comment terminer le code C ++

Je voudrais que mon code C ++ cesse de fonctionner si une certaine condition est remplie, mais je ne sais pas comment faire cela. Donc, à tout moment si une ifdéclaration est vraie, terminez le code comme ceci:

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

Il existe plusieurs façons, mais vous devez d'abord comprendre pourquoi le nettoyage des objets est important, et donc la raison std::exitest marginalisée parmi les programmeurs C ++.

RAII et déroulement de la pile

C ++ utilise un idiome appelé RAII , ce qui signifie en termes simples que les objets doivent effectuer l'initialisation dans le constructeur et le nettoyage dans le destructeur. Par exemple, la std::ofstreamclasse [peut] ouvrir le fichier pendant le constructeur, puis l'utilisateur effectue des opérations de sortie sur celui-ci, et enfin à la fin de son cycle de vie, généralement déterminé par sa portée, le destructeur est appelé qui ferme essentiellement le fichier et vide tout contenu écrit sur le disque.

Que se passe-t-il si vous n'obtenez pas le destructeur pour vider et fermer le fichier? Qui sait! Mais il est possible qu'il n'écrive pas toutes les données qu'il était censé écrire dans le fichier.

Par exemple, considérez ce code

#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);
}

Ce qui se passe dans chaque possibilité est:

• Possibilité 1: Return laisse essentiellement la portée de la fonction actuelle, donc il connaît la fin du cycle de vie d' osappeler ainsi son destructeur et de faire un nettoyage approprié en fermant et en vidant le fichier sur le disque.
• Possibilité 2: le fait de lever une exception prend également en charge le cycle de vie des objets dans la portée actuelle, effectuant ainsi un nettoyage approprié ...
• Possibilité 3: Ici, le déroulement de la pile entre en action! Même si l'exception est lancée inner_mad, le dérouleur passera par la pile de madet mainpour effectuer un nettoyage approprié, tous les objets seront détruits correctement, y compris ptret os.
• Possibilité 4: Eh bien, ici? exitest une fonction C et elle n'est pas consciente ni compatible avec les idiomes C ++. Il n'effectue pas de nettoyage sur vos objets, y compris osdans la même portée. Votre fichier ne sera donc pas fermé correctement et pour cette raison, le contenu pourrait ne jamais y être écrit!
• Autres possibilités: il ne restera plus que la portée principale, en effectuant un implicite return 0et en ayant ainsi le même effet que la possibilité 1, c'est-à-dire un nettoyage correct.

Mais ne soyez pas si sûr de ce que je viens de vous dire (principalement les possibilités 2 et 3); continuez à lire et nous découvrirons comment effectuer un nettoyage approprié basé sur les exceptions.

Façons possibles de mettre fin

Retour de main!

Vous devriez le faire chaque fois que possible; préférez toujours revenir de votre programme en renvoyant un état de sortie correct de main.

L'appelant de votre programme, et peut-être le système d'exploitation, voudra peut-être savoir si ce que votre programme était censé faire a été fait avec succès ou non. Pour cette même raison, vous devez retourner zéro ou EXIT_SUCCESSsignaler que le programme s'est terminé avec succès et EXIT_FAILUREsignaler que le programme s'est terminé sans succès, toute autre forme de valeur de retour est définie par l'implémentation ( §18.5 / 8 ).

Cependant, vous pouvez être très profondément dans la pile des appels, et retourner tout cela peut être douloureux ...

[Ne pas] lever une exception

Le lancement d'une exception effectuera un nettoyage d'objet approprié à l'aide du déroulement de la pile, en appelant le destructeur de chaque objet dans n'importe quelle portée précédente.

Mais voici le hic ! Il est défini par l'implémentation si le déroulement de la pile est effectué lorsqu'une exception levée n'est pas gérée (par la clause catch (...)) ou même si vous avez une noexceptfonction au milieu de la pile des appels. Ceci est indiqué au §15.5.1 [sauf.terminate] :

1. Dans certaines situations, la gestion des exceptions doit être abandonnée pour des techniques de gestion des erreurs moins subtiles. [Remarque: ces situations sont les suivantes:

   [...]

   - lorsque le mécanisme de gestion des exceptions ne peut pas trouver de gestionnaire pour une exception levée (15.3), ou lorsque la recherche d'un gestionnaire (15.3) rencontre le bloc le plus à l'extérieur d'une fonction avec une noexceptspécification qui n'autorise pas l'exception (15.4), ou [...]

   [...]

2. Dans de tels cas, std :: terminate () est appelé (18.8.3). Dans le cas où aucun gestionnaire correspondant n'est trouvé, il est défini par l'implémentation si la pile est déroulée ou non avant que std :: terminate () soit appelé [...]

Nous devons donc l'attraper!

Jetez une exception et attrapez-la au principal!

Étant donné que les exceptions non capturées peuvent ne pas effectuer le déroulement de la pile (et, par conséquent, ne pas effectuer le nettoyage approprié) , nous devons intercepter l'exception en principal, puis renvoyer un état de sortie ( EXIT_SUCCESSou EXIT_FAILURE).

Donc, une bonne configuration pourrait être:

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;
    }
    /* ... */
}

[Ne pas] std :: exit

Cela n'effectue aucune sorte de déroulement de la pile, et aucun objet vivant sur la pile n'appellera son destructeur respectif pour effectuer le nettoyage.

Ceci est appliqué au §3.6.1 / 4 [basic.start.init] :

Terminer le programme sans quitter le bloc courant (par exemple, en appelant la fonction std :: exit (int) (18.5)) ne détruit aucun objet avec une durée de stockage automatique (12.4) . Si std :: exit est appelé pour terminer un programme pendant la destruction d'un objet avec une durée de stockage statique ou de thread, le programme a un comportement indéfini.

Pensez-y maintenant, pourquoi feriez-vous une telle chose? Combien d'objets avez-vous douloureusement endommagés?

Autres alternatives [aussi mauvaises]

Il existe d'autres façons de mettre fin à un programme (autre que le plantage) , mais elles ne sont pas recommandées. Pour plus de précision, ils vont être présentés ici. Remarquez comment la fin normale d'un programme ne signifie pas un déroulement de la pile mais un état correct pour le système d'exploitation.

• std::_Exit provoque une interruption normale du programme, et c'est tout.
• std::quick_exitprovoque un arrêt normal du programme et appelle les std::at_quick_exitgestionnaires, aucun autre nettoyage n'est effectué.
• std::exitprovoque un arrêt normal du programme et appelle ensuite les std::atexitgestionnaires. D'autres types de nettoyage sont effectués, comme l'appel de destructeurs d'objets statiques.
• std::abortprovoque une interruption anormale du programme, aucun nettoyage n'est effectué. Cela devrait être appelé si le programme s'est terminé d'une manière vraiment, vraiment inattendue. Cela ne fera que signaler au système d'exploitation la fin anormale. Certains systèmes effectuent un vidage de mémoire dans ce cas.
• std::terminateappelle le std::terminate_handlerqui appelle std::abortpar défaut.

Comme Martin York l'a mentionné, la sortie n'effectue pas le nettoyage nécessaire comme le fait le retour.

Il est toujours préférable d'utiliser le retour au lieu de sortie. Si vous n'êtes pas dans main, où que vous souhaitiez quitter le programme, revenez d'abord à main.

Considérez l'exemple ci-dessous. Avec le programme suivant, un fichier sera créé avec le contenu mentionné. Mais si return est commenté et sortie non commentée (0), le compilateur ne vous garantit pas que le fichier aura le texte requis.

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

Non seulement cela, avoir plusieurs points de sortie dans un programme rendra le débogage plus difficile. N'utilisez exit que lorsque cela peut être justifié.

Appelez la std::exitfonction.   

Les gens disent "appeler la sortie (code retour)", mais c'est une mauvaise forme. Dans les petits programmes, c'est bien, mais cela pose un certain nombre de problèmes:

1. Vous finirez par avoir plusieurs points de sortie du programme
2. Cela rend le code plus compliqué (comme l'utilisation de goto)
3. Il ne peut pas libérer la mémoire allouée au moment de l'exécution

Vraiment, le seul moment où vous devez quitter le problème est avec cette ligne dans main.cpp:

return 0;

Si vous utilisez exit () pour gérer les erreurs, vous devez vous renseigner sur les exceptions (et les exceptions d'imbrication), en tant que méthode beaucoup plus élégante et sûre.

return 0;placez-le où vous voulez int main()et le programme se fermera immédiatement.

Le programme se terminera lorsque le flux d'exécution atteindra la fin de la fonction principale.

Pour le terminer avant cette date, vous pouvez utiliser la fonction exit (int status), où status est une valeur renvoyée à ce qui a démarré le programme. 0 indique normalement un état sans erreur

Soit renvoyez une valeur de votre, mainsoit utilisez la exitfonction. Les deux prennent un int. Peu importe la valeur que vous renvoyez, sauf si un processus externe surveille la valeur de retour.

Si vous avez une erreur quelque part au fond du code, lève une exception ou définit le code d'erreur. Il est toujours préférable de lever une exception au lieu de définir des codes d'erreur.

En général, vous utiliseriez la exit()méthode avec un état de sortie approprié .

Zéro signifierait une course réussie. Un état différent de zéro indique qu'une sorte de problème s'est produit. Ce code de sortie est utilisé par les processus parents (par exemple les scripts shell) pour déterminer si un processus s'est correctement exécuté.

Au-delà d'appeler exit (error_code) - qui appelle des gestionnaires atexit, mais pas des destructeurs RAII, etc. - j'utilise de plus en plus d'exceptions.

De plus en plus mon programme principal ressemble

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);
    }
}

où primary_main dans où toutes les choses qui étaient à l'origine sont placées - c'est-à-dire que le principal original est renommé secondaire_main, et le stub principal ci-dessus est ajouté. C'est juste une subtilité, de sorte qu'il n'y a pas trop de code entre le plateau et la prise principale.

Si vous le souhaitez, interceptez d'autres types d'exceptions.
J'aime bien attraper les types d'erreur de chaîne, comme std :: string ou char *, et les imprimer dans le gestionnaire de capture en principal.

L'utilisation d'exceptions comme celle-ci permet au moins d'appeler les destructeurs RAII, afin qu'ils puissent faire le nettoyage. Ce qui peut être agréable et utile.

Dans l'ensemble, la gestion des erreurs C - sortie et signaux - et la gestion des erreurs C ++ - exceptions try / catch / throw - jouent ensemble au mieux de manière incohérente.

Ensuite, où vous détectez une erreur

throw "error message"

ou un type d'exception plus spécifique.

Si votre instruction if est en boucle, vous pouvez utiliser

 break; 

Si vous voulez échapper du code et continuer à boucler Utilisez:

continuer;

Si votre instruction if n'est pas dans la boucle, vous pouvez utiliser:

 return 0;

Or 




  exit();

La exit()fonction Dude ... est définie sous stdlib.h

Vous devez donc ajouter un préprocesseur.

Mettez include stdlib.hdans la section d'en-tête

Ensuite, utilisez exit();où vous voulez, mais n'oubliez pas de mettre un nombre entier entre parenthèses de sortie.

par exemple:

exit(0);

Si la condition pour laquelle je teste est vraiment une mauvaise nouvelle, je fais ceci:

*(int*) NULL= 0;

Cela me donne un joli coredump d'où je peux examiner la situation.

Pour rompre une condition, utilisez le retour (0);

Donc, dans votre cas, ce serait:

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