Как завершить код 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: Return, по существу, оставляет текущую область действия функции, поэтому он знает о конце жизненного цикла 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 [except.terminate] :

1. В некоторых ситуациях обработка исключений должна быть прекращена для менее тонких методов обработки ошибок. [Примечание: эти ситуации:

   [...]

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

   [...]

2. В таких случаях вызывается std :: terminate () (18.8.3). В ситуации, когда соответствующий обработчик не найден, определяется реализацией, будет ли стек разматываться перед вызовом std :: terminate () [...]

Таким образом, мы должны поймать это!

Сделайте исключение и поймайте его на главном!

Поскольку неперехваченные исключения могут не выполнять разматывание стека (и, следовательно, не будут выполнять надлежащую очистку) , мы должны перехватить исключение в main и затем вернуть состояние выхода ( 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по умолчанию.

Как отметил Мартин Йорк, exit не выполняет необходимую очистку, как return.

Всегда лучше использовать возврат в месте выхода. В случае, если вы не в основном, где бы вы хотели выйти из программы, сначала вернитесь в главное.

Рассмотрим приведенный ниже пример. С помощью следующей программы будет создан файл с указанным содержимым. Но если return является закомментированным и некомментированным exit (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 status), где status - это значение, возвращаемое любому запущенному приложению. 0 обычно указывает на состояние без ошибок

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

Если у вас есть ошибка где-то глубоко в коде, то либо сгенерируйте исключение, либо установите код ошибки. Всегда лучше генерировать исключение вместо установки кодов ошибок.

Обычно вы используете 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);
    }
}

где second_main, в который помещается весь материал, который был первоначально помещен, т.е. исходный main переименовывается в second_main, и добавляется заглушка main выше. Это всего лишь небольшая хитрость, так что между лотком и уловом main не слишком много кода.

Если хотите, ловите другие типы исключений.
Мне очень нравится перехватывать строковые типы ошибок, такие как std :: string или char *, и печатать их в обработчике catch в main.

Использование подобных исключений, по крайней мере, позволяет вызывать деструкторы RAII, чтобы они могли выполнять очистку. Который может быть приятным и полезным.

В целом, обработка ошибок C - выход и сигналы - и обработка ошибок C ++ - исключения try / catch / throw - в лучшем случае несовместимы.

Затем, где вы обнаружите ошибку

throw "error message"

или какой-то более конкретный тип исключения.

Если ваш оператор if находится в цикле, вы можете использовать

 break; 

Если вы хотите избежать некоторого кода и продолжить цикл Используйте:

Продолжать;

Если ваше заявление if не в цикле, вы можете использовать:

 return 0;

Or 




  exit();

Чувак ... exit()функция определена в stdlib.h

Так что вам нужно добавить препроцессор.

Положить include stdlib.hв заголовок раздела

Затем используйте, exit();где хотите, но не забывайте ставить целое число в круглые скобки выхода.

например:

exit(0);

Если условие, которое я проверяю, действительно плохие новости, я делаю это:

*(int*) NULL= 0;

Это дает мне хороший coredump, откуда я могу изучить ситуацию.

Чтобы нарушить условие, используйте return (0);

Итак, в вашем случае это будет:

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