Что должен вернуть main () в C и C++?

Возвращаемое значение main указывает, как программа завершилась. Нормальный выход представлен возвращаемым значением 0 от main. Аномальный выход сигнализируется ненулевым возвратом, но нет стандарта для интерпретации ненулевых кодов. Как отмечали другие, void main() запрещен стандартом C++ и не должен использоваться. Допустимые подписи C++ main:

int main()

и

int main(int argc, char* argv[])

что эквивалентно

int main(int argc, char** argv)

Также стоит отметить, что в C++ int main() можно оставить без оператора return, после чего по умолчанию возвращается 0. Это также верно и для программы C99. Вопрос о том, следует ли исключать return 0;, остается открытым. Диапазон допустимых основных сигнатур программы C намного шире.

Эффективность не является проблемой для функции main. Его можно ввести и оставить только один раз (отмечая начало и завершение программы) в соответствии со стандартом C++. Для C повторный ввод main() разрешен, но этого следует избегать.

Возвращает 0 в случае успеха и ненулевое значение в случае ошибки. Это стандарт, используемый сценариями UNIX и DOS для выяснения того, что произошло с вашей программой.

Я считаю, что main() должен возвращать либо EXIT_SUCCESS, либо EXIT_FAILURE. Они определены в stdlib.h.

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

Однако обычно я возвращаю 0.

Имейте в виду, что даже если вы возвращаете int, некоторые операционные системы (Windows) усекают возвращаемое значение до одного байта (0–255).

Принятый ответ, похоже, предназначен для C++, поэтому я подумал, что добавлю ответ, относящийся к C, и это несколько отличается. Также были внесены некоторые изменения между ISO / IEC 9899: 1989 (C90) и ISO / IEC 9899: 1999 (C99).

main() должен быть объявлен как:

int main(void)
int main(int argc, char **argv)

Или эквивалент. Например, int main(int argc, char *argv[]) эквивалентен второму. В C90 тип возврата int может быть опущен, поскольку он является значением по умолчанию, но в C99 и новее тип возврата int не может быть пропущен.

Если реализация позволяет это, main() может быть объявлен другими способами (например, int main(int argc, char *argv[], char *envp[])), но это делает реализацию программы определенной и больше не соответствует строго.

Стандарт определяет 3 значения для возврата, которые строго соответствуют (то есть не зависят от поведения, определенного реализацией): 0 и EXIT_SUCCESS для успешного завершения и EXIT_FAILURE для неудачного завершения. Любые другие значения являются нестандартными и определяются реализацией. В C90 main() должен иметь явный оператор return в конце, чтобы избежать неопределенного поведения. В C99 и новее вы можете опустить оператор возврата из main(). Если вы это сделаете, и main() закончил, есть неявный return 0.

Наконец, с точки зрения стандартов, нет ничего плохого в вызове main()рекурсивно из программы на языке C.

Если у вас действительно есть проблемы, связанные с эффективностью возврата целого числа из процесса, вам, вероятно, следует избегать вызова этого процесса столько раз, что это возвращаемое значение станет проблемой.

Если вы делаете это (вызываете процесс столько раз), вы должны найти способ поместить свою логику непосредственно внутри вызывающего объекта или в файл DLL, не выделяя конкретный процесс для каждого вызова; распределение нескольких процессов создает в этом случае соответствующую проблему эффективности.

В деталях, если вы хотите знать, является ли возврат 0 более или менее эффективным, чем возврат 1, в некоторых случаях это может зависеть от компилятора, но в целом, если они считываются из одного и того же источника (локального, полевого, константы, встроенного в коде, результате функции и т. д.) требуется точно такое же количество тактов.

