Як закінчити код C ++

Я хотів би, щоб мій код C ++ припинив роботу, якщо виконано певну умову, але я не знаю, як це зробити. Тож у будь-який момент, якщо ifтвердження є істинним, скасуйте такий код:

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

Існує декілька способів, але спочатку потрібно зрозуміти, чому очищення об'єкта важливо, а отже, і причина std::exit маргіналізована серед програмістів на C ++.

RAII та розмотування стека

C ++ використовує ідіому під назвою RAII , що, простіше кажучи, означає, що об'єкти повинні виконувати ініціалізацію в конструкторі та очищення в деструкторі. Наприклад,std::ofstream клас [може] відкрити файл під час конструктора, потім користувач виконує вихідні операції над ним, і, нарешті, наприкінці свого життєвого циклу, як правило, визначається його обсягом, називається деструктор, який по суті закриває файл і видаляє будь-який записаний вміст на диск.

Що станеться, якщо ви не потрапите до деструктора, щоб промити та закрити файл? Хто знає! Але, можливо, він не запише всі дані, які він повинен був записати у файл.

Наприклад, розгляньте цей код

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

Що відбувається в кожній можливості:

• Можливість 1: Повернення по суті залишає поточну область функцій, тому вона знає про закінчення життєвого циклу, osтаким чином викликаючи свого деструктора і виконуючи належну очистку, закриваючи та перемикаючи файл на диск.
• Можливість 2: Закидання винятку також піклується про життєвий цикл об'єктів у поточному масштабі, таким чином роблячи належну очистку ...
• Можливість 3: Тут розмотування стека вступає в дію! Навіть незважаючи на те, що виняток закинуто inner_mad, розмотувач піде через стек madі mainвиконати належну очистку, всі об'єкти будуть зруйновані належним чином, включаючи ptrі os.
• Можливість 4: Ну, тут? exitє функцією C, і це не відомо і не сумісне з ідіомами C ++. Він не виконує очищення ваших об'єктів, в тому числі osв тій же самій області. Таким чином, ваш файл не буде закритий належним чином, і тому вміст ніколи не може бути записаний у нього!
• Інші можливості: Це просто залишить основну сферу дії, виконуючи неявну return 0і тим самим надаючи такий же ефект, як і можливість 1, тобто правильне очищення.

Але не будьте настільки впевнені у тому, що я вам щойно сказав (переважно можливості 2 та 3); продовжуйте читати, і ми дізнаємось, як виконати правильне очищення на основі виключень.

Можливі шляхи до кінця

Повернення з головного!

Ви повинні робити це по можливості; завжди віддайте перевагу поверненню зі своєї програми, повертаючи належний статус виходу з основного.

Абонент вашої програми, а можливо, і операційна система, можливо, захоче знати, успішно чи ні було виконано те, що ваша програма повинна зробити. З цієї ж причини вам слід повернути або нуль, або EXIT_SUCCESSсигналізувати про те, що програма успішно завершилась, і EXIT_FAILUREсигнал про те, що програма завершилася невдало, будь-яка інша форма повернутого значення визначається реалізацією ( §18.5 / 8 ).

Однак ви можете бути дуже глибоко в стеці викликів, і повернення всього цього може бути болісним ...

[Не] кидайте виняток

Викидання винятку виконає належну очистку об'єкта за допомогою розмотування стека, викликавши деструктор кожного об'єкта в будь-якому попередньому діапазоні.

Але ось улов ! Це визначено реалізацією, чи виконується розмотування стека, коли викинутий виняток не обробляється (за допомогою пункту catch (...)) або навіть якщо у вас є noexceptфункція посеред стека виклику. Про це йдеться у § 15.5.1 [крім.закінчити] :

1. У деяких ситуаціях обробку винятків потрібно відмовитися від менш тонких методів обробки помилок. [Примітка. Це такі ситуації:

   [...]

   - коли механізм обробки винятків не може знайти обробник для викинутого винятку (15.3), або коли пошук обробника (15.3) стикається із самим зовнішнім блоком функції з noexcept-специфікою , яка не дозволяє виключення (15.4), або [...]

   [...]

2. У таких випадках викликається std :: endinate () (18.8.3). У ситуації, коли не знайдено відповідного обробника, визначається реалізація того, чи слід стек розкручується, перш ніж std :: terminate () викликається [...]

Тож ми мусимо це зловити!

Викиньте виняток і ловіть його головним чином!

Оскільки невиконані винятки можуть не виконувати розмотування стека (і, отже, не виконувати належну очистку) , ми повинні зафіксувати виняток в основному, а потім повернути статус виходу ( EXIT_SUCCESSабо 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;
    }
    /* ... */
}

[Не] std :: вихід

Це не виконує будь-якого типу розмотування стека, і жоден живий об'єкт у стеку не закличе відповідного деструктора для проведення очищення.

Це застосовується в §3.6.1 / 4 [basic.start.init] :

Припинення програми без виходу з поточного блоку (наприклад, викликом функції std :: exit (int) (18.5)) не знищує жодних об'єктів з автоматичною тривалістю зберігання (12.4) . Якщо std :: exit викликається для завершення програми під час знищення об'єкта зі статичною тривалістю або тривалості зберігання, програма має невизначене поведінку.

