оператор возврата против выхода () в main ()

Должен ли я использовать exit()или просто returnзаявления в main()? Лично я одобряю returnутверждения, потому что я чувствую, что это похоже на чтение любой другой функции, и управление потоком, когда я читаю код, является плавным (по моему мнению). И даже если я хочу реорганизовать main()функцию, мне returnкажется, что это лучший выбор, чем exit().

Делает exit()что-то особенное, что returnнет?

На самом деле, это различие, но это тонкое. Это имеет больше последствий для C ++, но различия важны.

Когда я звоню returnв main(), деструкторы будут вызываться для моих локально контекстных объектов. Если я позвоню exit(), никакой деструктор не будет вызван для моих локально ограниченных объектов! Перечитайте это. exit() не возвращается . Это означает, что, как только я это называю, «нет бэкси». Любые объекты, которые вы создали в этой функции, не будут уничтожены. Часто это не имеет значения, но иногда это имеет место, например закрытие файлов (конечно, вы хотите, чтобы все ваши данные были записаны на диск?).

Обратите внимание, что staticобъекты будут очищены, даже если вы позвоните exit(). Наконец, обратите внимание, что если вы используете abort(), ни один объект не будет уничтожен. То есть никакие глобальные объекты, никакие статические объекты и никакие локальные объекты не будут вызывать свои деструкторы.

Действуйте с осторожностью, предпочитая выход, а не возврат.

http://groups.google.com/group/gnu.gcc.help/msg/8348c50030cfd15a

Еще одно отличие: exitэто функция стандартной библиотеки, поэтому вам нужно включить заголовки и ссылку на стандартную библиотеку. Чтобы проиллюстрировать (на C ++), это допустимая программа:

int main() { return 0; }

но для использования exitвам понадобится включить:

#include <stdlib.h>
int main() { exit(EXIT_SUCCESS); }

Плюс к этому добавляется дополнительное предположение: у вызова exitfrom mainте же побочные эффекты, что и при возврате нуля. Как уже отмечали другие, это зависит от того, какой исполняемый файл вы создаете (то есть, кто вызывает main). Вы кодируете приложение, которое использует C-runtime? Плагин майя? Служба Windows? Водитель? Каждый случай потребует исследования, чтобы увидеть, если exitэквивалентно return. Использование IMHO, exitкогда вы действительно имеете в виду, return просто делает код более запутанным. OTOH, если вы действительно имеете в виду exit , то во что бы то ни стало используйте его.

Существует по крайней мере одна причина для предпочтения exit: если какой-либо из ваших atexitобработчиков ссылается на данные продолжительности автоматического хранения mainили если вы использовали setvbufили setbufдля назначения одному из стандартных потоков буфер буферизации автоматического хранения main, то возвращение из mainпроизводит неопределенное поведение, но вызов exitдействителен.

Другое потенциальное использование (обычно зарезервированное для игрушечных программ) - выход из программы с рекурсивными вызовами main.

Я всегда использую, returnпотому что стандартный прототип для main()говорит, что он возвращает int.

Тем не менее, некоторые версии стандартов предоставляют mainособый режим и предполагают, что он возвращает 0, если нет явного returnутверждения. Учитывая следующий код:

int foo() {}
int main(int argc, char *argv[]) {}

G ++ только генерирует предупреждение foo()и игнорирует пропущенный возврат из main:

% g++ -Wall -c foo.cc
foo.cc: In function ‘int foo()’:
foo.cc:1: warning: control reaches end of non-void function

Я НАСТОЯТЕЛЬНО поддерживаю комментарий Р. об использовании exit (), чтобы избежать автоматического сохранения в памяти main()до того, как программа действительно завершится. return X;Заявление в main()не точно эквивалентно вызову exit(X);, так как динамическое хранение main()исчезает , когда main()возвращается, но он не обращается в нуль , если вызов exit()сделан вместо этого.

Кроме того, в C или любом C-подобном языке returnоператор настоятельно намекает читателю, что выполнение будет продолжаться в вызывающей функции, и хотя это продолжение выполнения обычно технически верно, если вы считаете подпрограмму запуска C, которая вызвала вашу main()функцию, это не так. именно то, что вы имеете в виду, когда вы хотите закончить процесс.