Что нужно вернуть, зависит от того, что вы хотите делать с исполняемым файлом. Например, если вы используете свою программу с оболочкой командной строки, вам нужно вернуть 0 в случае успеха и ненулевое значение в случае неудачи. Тогда вы сможете использовать программу в оболочках с условной обработкой в ​​зависимости от результата вашего кода. Также вы можете присвоить любое ненулевое значение в соответствии с вашей интерпретацией, например, для критических ошибок разные точки выхода программы могут завершить программу с разными значениями выхода, и это доступно для вызывающей оболочки, которая может решить, что делать, проверив возвращенное значение. Если код не предназначен для использования с оболочками и возвращаемое значение никого не беспокоит, его можно пропустить. Лично пользуюсь подписью int main (void) { .. return 0; .. }

Возвращаемое значение может использоваться операционной системой для проверки того, как была закрыта программа.

Возвращаемое значение 0 обычно означает ОК в большинстве операционных систем (тех, о которых я все равно могу думать).

Это также можно проверить, когда вы сами вызываете процесс, и посмотрите, завершилась ли программа и завершилась ли она должным образом.

Это НЕТ просто соглашение о программировании.

Возвращаемое значение main() показывает, как программа завершилась. Если возвращаемое значение - zero, это означает, что выполнение было успешным, в то время как любое ненулевое значение будет означать, что что-то пошло не так при выполнении.

main() в C89 и неопределенные типы возвращаемых значений K&R C по умолчанию имеют значение 'int`.

return 1? return 0?

1. Если вы не напишите оператор возврата в int main(), закрывающий { по умолчанию вернет 0.

2. return 0 или return 1 будет получен родительским процессом. В оболочке он переходит в переменную оболочки, и если вы запускаете свою программу из оболочки и не используете эту переменную, вам не нужно беспокоиться о возвращаемом значении main().

См. Как я могу получить то, что вернула моя основная функция?.

$ ./a.out
$ echo $?

Таким образом, вы можете увидеть, что именно переменная $? получает младший байт возвращаемого значения main().

В сценариях Unix и DOS обычно возвращается return 0 в случае успеха и ненулевое значение в случае ошибки. Это стандарт, используемый сценариями Unix и DOS, чтобы узнать, что произошло с вашей программой, и контролировать весь поток.

Возвращение 0 должно сообщить программисту, что программа успешно завершила работу.

Стандарт C - Размещенная среда

Для размещенной среды (это нормальная) стандарт C11 (ISO / IEC 9899: 2011) гласит:

5.1.2.2.1 Program startup

The function called at program startup is named main. The implementation declares no prototype for this function. It shall be defined with a return type of int and with no parameters:

int main(void) { /* ... */ }

or with two parameters (referred to here as argc and argv, though any names may be used, as they are local to the function in which they are declared):

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

or equivalent;¹⁰⁾ or in some other implementation-defined manner.

If they are declared, the parameters to the main function shall obey the following constraints:

• The value of argc shall be nonnegative.
• argv[argc] shall be a null pointer.
• If the value of argc is greater than zero, the array members argv[0] through argv[argc-1] inclusive shall contain pointers to strings, which are given implementation-defined values by the host environment prior to program startup. The intent is to supply to the program information determined prior to program startup from elsewhere in the hosted environment. If the host environment is not capable of supplying strings with letters in both uppercase and lowercase, the implementation shall ensure that the strings are received in lowercase.
• If the value of argc is greater than zero, the string pointed to by argv[0] represents the program name; argv[0][0] shall be the null character if the program name is not available from the host environment. If the value of argc is greater than one, the strings pointed to by argv[1] through argv[argc-1] represent the program parameters.
• The parameters argc and argv and the strings pointed to by the argv array shall be modifiable by the program, and retain their last-stored values between program startup and program termination.

¹⁰⁾ Thus, int can be replaced by a typedef name defined as int, or the type of argv can be written as char **argv, and so on.

Завершение программы в C99 или C11

Значение, возвращаемое main(), передается в «среду» способом, определяемым реализацией.

5.1.2.2.3 Program termination

1 If the return type of the main function is a type compatible with int, a return from the initial call to the main function is equivalent to calling the exit function with the value returned by the main function as its argument;¹¹⁾ reaching the } that terminates the main function returns a value of 0. If the return type is not compatible with int, the termination status returned to the host environment is unspecified.