Подумайте над цим зараз, чому б ви робили таке? Скільки предметів ви болісно пошкодили?

Інші [як погані] альтернативи

Є й інші способи припинення програми (крім збоїв) , але вони не рекомендуються. Просто задля уточнення вони будуть представлені тут. Зверніть увагу, як звичайне завершення програми не означає розмотування стека, а нормальний стан для операційної системи.

• std::_Exit викликає нормальне припинення програми, і все.
• std::quick_exitвикликає нормальне припинення програми та std::at_quick_exitобробляє дзвінки , інша очистка не проводиться.
• std::exitвикликає нормальне припинення програми, а потім викликає std::atexitобробників. Інші види очищення виконуються, наприклад, виклик статичних об'єктів деструкторів.
• std::abortвикликає ненормальне припинення програми, очищення не проводиться. Це слід назвати, якщо програма припиняється дійсно, дійсно несподівано. Це нічого, крім сигналу ОС про аномальне припинення. Деякі системи виконують дамп ядра в цьому випадку.
• std::terminateвиклики, std::terminate_handlerякі дзвінки std::abortза замовчуванням.

Як зазначив Мартін Йорк, вихід не виконує необхідного очищення, як це робить повернення.

Завжди краще використовувати повернення в місці виходу. Якщо ви не в основному, де б ви не хотіли вийти з програми, поверніться до основного.

Розглянемо нижченаведений приклад. За допомогою наступної програми буде створено файл із зазначеним змістом. Але якщо повернення прокоментується і не коментується вихід (0), компілятор не запевняє вас, що у файлі буде потрібний текст.

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

Не тільки це, наявність кількох точок виходу в програму ускладнить налагодження. Використовуйте вихід лише тоді, коли це може бути виправдано.

Викличте std::exitфункцію.   

Люди кажуть "вихід дзвінка (код повернення)", але це погана форма. У невеликих програмах це добре, але з цим існує низка питань:

1. У вас з’явиться кілька точок виходу з програми
2. Це робить код більш складним (наприклад, використання goto)
3. Він не може випустити пам'ять, виділену під час виконання

Дійсно, єдиний раз, коли ви повинні вийти з проблеми, це цей рядок у main.cpp:

return 0;

Якщо ви використовуєте exit () для обробки помилок, вам слід дізнатися про винятки (і вкладення винятків), як про набагато більш елегантний і безпечний метод.

return 0;покладіть це куди завгодно, int main()і програма негайно закриється.

Програма припиняється, коли потік виконання досягне кінця основної функції.

Щоб припинити його раніше, ви можете скористатися функцією виходу (статус int), де статус - це значення, яке повертається до будь-якої запущеної програми. 0 зазвичай вказує на стан непомилки

Або поверніть значення зі свого mainабо скористайтеся exitфункцією. Обидва беруть інт. Насправді не важливо, яке значення ви повертаєте, якщо у вас немає зовнішнього процесу, який слідкує за значенням повернення.

Якщо у вас є помилка десь у коді, то або киньте виняток, або встановіть код помилки. Завжди краще кинути виняток, а не встановлювати коди помилок.

Як правило, ви використовуєте exit()метод з відповідним статусом виходу .

Нуль означатиме успішний біг. Ненульовий статус вказує на певну проблему. Цей вихідний код використовується батьківськими процесами (наприклад, скриптами оболонки), щоб визначити, чи успішно працює процес.

Крім виклику exit (error_code) - який викликає обробники atexit, але не деструктори RAII тощо - я все більше і більше використовую винятки.

Все більше і більше виглядає моя основна програма

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

де sekundar_main, де розміщені всі спочатку речі, тобто первинна головна назва перейменована на Second_main, а додається головна заглушка вище. Це просто вигадка, так що між лотком і головним ловом не буде занадто багато коду.

Якщо ви хочете, ловіть інші типи винятків.
Мені дуже подобається ловити типи помилок рядків, як-от std :: string або char *, і друкувати ті, хто знаходиться в оброблювачі вилову в основному.

Використання таких винятків принаймні дозволяє викликати деструктори RAII, щоб вони могли робити очищення. Що може бути приємним і корисним.

Загалом, поводження з помилками C - вихід та сигнали - та поводження з помилками C ++ - випробування / вилов / викидання - грають разом у кращому випадку непослідовно.

Потім, де ви виявите помилку

throw "error message"

або якийсь більш конкретний тип виключення.

Якщо ваш випадок, якщо заявка знаходиться в циклі, ви можете використовувати

 break; 

Якщо ви хочете уникнути деякого коду та продовжуйте циклічно, використовуйте:

продовжувати;

Якщо ваша заява if не знаходиться в циклі, ви можете використовувати:

 return 0;

Or 




  exit();

Чувак ... exit()функція визначається під stdlib.h

Тому потрібно додати препроцесора.

Помістіть include stdlib.hу розділі заголовка

Потім використовуйте exit();куди завгодно, але не забудьте поставити міжрежик у дужках виходу.

наприклад:

exit(0);

Якщо стан, на який я тестую, є справді поганою новиною, я роблю це:

*(int*) NULL= 0;

Це дає мені приємний корредум, звідки я можу вивчити ситуацію.

Щоб розбити умову, використовуйте return (0);

Отже, у вашому випадку це було б:

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