В конце концов, если вы хотите завершить свою программу из любой другой функции, кроме как main()вы должны вызвать exit(). Кроме того, последовательное выполнение этого main()делает ваш код намного более читабельным, а также значительно упрощает повторный анализ вашего кода; т. е. код, скопированный из main()какой-либо другой функции, не будет работать неправильно из-за случайных returnоператоров, которые должны были быть exit()вызовами.

Таким образом, объединяя все эти пункты вместе, можно сделать вывод, что это плохая привычка , по крайней мере для C, использовать returnоператор для завершения программы main().

Выполняет ли exit () что-то особенное, чего не делает return?

Некоторые компиляторы для необычных платформ exit()могут преобразовать свой аргумент в значение выхода вашей программы, в то время как возвращение из main()может просто передать значение непосредственно в среду хоста без какого-либо перевода.

Стандарт требует идентичного поведения в этих случаях (в частности, он говорит, что возвращение чего-либо, из- intсовместимого main()должно быть эквивалентно вызову exit()с этим значением). Проблема в том, что разные ОС имеют разные соглашения для интерпретации выходных значений. Во многих (МНОГО!) Системах 0 означает успех, а все остальное - неудача. Но, скажем, в VMS нечетные значения означают успех, а четные - неудачу. Если вы вернули 0 из main(), пользователь VMS увидит неприятное сообщение о нарушении доступа. На самом деле не было нарушения прав доступа - это было просто стандартное сообщение, связанное с кодом ошибки 0.

Затем появился ANSI и благословил, EXIT_SUCCESSи в EXIT_FAILUREкачестве аргументов вы могли бы передать exit(). Стандарт также говорит, что exit(0)должен вести себя идентично exit(EXIT_SUCCESS), так что большинство реализаций определяют EXIT_SUCCESSего 0.

Поэтому стандарт ставит вас в тупик в VMS, поскольку не оставляет стандартного способа вернуть код ошибки, который имеет значение 0.

Поэтому компилятор VAX / VMS C начала 1990-х годов не интерпретировал возвращаемое значение main(), а просто возвращал любое значение в среду хоста. Но если бы вы использовали exit()его, он сделал бы то, что требовал стандарт: преобразовал EXIT_SUCCESS(или 0) в код успеха и EXIT_FAILUREв общий код ошибки. Чтобы использовать EXIT_SUCCESS, вы должны были передать его exit(), вы не могли вернуть его main(). Я не знаю, сохранили ли такое поведение более современные версии этого компилятора.

Портативная программа на Си раньше выглядела так:

#include <stdio.h>
#include <stdlib.h>

int main() {
  printf("Hello, World!\n");
  exit(EXIT_SUCCESS);  /* to get good return value to OS */
  /*NOTREACHED*/ /* to silence lint warning */
  return 0;  /* to silence compiler warning */
}

В стороне: Если я правильно помню, соглашение VMS для значений выхода более нюанс, чем нечетное / четное. На самом деле он использует что-то вроде младших трех битов для кодирования уровня серьезности. В целом, однако, уровни нечетной серьезности указывают на успех или различную информацию, а четные указывают на ошибки.

В С возврат из mainточно такой же, как вызов exitс тем же значением.

Раздел 5.1.2.2.3 стандарта C гласит:

Если возвращаемый тип главной функции является типом, совместимым с int, возврат из начального вызова основной функции эквивалентен вызову функции выхода со значением, возвращаемым главной функцией в качестве аргумента ; 11) при достижении}, завершающего функцию main, возвращается значение 0. Если возвращаемый тип не совместим с int, состояние завершения, возвращаемое в хост-среду, не указывается.

Правила для C ++ немного отличаются, как упомянуто в других ответах.

На самом деле есть разница между exit(0)и return(0)в main- когда ваша mainфункция вызывается несколько раз.

Следующая программа

#include <stdio.h>
#include <stdlib.h>

int main(int argc, char** argv) {
  if (argc == 0)
    return(0);
  printf("%d", main(argc - 1, argv));
}

Беги как

./program 0 0 0 0

Результатом будет следующий вывод:

00000

Однако этот:

#include <stdio.h>
#include <stdlib.h>

int main(int argc, char** argv) {
  if (argc == 0)
    exit(0);
  printf("%d", main(argc - 1, argv));
}

Не буду ничего печатать независимо от аргументов.

Если вы уверены, что никто никогда не позвонит вам mainявно, технически это не будет большой разницей в целом, но поддержание более ясного кода exitбудет выглядеть намного лучше. Если вы по какой-то причине хотите позвонить main- вам следует настроить его под свои нужды.

Говоря о С.