¹¹⁾ In accordance with 6.2.4, the lifetimes of objects with automatic storage duration declared in main will have ended in the former case, even where they would not have in the latter.

Обратите внимание, что 0 считается «успешным». Вы можете использовать EXIT_FAILURE и EXIT_SUCCESS из <stdlib.h>, если хотите, но 0 хорошо установлен, так же как и 1. См. Также Коды выхода больше 255 - возможно?.

В C89 (и, следовательно, в Microsoft C) нет утверждения о том, что произойдет, если функция main() вернется, но не задает возвращаемое значение; поэтому это приводит к неопределенному поведению.

7.22.4.4 The exit function

¶5 Finally, control is returned to the host environment. If the value of status is zero or EXIT_SUCCESS, an implementation-defined form of the status successful termination is returned. If the value of status is EXIT_FAILURE, an implementation-defined form of the status unsuccessful termination is returned. Otherwise the status returned is implementation-defined.

Стандартный C++ - размещенная среда

Стандарт C++ 11 (ISO / IEC 14882: 2011) гласит:

3.6.1 Main function [basic.start.main]

¶1 A program shall contain a global function called main, which is the designated start of the program. [...]

¶2 An implementation shall not predefine the main function. This function shall not be overloaded. It shall have a return type of type int, but otherwise its type is implementation defined. All implementations shall allow both of the following definitions of main:

int main() { /* ... */ }

and

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

In the latter form argc shall be the number of arguments passed to the program from the environment in which the program is run. If argc is nonzero these arguments shall be supplied in argv[0] through argv[argc-1] as pointers to the initial characters of null-terminated multibyte strings (NTMBSs) (17.5.2.1.4.2) and argv[0] shall be the pointer to the initial character of a NTMBS that represents the name used to invoke the program or "". The value of argc shall be non-negative. The value of argv[argc] shall be 0. [ Note: It is recommended that any further (optional) parameters be added after argv. —end note ]

¶3 The function main shall not be used within a program. The linkage (3.5) of main is implementation-defined. [...]

¶5 A return statement in main has the effect of leaving the main function (destroying any objects with automatic storage duration) and calling std::exit with the return value as the argument. If control reaches the end of main without encountering a return statement, the effect is that of executing

return 0;

Стандарт C++ явно говорит: «Она [основная функция] должна иметь тип возвращаемого значения int, но в остальном ее тип определяется реализацией» и требует поддержки тех же двух сигнатур, что и стандарт C, в качестве параметров. Таким образом, void main () прямо не допускается стандартом C++, хотя он ничего не может сделать, чтобы остановить нестандартную реализацию, допускающую альтернативы. Обратите внимание, что C++ запрещает пользователю вызывать main (но стандарт C этого не делает).

В стандарте C++ 11 есть параграф §18.5 Начало и завершение, который идентичен параграфу из §7.22.4.4 Функция exit в стандарте C11 (цитируется выше), за исключением сноски (которая просто документирует, что EXIT_SUCCESS и EXIT_FAILURE определены в <cstdlib>).

Стандартный C - общее расширение

Традиционно системы Unix поддерживают третий вариант:

int main(int argc, char **argv, char **envp) { ... }

Третий аргумент - это список указателей на строки с завершающим нулем, каждая из которых является переменной среды, имеющей имя, знак равенства и значение (возможно, пустое). Если вы не используете это, вы все равно можете получить доступ к среде через «extern char **environ;». Эта глобальная переменная уникальна среди переменных POSIX тем, что у нее нет заголовка, который ее объявляет.

Это признано стандартом C как общее расширение, задокументированное в Приложении J:

J.5.1 Environment arguments

¶1 In a hosted environment, the main function receives a third argument, char *envp[], that points to a null-terminated array of pointers to char, each of which points to a string that provides information about the environment for this execution of the program (5.1.2.2.1).

