Что должно возвращать main () в C и C ++?

Как правильно (наиболее эффективно) определить main()функцию в C и C ++ - int main()или void main()- и почему? Если int main()тогда return 1или return 0?

Существует множество дубликатов этого вопроса, в том числе:

• Каковы действительные подписи для main()функции C ?
• Возвращаемый тип main()функции
• Разница между void main()а int main()?
• main()подпись в C ++
• Что такое правильная декларация main()? - Для C ++, с очень хорошим ответом.
• Стили main()функций в Си
• Тип возврата main()метода в C
• int main()против void main()C

Связанные с:

• C ++ - int main(int argc, char **argv)
• C ++ - int main(int argc, char *argv[])
• Является ли char *envp[]третьим аргументом в пользу main()портативного?
• Должна ли int main()функция возвращать значение во всех компиляторах?
• Почему тип main()функции в C и C ++ оставлен на усмотрение пользователя?
• Почему int main(){}компилируется?
• Юридические определения main()в C ++ 14?

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

int main()

а также

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

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

int main(int argc, char** argv)

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

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

Принятый ответ, по-видимому, предназначен для C ++, поэтому я подумал, что добавлю ответ, относящийся к C, и он отличается в нескольких отношениях.

ИСО / МЭК 9899: 1989 (С90):

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

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

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

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

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

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

ISO / IEC 9899: 1999 (C99):

Для C99 все то же самое, что и выше, за исключением:

• Тип intвозврата не может быть опущен.
• Вы можете опустить оператор возврата из main(). Если вы делаете, и main()закончил, есть неявное return 0.

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

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

5.1.2.2.1 Запуск программы

Функция, вызываемая при запуске программы, называется main. Реализация не объявляет прототип для этой функции. Это должно быть определено с типом возвратаint и без параметров:

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

или с двумя параметрами (упоминается здесь как argcиargv , хотя могут использоваться любые имена, так как они являются локальными для функции, в которой они объявлены):

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

или эквивалент;¹⁰⁾ или каким-либо другим способом, определяемым реализацией.

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

• Значение argc должно быть неотрицательным.
• argv[argc] должен быть нулевым указателем.
• Если значение argcбольше нуля, массив argv[0]проходит через argv[argc-1] inclusive должны содержать указатели на строки, которым перед запуском программы передаются значения, определяемые реализацией средой хоста. Намерение состоит в том, чтобы предоставить программе информацию, определенную до ее запуска, из другого места в размещенной среде. Если среда хоста не способна снабжать строки буквами как в верхнем, так и в нижнем регистре, реализация должна обеспечивать получение строк в нижнем регистре.
• Если значение argcбольше нуля, указанная строка argv[0] представляет имя программы; argv[0][0]должен быть нулевым символом, если имя программы недоступно из среды хоста. Если значение argcбольше единицы, строки, на которые указывает argv[1]сквозная строка, argv[argc-1] представляют параметры программы.
• Параметры argcи argvстроки, на которые указывает argvмассив, должны изменяться программой и сохранять свои последние сохраненные значения между запуском программы и ее завершением.

¹⁰⁾ Таким образом, intможет быть заменено именем typedef, определенным как int, или тип argvможет быть записан как char **argv, и так далее.

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

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

5.1.2.2.3 Завершение программы

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

¹¹⁾ В соответствии с 6.2.4, срок службы объектов с автоматической продолжительностью хранения, объявленной в, main будет закончен в первом случае, даже если в последнем случае их не будет.

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

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

7.22.4.4 exitФункция

Finally5 Наконец, управление возвращается в среду хоста. Если значение statusравно нулю или EXIT_SUCCESS, возвращается определяемая реализацией форма успешного завершения статуса . Если значение statusравно EXIT_FAILURE, возвращается форма реализации неудачного завершения статуса . В противном случае возвращаемый статус определяется реализацией.

Стандарт C ++ - Хостинг-среда

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

3.6.1 Основная функция [basic.start.main]

Program1 Программа должна содержать глобальную функцию, называемую main, которая является назначенным началом программы. [...]

An2 Реализация не должна предопределять основную функцию. Эта функция не должна быть перегружена. Он должен иметь возвращаемый тип типа int, но в противном случае его тип определяется реализацией. Все реализации должны позволять оба следующих определения main:

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

а также

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

