В чем разница между exit() и abort() в C и C++? Я пытаюсь завершить программу после ошибки (не исключение).





прервать отправляет сигнал SIGABRT, выход просто закрывает приложение, выполняя обычную очистку.
Вы можете обрабатывать сигнал прервать, как хотите, но по умолчанию приложение также закрывается с кодом ошибки.
прервать не будет выполнять уничтожение ваших статических и глобальных членов, но выход будет.
Конечно, когда приложение полностью закрыто, операционная система освободит всю неиспользованную память и другие ресурсы.
Как при завершении программы прервать, так и выход (при условии, что вы не переопределили поведение по умолчанию), код возврата будет возвращен родительскому процессу, запустившему ваше приложение.
См. Следующий пример:
SomeClassType someobject;
void myProgramIsTerminating1(void)
{
cout<<"exit function 1"<<endl;
}
void myProgramIsTerminating2(void)
{
cout<<"exit function 2"<<endl;
}
int main(int argc, char**argv)
{
atexit (myProgramIsTerminating1);
atexit (myProgramIsTerminating2);
//abort();
return 0;
}
Комментарии:
Если прервать раскомментирован: ничего не печатается и деструктор некоторого объекта не вызывается.
Если прервать прокомментирован, как указано выше: будет вызван деструктор someobject, вы получите следующий результат:
exit function 2
exit function 1
На странице руководства для atexit говорится: «Функции [зарегистрированные с помощью atexit] вызываются в обратном порядке; аргументы не передаются».
@strager прав, функции, зарегистрированные atexit, должны вызываться в обратном порядке, когда вызывается либо exit, либо основной возврат.
Запустив тест, выяснилось, что деструкторы глобальных экземпляров вызываются после всех обратных вызовов atexit.
+1 за напоминание людям, что ОС в конечном итоге освободит все выделенные ресурсы даже после вызова abort ().
Почему все жирное? Лучше организовать в таблицу, имо
abort() выходит из вашей программы без предварительного вызова функций, зарегистрированных с помощью atexit(), и без предварительного вызова деструкторов объектов. exit() делает и то, и другое перед выходом из программы. Однако он не вызывает деструкторы для автоматических объектов. Так
A a;
void test() {
static A b;
A c;
exit(0);
}
Разрушит a и b должным образом, но не вызовет деструкторы c. abort() не будет вызывать деструкторы ни для одного из объектов. Поскольку это прискорбно, Стандарт C++ описывает альтернативный механизм, который обеспечивает правильное завершение:
Objects with automatic storage duration are all destroyed in a program whose function
main()contains no automatic objects and executes the call toexit(). Control can be transferred directly to such amain()by throwing an exception that is caught inmain().
struct exit_exception {
int c;
exit_exception(int c):c(c) { }
};
int main() {
try {
// put all code in here
} catch(exit_exception& e) {
exit(e.c);
}
}
Вместо того, чтобы звонить exit(), используйте вместо этого код throw exit_exception(exit_code);.
+1 потому что, хотя Брайан Р. Бонди был хорош, вы подняли проблему прерывания / выхода (не вызывается деструктор объектов стека) и предложили альтернативу для процесса C++ с интенсивным использованием RAII.
Я искал способ выйти из программы без вызова dtor, и ваш ответ - именно то, что я искал! Спасибо
Это, конечно, совершенно правильно, если действительно важно, что ваши автоматические деструкторы объектов не вызываются :-)
Насколько мне известно, еще одно различие между выходом и прерыванием будет заключаться в том, что прерывание может (в зависимости от конфигурации операционной системы) привести к созданию дампа ядра.
abort отправляет сигнал SIGABRT. abort не возвращается к звонящему. Обработчик сигнала SIGABRT по умолчанию закрывает приложение. Потоки файлов stdio сбрасываются, а затем закрываются. Однако деструкторов для экземпляров классов C++ нет (не уверен в этом - возможно, результаты не определены?).
exit имеет свои собственные обратные вызовы, установленные с помощью atexit. Если обратные вызовы указаны (или только один), они вызываются в порядке, обратном порядку их регистрации (как стек), тогда программа завершается. Как и в случае с abort, exit не возвращается к вызывающему. Потоки файлов stdio сбрасываются, а затем закрываются. Также вызываются деструкторы для экземпляров класса C++.
exit может иметь несколько функций обратного вызова, зарегистрированных через atexit, при вызове exit все функции обратного вызова будут вызываться в обратном порядке, в котором они были зарегистрированы.
@Gamble, конечно, я сам упомянул об этом несколько минут назад в комментарии к ответу @Bondy. Я отредактирую свой ответ, чтобы отразить это.
На странице руководства exit ():
The exit() function causes normal process termination and the value of status & 0377 is returned to the parent.
На странице руководства abort ():
The abort() first unblocks the SIGABRT signal, and then raises that signal for the calling process. This results in the abnormal termination of the process unless the SIGABRT signal is caught and the signal handler does not return.
Когда программа вызывает exit (), происходят следующие вещи:
atexit, выполняютсяtmpfile, удаляются.Функция abort () отправляет сигнал SIGABRT текущему процессу, если он не обнаружен, программа завершается без гарантии, что открытые потоки очищены / закрыты или что временные файлы, созданные с помощью tmpfile, удалены, зарегистрированные функции atexit не вызываются, и хосту возвращается ненулевой статус выхода.
Хм. стандарт гласит, что программа не завершается только в том случае, если обработчик сигнала "не возвращает". у вас все хорошо с C.Можете ли вы представить любой сценарий, который позволил бы продолжить нормальное выполнение без возврата? я представляю longjmp, но я не уверен, как он ведет себя в обработчиках сигналов.
В общем, вызов longjmp из обработчика сигнала не определен, но есть особый случай, когда сигнал был сгенерирован с помощью повышения / прерывания, поэтому я предполагаю, что это было бы теоретически возможно, хотя я не думаю, что когда-либо видел, как это делается. Теперь мне нужно попробовать;)
Кажется, это работает (разбито на несколько сообщений из-за ограничения в 300 символов): #include <stdio.h> #include <stdlib.h> #include <signal.h> #include <setjmp.h> volatile sig_atomic_t do_abort = 1; jmp_buf env; недействительным abort_handler (int я) {do_abort = 0; longjmp (env, 1);}
int main (void) {setjmp (env); put ("В setjmp"); если (do_abort) {сигнал (SIGABRT, abort_handler); put ("Прерывание вызова"); abort (); } put ("Не прервано!"); возврат 0; }
В Ubuntu 7.04 это печатает: При setjmp Прерывание вызова При setjmp Не прервано!
я видел, что он даже поддерживает longjmp из SIGSEGV :) libsigsegv.sourceforge.net
Я считаю, что смыв и закрытие ручья - самое важное отличие. Меня не волнует, освобождены ли мои объекты C++ dtors или ОС, но с вводом-выводом это может иметь большое значение.
Здесь он вызвал функцию выхода 2, ЗАТЕМ функцию выхода 1. gcc 4, Linux 2.6.