Microsoft C

Компилятор Microsoft VS 2010 интересен. На сайте написано:

The declaration syntax for main is

 int main();

or, optionally,

int main(int argc, char *argv[], char *envp[]);

Alternatively, the main and wmain functions can be declared as returning void (no return value). If you declare main or wmain as returning void, you cannot return an exit code to the parent process or operating system by using a return statement. To return an exit code when main or wmain is declared as void, you must use the exit function.

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

Интересно, что MS не предписывает версию main() с двумя аргументами, которая требуется стандартами C и C++. Он предписывает только форму с тремя аргументами, где третьим аргументом является char **envp, указатель на список переменных среды.

На странице Microsoft также перечислены некоторые другие альтернативы - wmain(), который принимает широкие строки символов, и некоторые другие.

Версия эта страница Microsoft Visual Studio 2005 не содержит void main() в качестве альтернативы. версии от Microsoft Visual Studio 2008 и далее делает.

Стандарт C - Отдельностоящая среда

Как отмечалось ранее, приведенные выше требования применяются к размещенным средам. Если вы работаете с автономной средой (которая является альтернативой размещенной среде), то стандарт может сказать гораздо меньше. Для автономной среды функцию, вызываемую при запуске программы, не нужно называть main, и нет ограничений на ее возвращаемый тип. В стандарте сказано:

5.1.2 Execution environments

Two execution environments are defined: freestanding and hosted. In both cases, program startup occurs when a designated C function is called by the execution environment. All objects with static storage duration shall be initialized (set to their initial values) before program startup. The manner and timing of such initialization are otherwise unspecified. Program termination returns control to the execution environment.

5.1.2.1 Freestanding environment

In a freestanding environment (in which C program execution may take place without any benefit of an operating system), the name and type of the function called at program startup are implementation-defined. Any library facilities available to a freestanding program, other than the minimal set required by clause 4, are implementation-defined.

The effect of program termination in a freestanding environment is implementation-defined.

Перекрестная ссылка на раздел 4 Соответствие относится к следующему:

¶5 A strictly conforming program shall use only those features of the language and library specified in this International Standard.³⁾ It shall not produce output dependent on any unspecified, undefined, or implementation-defined behavior, and shall not exceed any minimum implementation limit.

¶6 The two forms of conforming implementation are hosted and freestanding. A conforming hosted implementation shall accept any strictly conforming program. A conforming freestanding implementation shall accept any strictly conforming program in which the use of the features specified in the library clause (clause 7) is confined to the contents of the standard headers <float.h>, <iso646.h>, <limits.h>, <stdalign.h>, <stdarg.h>, <stdbool.h>, <stddef.h>, <stdint.h>, and <stdnoreturn.h>. A conforming implementation may have extensions (including additional library functions), provided they do not alter the behavior of any strictly conforming program.⁴⁾

¶7 A conforming program is one that is acceptable to a conforming implementation.⁵⁾

³⁾ A strictly conforming program can use conditional features (see 6.10.8.3) provided the use is guarded by an appropriate conditional inclusion preprocessing directive using the related macro. For example:

#ifdef __STDC_IEC_559__ /* FE_UPWARD defined */
    /* ... */
    fesetround(FE_UPWARD);
    /* ... */
#endif

⁴⁾ This implies that a conforming implementation reserves no identifiers other than those explicitly reserved in this International Standard.

⁵⁾ Strictly conforming programs are intended to be maximally portable among conforming implementations. Conforming programs may depend upon non-portable features of a conforming implementation.

Примечательно, что единственный заголовок, необходимый для автономной среды, которая фактически определяет какие-либо функции, - это <stdarg.h> (и даже они могут быть - и часто являются - просто макросами).

Стандартный C++ - Автономная среда

Так же, как стандарт C распознает как размещенную, так и автономную среду, стандарт C++ тоже. (Цитаты из ISO / IEC 14882: 2011.)