В последней форме argcуказывается количество аргументов, переданных программе из среды, в которой она запущена. Если значение argcравно нулю, эти аргументы должны быть переданы argv[0] через argv[argc-1]как указатели на начальные символы многобайтовых строк с нулевым символом в конце (NTMBS) (17.5.2.1.4.2) и argv[0]должны быть указателем на начальный символ NTMBS, который представляет имя, используемое для вызвать программу или "". Значение argcдолжно быть неотрицательным. Значение argv[argc] должно быть 0. [Примечание: рекомендуется добавлять любые дополнительные (необязательные) параметры после argv. —Конечная записка]

¶3 Функция mainне должна использоваться в программе. Связь (3.5) mainопределяется реализацией. [...]

Statement5 Оператор return в main приводит к выходу из функции main (уничтожению любых объектов с автоматическим хранением) и вызову std::exitс возвращаемым значением в качестве аргумента. Если управление достигает конца main, не встречая оператора return, эффект заключается в выполнении

return 0;

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

Там в пункте §18.5 Начало и окончание в C ++ 11 стандарт , который идентичен пункту из §7.22.4.4 функции в стандарте C11 (процитированном выше), за исключением сноски (который просто документы, и определяются в )exitEXIT_SUCCESSEXIT_FAILURE<cstdlib>

Стандарт C - Общее расширение

Классически системы Unix поддерживают третий вариант:

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

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

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

J.5.1 Аргументы среды

In1 В размещенной среде главная функция получает третий аргумент, char *envp[]который указывает на массив указателей с нулевым символом в конце char, каждый из которых указывает на строку, которая предоставляет информацию о среде для этого выполнения программы (5.1. 2.2.1).

Microsoft C

Microsoft VS 2010 компилятор интересно. Веб-сайт говорит:

Синтаксис объявления для main

 int main();

или, необязательно,

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

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

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

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

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

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

Стандарт С - автономная среда

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

5.1.2 Среды исполнения

Определяются две среды исполнения: автономная и размещенная. В обоих случаях запуск программы происходит, когда назначенная функция C вызывается средой выполнения. Все объекты со статической продолжительностью хранения должны быть инициализированы (установлены их начальные значения) перед запуском программы. Способ и время такой инициализации в остальном не определены. Завершение программы возвращает управление среде выполнения.

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

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

Эффект завершения программы в автономной среде определяется реализацией.

Перекрестная ссылка на пункт 4 Соответствие относится к этому:

A5 В строго соответствующей программе должны использоваться только те функции языка и библиотеки, которые указаны в настоящем международном стандарте. ³⁾ Он не должен генерировать выходные данные, зависящие от какого-либо неопределенного, неопределенного или определенного реализацией поведения, и не должен превышать какого-либо минимального предела реализации.

¶6 Две формы соответствующей реализации размещаются и автономно . В соответствии организовано внедрение должно принимать любую строго соответствующую программу. В соответствии автономной реализация должна принимать любую строго соответствующую программу , в которой использование особенностей , указанных в пункте библиотеки (п 7) сводятся к содержанию стандартных заголовков <float.h>, <iso646.h>, <limits.h>, <stdalign.h>, <stdarg.h>, <stdbool.h>, <stddef.h>, <stdint.h>, и <stdnoreturn.h>. Соответствующая реализация может иметь расширения (включая дополнительные библиотечные функции), при условии, что они не изменяют поведение любой строго соответствующей программы. ⁴⁾

¶7 Соответствующая программа - это программа , приемлемая для соответствующей реализации. ⁵⁾

³⁾ Строго соответствующая программа может использовать условные функции (см. 6.10.8.3) при условии, что использование защищено соответствующей директивой предварительной обработки условного включения с использованием соответствующего макроса. Например:

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

⁴⁾ Это подразумевает, что соответствующая реализация не оставляет никаких идентификаторов, кроме тех, которые явно зарезервированы в настоящем международном стандарте.

⁵⁾ Строго соответствующие программы предназначены для максимальной переносимости среди соответствующих реализаций. Соответствующие программы могут зависеть от непереносимых функций соответствующей реализации.

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

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

Так же, как стандарт C признает как размещенную, так и автономную среду, то же самое относится и к стандарту C ++. (Цитаты из ИСО / МЭК 14882: 2011.)

1.4 Соответствие реализации [intro.compliance]

¶7 Определены два вида реализаций: размещенная реализация и автономная реализация . Для размещенной реализации этот международный стандарт определяет набор доступных библиотек. Автономная реализация - это та, в которой выполнение может осуществляться без использования операционной системы, и имеет определенный набор реализаций библиотек, который включает в себя определенные библиотеки поддержки языка (17.6.1.3).

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

Each9 Каждая реализация должна включать документацию, которая идентифицирует все условно поддерживаемые конструкции, которые она не поддерживает, и определяет все специфичные для локали характеристики. ³