1.4 Implementation compliance [intro.compliance]

¶7 Two kinds of implementations are defined: a hosted implementation and a freestanding implementation. For a hosted implementation, this International Standard defines the set of available libraries. A freestanding implementation is one in which execution may take place without the benefit of an operating system, and has an implementation-defined set of libraries that includes certain language-support libraries (17.6.1.3).

¶8 A conforming implementation may have extensions (including additional library functions), provided they do not alter the behavior of any well-formed program. Implementations are required to diagnose programs that use such extensions that are ill-formed according to this International Standard. Having done so, however, they can compile and execute such programs.

¶9 Each implementation shall include documentation that identifies all conditionally-supported constructs that it does not support and defines all locale-specific characteristics.³

³⁾ This documentation also defines implementation-defined behavior; see 1.9.

17.6.1.3 Freestanding implementations [compliance]

Two kinds of implementations are defined: hosted and freestanding (1.4). For a hosted implementation, this International Standard describes the set of available headers.

A freestanding implementation has an implementation-defined set of headers. This set shall include at least the headers shown in Table 16.

The supplied version of the header <cstdlib> shall declare at least the functions abort, atexit, at_quick_exit, exit, and quick_exit (18.5). The other headers listed in this table shall meet the same requirements as for a hosted implementation.

Table 16 — C++ headers for freestanding implementations

Subclause                           Header(s)
                                    <ciso646>
18.2  Types                         <cstddef>
18.3  Implementation properties     <cfloat> <limits> <climits>
18.4  Integer types                 <cstdint>
18.5  Start and termination         <cstdlib>
18.6  Dynamic memory management     <new>
18.7  Type identification           <typeinfo>
18.8  Exception handling            <exception>
18.9  Initializer lists             <initializer_list>
18.10 Other runtime support         <cstdalign> <cstdarg> <cstdbool>
20.9  Type traits                   <type_traits>
29    Atomics                       <atomic>

А как насчет использования int main() в C?

Стандарт §5.1.2.2.1 стандарта C11 показывает предпочтительную нотацию - int main(void) - но в стандарте также есть два примера, которые показывают int main(): §6.5.3.4 ¶8 и §6.7.6.3 ¶20. Теперь важно отметить, что примеры не являются «нормативными»; они только иллюстративные. Если в примерах есть ошибки, они не влияют напрямую на основной текст стандарта. Тем не менее, они явно указывают на ожидаемое поведение, поэтому, если стандарт включает в себя int main() в примере, это говорит о том, что int main() не запрещен, даже если это не предпочтительное обозначение.

6.5.3.4 The sizeof and _Alignof operators

…

¶8 EXAMPLE 3 In this example, the size of a variable length array is computed and returned from a function:

#include <stddef.h>

size_t fsize3(int n)
{
    char b[n+3]; // variable length array
    return sizeof b; // execution time sizeof
}
int main()
{
    size_t size;
    size = fsize3(10); // fsize3 returns 13
    return 0;
}

Вот небольшая демонстрация использования кодов возврата ...

При использовании различных инструментов, которые предоставляет терминал Linux, можно использовать код возврата, например, для обработки ошибок после завершения процесса. Представьте, что присутствует следующий текстовый файл myfile:

This is some example in order to check how grep works.

Когда вы выполняете команду grep, создается процесс. Как только он прошел (и не сломался), он возвращает некоторый код от 0 до 255. Например:

$ grep order myfile

Если вы это сделаете

$ echo $?
$ 0

вы получите 0. Почему? Поскольку grep нашел совпадение и вернул код выхода 0, что является обычным значением для успешного выхода. Давайте проверим это еще раз, но с чем-то, чего нет в нашем текстовом файле, и, следовательно, совпадение не будет найдено:

$ grep foo myfile
$ echo $?
$ 1

Так как grep не удалось сопоставить токен «foo» с содержимым нашего файла, код возврата равен 1 (это обычный случай, когда происходит сбой, но, как указано выше, у вас есть много значений на выбор).

Теперь следующий сценарий bash (просто введите его в терминале Linux), хотя и очень простой, должен дать некоторое представление об обработке ошибок:

$ grep foo myfile
$ CHECK=$?
$ [ $CHECK -eq 0] && echo 'Match found'
$ [ $CHECK -ne 0] && echo 'No match was found'
$ No match was found

После второй строки ничего не выводится на терминал, так как "foo" заставил grep вернуть 1, и мы проверяем, был ли код возврата grep равен 0. Второй условный оператор повторяет свое сообщение в последней строке, поскольку оно истинно из-за CHECK == 1.

Как видите, если вы вызываете тот или иной процесс, иногда важно увидеть, что он вернул (по возвращаемому значению main ()).

Обратите внимание, что стандарты C и C++ определяют два типа реализаций: автономные и размещенные.

• C90 размещенная среда

Допустимые формы ¹:

    int main (void)
    int main (int argc, char *argv[])

    main (void)
    main (int argc, char *argv[])
    /*... etc, similar forms with implicit int */

Комментарии:

Первые две явно указаны как разрешенные формы, остальные неявно разрешены, потому что C90 разрешает "неявное int" для типа возвращаемого значения и параметров функции. Никакая другая форма не допускается.

• Отдельностоящая среда C90

Разрешена любая форма или название основного ².

• C99 размещенная среда

Допустимые формы ³:

    int main (void)
    int main (int argc, char *argv[])
    /* or in some other implementation-defined manner. */

Комментарии:

C99 удалил "неявное int", поэтому main() больше не действителен.

Было введено странное двусмысленное предложение «или каким-либо другим способом, определяемым реализацией». Это можно интерпретировать как «параметры int main() могут отличаться» или как «main может иметь любую форму, определяемую реализацией».

Некоторые компиляторы предпочли интерпретировать стандарт именно так. Возможно, нельзя легко заявить, что они не соответствуют, цитируя стандарт сам по себе, поскольку он неоднозначен.

Однако, чтобы разрешить полностью дикие формы main(), вероятно (?) Не целью этого нового предложения. Обоснование C99 (не нормативное) подразумевает, что предложение относится к дополнительным параметрам int main⁴.

Тем не менее, в разделе о завершении программы в размещенной среде продолжаются споры о случае, когда main не возвращает int ⁵. Хотя этот раздел не является нормативным в отношении того, как следует объявлять main, он определенно подразумевает, что main может быть объявлен полностью определяемым реализацией способом даже в размещенных системах.

• Отдельностоящая среда C99

Разрешена любая форма или название основного ⁶.

• C11 размещенная среда

Допустимые формы ⁷:

    int main (void)
    int main (int argc, char *argv[])
    /* or in some other implementation-defined manner. */

• Отдельностоящая среда C11

Разрешена любая форма или название основного ⁸.

Обратите внимание, что int main() никогда не был указан как допустимая форма для любой размещенной реализации C ни в одной из вышеперечисленных версий. В C, в отличие от C++, () и (void) имеют разные значения. Первый - устаревшая функция, которую можно удалить из языка. См. Будущие языковые направления C11:

6.11.6 Function declarators

The use of function declarators with empty parentheses (not prototype-format parameter type declarators) is an obsolescent feature.

• Размещенная среда C++ 03

Допустимые формы ⁹:

    int main ()
    int main (int argc, char *argv[])

Комментарии:

Обратите внимание на пустую скобку в первой форме. В этом случае C++ и C отличаются, потому что в C++ это означает, что функция не принимает параметров. Но в C это означает, что он может принимать любой параметр.

• Автономная среда C++ 03

Имя функции, вызываемой при запуске, определяется реализацией. Если он называется main(), он должен соответствовать заявленным формам ¹⁰:

    // implementation-defined name, or 
    int main ()
    int main (int argc, char *argv[])