³⁾ Эта документация также определяет поведение, определяемое реализацией; см. 1.9.

17.6.1.3 Отдельно стоящие реализации [соответствие]

Определены два вида реализаций: размещенный и автономный (1.4). Для размещенной реализации этот международный стандарт описывает набор доступных заголовков.

Автономная реализация имеет определенный набор реализаций заголовков. Этот набор должен включать как минимум заголовки, показанные в таблице 16.

Прилагаемая версия заголовка <cstdlib>объявляет , по меньшей мере функции abort, atexit, at_quick_exit, exit, и quick_exit(18,5). Другие заголовки, перечисленные в этой таблице, должны соответствовать тем же требованиям, что и для размещенной реализации.

Таблица 16 - Заголовки C ++ для автономных реализаций

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 sizeofи _Alignofоператоры

...

Пример 8 В этом примере размер массива переменной длины вычисляется и возвращается из функции:

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

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

Обратите внимание, что стандарты 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 удалил "implicit int", поэтому main()больше не действителен.

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

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

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

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

• C99 автономная среда

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

• С11 размещенная среда

  Разрешенные формы ⁷ :

  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 Объявление функций

Использование деклараторов функций с пустыми скобками (не деклараторы типа параметров в формате prototype) является устаревшей функцией.

• 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 Размещенная среда. «Запуск программы»

   Функция, вызываемая при запуске программы, называется основной. Реализация не объявляет прототип для этой функции. Он должен быть определен с типом возврата int и без параметров:

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

   или с двумя параметрами (именуемыми здесь как argc и argv, хотя могут использоваться любые имена, поскольку они являются локальными для функции, в которой они объявлены):

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

2. ANSI X3.159-1989 2.1.2.1 Отдельно стоящая среда:

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

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

   Функция, вызываемая при запуске программы, называется основной. Реализация не объявляет прототип для этой функции. Он должен быть определен с типом возврата int и без параметров:

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

   или с двумя параметрами (именуемыми здесь как argc и argv, хотя могут использоваться любые имена, поскольку они являются локальными для функции, в которой они объявлены):

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

   или эквивалентный; 9) или каким-либо другим способом, определяемым реализацией.

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

   Поведение аргументов main и взаимодействия exit, main и atexit (см. §7.20.4.2) было кодифицировано, чтобы ограничить некоторое нежелательное разнообразие в представлении строк argv и в значении значений, возвращаемых main.

   Спецификация argc и argv в качестве аргументов для main признает обширную предшествующую практику. argv [argc] должен быть нулевым указателем, чтобы обеспечить избыточную проверку конца списка, также на основе обычной практики.

   main - единственная функция, которая может быть объявлена ​​переносимым образом с нулем или двумя аргументами. (Число аргументов других функций должно точно совпадать между вызовом и определением.) Этот особый случай просто признает широко распространенную практику исключения аргументов из main, когда программа не имеет доступа к строкам аргументов программы. Хотя многие реализации поддерживают более двух аргументов для main, такая практика не благословлена ​​и не запрещена Стандартом; программа, которая определяет main с тремя аргументами, не является строго соответствующей (см. §J.5.1.).

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

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

6. ISO 9899: 1999 5.1.2.1 Отдельно стоящая среда

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

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 Основная функция

   Реализация не должна предопределять основную функцию. Эта функция не должна быть перегружена. Он должен иметь возвращаемый тип типа int, но в остальном его тип определяется реализацией. Все реализации должны позволять оба следующих определения main:

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

   а также

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

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

    Определяется реализацией, требуется ли программе в автономной среде для определения главной функции.

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

    Реализация не должна предопределять основную функцию. Эта функция не должна быть перегружена. Он должен иметь возвращаемый тип типа int, но в остальном его тип определяется реализацией. Все реализации должны позволять

    - функция (), возвращающая int и

    - функция (int, указатель на указатель на символ), возвращающая int

    как тип основного (8.3.5).

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

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

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

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

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

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

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

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

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

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

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

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

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

Опустить return 0

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

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

[...] возврат из начального вызова mainфункции эквивалентен вызову exitфункции со значением, возвращаемым mainфункцией в качестве аргумента; при достижении }завершающей mainфункции функция возвращает значение 0.

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

Если управление достигает конца main, не встречая оператора return, результатом является выполнение return 0;

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

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

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

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

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

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

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

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

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

Это пример того, как проверить, как работает grep.

Когда вы выполняете команду 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 ()).

Как правильно (наиболее эффективно) определить функцию main () в C и C ++ - int main () или void main () - и почему?

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

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

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

Если int main (), тогда вернуть 1 или вернуть 0?

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