• Размещенная среда C++ 11

Допустимые формы ¹¹:

    int main ()
    int main (int argc, char *argv[])

Комментарии:

Текст стандарта был изменен, но он имеет то же значение.

• Автономная среда C++ 11

Имя функции, вызываемой при запуске, определяется реализацией. Если он называется main(), он должен соответствовать заявленным формам ¹²:

    // implementation-defined name, or 
    int main ()
    int main (int argc, char *argv[])

использованная литература

1. ANSI X3.159-1989 2.1.2.2 Размещенная среда. «Запуск программы»

The function called at program startup is named main. The implementation declares no prototype for this function. It shall be defined with a return type of int and with no parameters:

    int main(void) { /* ... */ } 

or with two parameters (referred to here as argc and argv, though any names may be used, as they are local to the function in which they are declared):

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

2. ANSI X3.159-1989 2.1.2.1 Автономная среда:

In a freestanding environment (in which C program execution may take place without any benefit of an operating system), the name and type of the function called at program startup are implementation-defined.

3. ISO 9899: 1999 5.1.2.2 Размещенная среда -> 5.1.2.2.1 Запуск программы

The function called at program startup is named main. The implementation declares no prototype for this function. It shall be defined with a return type of int and with no parameters:

    int main(void) { /* ... */ } 

or with two parameters (referred to here as argc and argv, though any names may be used, as they are local to the function in which they are declared):

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

or equivalent;9) or in some other implementation-defined manner.

4. Обоснование международного стандарта - Языки программирования - C, редакция 5.10. 5.1.2.2 Размещенная среда -> 5.1.2.2.1 Запуск программы

The behavior of the arguments to main, and of the interaction of exit, main and atexit (see §7.20.4.2) has been codified to curb some unwanted variety in the representation of argv strings, and in the meaning of values returned by main.

The specification of argc and argv as arguments to main recognizes extensive prior practice. argv[argc] is required to be a null pointer to provide a redundant check for the end of the list, also on the basis of common practice.

main is the only function that may portably be declared either with zero or two arguments. (The number of other functions’ arguments must match exactly between invocation and definition.) This special case simply recognizes the widespread practice of leaving off the arguments to main when the program does not access the program argument strings. While many implementations support more than two arguments to main, such practice is neither blessed nor forbidden by the Standard; a program that defines main with three arguments is not strictly conforming (see §J.5.1.).

5. ISO 9899: 1999 5.1.2.2 Размещенная среда -> 5.1.2.2.3 Завершение программы

If the return type of the main function is a type compatible with int, a return from the initial call to the main function is equivalent to calling the exit function with the value returned by the main function as its argument;11) reaching the } that terminates the main function returns a value of 0. If the return type is not compatible with int, the termination status returned to the host environment is unspecified.

6. ISO 9899: 1999 5.1.2.1 Автономная среда

In a freestanding environment (in which C program execution may take place without any benefit of an operating system), the name and type of the function called at program startup are implementation-defined.

7. ISO 9899: 2011 5.1.2.2 Размещенная среда -> 5.1.2.2.1 Запуск программы

Этот раздел идентичен упомянутому выше разделу C99.

8. ISO 9899: 1999 5.1.2.1 Автономная среда

Этот раздел идентичен упомянутому выше разделу C99.

9. ISO 14882: 2003 3.6.1 Основная функция

An implementation shall not predefine the main function. This function shall not be overloaded. It shall have a return type of type int, but otherwise its type is implementation-defined. All implementations shall allow both of the following definitions of main:

    int main() { /* ... */ }

and

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

10. ISO 14882: 2003 3.6.1 Основная функция

It is implementation-defined whether a program in a freestanding environment is required to define a main function.

11. ISO 14882: 2011 3.6.1 Основная функция

An implementation shall not predefine the main function. This function shall not be overloaded. It shall have a return type of type int, but otherwise its type is implementation-defined. All implementations shall allow both

— a function of () returning int and

— a function of (int, pointer to pointer to char) returning int

as the type of main (8.3.5).

12. ISO 14882: 2011 3.6.1 Основная функция

Этот раздел идентичен приведенному выше разделу C++ 03.

Опустить return 0

Когда программа C или C++ достигает конца main, компилятор автоматически генерирует код, возвращающий 0, поэтому нет необходимости явно помещать return 0; в конец main.

Примечание:, когда я делаю это предложение, за ним почти всегда следует один из двух видов комментариев: «Я этого не знал». или "Плохой совет!" Мое объяснение состоит в том, что безопасно и полезно полагаться на поведение компилятора, явно поддерживаемое стандартом. Для C, начиная с C99; см. ИСО / МЭК 9899: 1999 раздел 5.1.2.2.3:

[...] a return from the initial call to the main function is equivalent to calling the exit function with the value returned by the main function as its argument; reaching the } that terminates the main function returns a value of 0.

Для C++, начиная с первого стандарта в 1998 году; см. ИСО / МЭК 14882: 1998 раздел 3.6.1:

If control reaches the end of main without encountering a return statement, the effect is that of executing return 0;

С тех пор все версии обоих стандартов (C99 и C++ 98) сохранили ту же идею. Мы полагаемся на автоматически сгенерированные функции-члены в C++, и немногие люди пишут явные операторы return; в конце функции void. Причины отказа, похоже, сводятся к "это выглядит странно". Если вам, как и мне, интересно, в чем причина изменения стандарта C прочтите этот вопрос. Также обратите внимание, что в начале 1990-х это считалось «небрежной практикой», поскольку в то время это было неопределенное поведение (хотя и широко поддерживалось).

Кроме того, Основные принципы C++ содержит несколько экземпляров пропуска return 0; в конце main и никаких экземпляров, в которых записан явный возврат. Хотя в этом документе еще нет конкретного руководства по этой конкретной теме, это кажется, по крайней мере, молчаливым одобрением этой практики.

Так что я рекомендую опустить его; другие не согласны (часто категорически!). В любом случае, если вы встретите код, в котором он отсутствует, вы узнаете, что он явно поддерживается стандартом, и вы поймете, что это значит.

What is the correct (most efficient) way to define the main() function in C and C++ — int main() or void main() — and why?

Эти слова «(наиболее эффективный)» не меняют вопроса. Если вы не находитесь в автономной среде, есть один универсально правильный способ объявить main(), и это как вернуть int.

What should main() return in C and C++?

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

If int main() then return 1 or return 0?

0 для успеха, ненулевое значение для неудачи. Опять же, это не то, что вам нужно (или нужно) выбирать: это определяется интерфейсом, которому вы должны соответствовать.

В C Раздел 5.1.2.2.1 стандарта C11 (выделено мной):

It shall be defined with a return type of int and with no parameters:

int main(void) { /* ... */ }

or with two parameters (referred to here as argc and argv, though any names may be used, as they are local to the function in which they are declared):

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

Однако для некоторых новичков, таких как я, абстрактный пример позволил бы мне понять это:

Когда вы пишете метод в своей программе, например int read_file(char filename[LEN]);, тогда вы, как вызывающий этот метод, хотите знать, все ли прошло хорошо (потому что могут произойти сбои, например, файл не может быть найден). Проверяя возвращаемое значение метода, вы можете узнать, все ли прошло хорошо или нет, это механизм для метода, который сигнализирует вам об успешном выполнении (или нет), и позволяет вызывающему (например, в вашем основном методе) решать как справиться с неожиданной ошибкой.

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

Другими словами:

Рациональным является то, что среда хоста (то есть операционная система (ОС)) должна знать, правильно ли завершилась программа. Без int-совместимого типа в качестве возвращаемого типа (например, void) «статус, возвращаемый в среду хоста, не указан» (т.е. неопределенное поведение в большинстве ОС).