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

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

ISO / IEC 9899: 1989 (C90):

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

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

для размещенной среды (это обычная среда) стандарт 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 is струны, на которые указывает 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 функция эквивалентна вызову в качестве аргумент;¹¹⁾ достижения } это завершает 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 функции

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

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

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

3.6.1 основная функция [basic.начать.main]

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

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

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

и

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

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

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

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

return 0;

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

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

Стандартное Расширение C-Common

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

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

третий аргумент-это список указателей на строки с нулевым завершением, каждая из которых является переменной среды, которая имеет имя, знак равенства и значение (возможно, пустое). Если вы не используете это, вы все равно можете получить в окружающей среде через'extern char **environ;'. Долгое время у этого не было заголовка, который его объявлял, но в POSIX 2008 стандарт теперь требует, чтобы он был объявлен в <unistd.h>.

это признано стандартом C в качестве общего расширения, документально подтвержденного в приложении J:

J. 5.1 окружающая среда доводы

¶1 в размещенной среде, основная функция принимает третий аргумент, 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, вы должны использовать

Я считаю, что 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 автономная среда

  допускается любая форма или название main ².

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

  разрешенные формы ³:

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

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

  C99 удален "неявный int" so main() больше не действует.

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

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

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

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

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

  допускается любая форма или название main ⁶.

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

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

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

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

  допускается любая форма или название main ⁸.

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

функции 6.11.6 деклараторы

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

• 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 размещенная среда. "Программа startup"

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

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

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

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

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

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

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 строки, и в значении значений, возвращаемых главный.

   спецификация 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) достижение } при завершении основной функции возвращается значение 0. Если возвращаемый тип не совместим с int, состояние завершения, возвращаемое в среду узла неопределенный.

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

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

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

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

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

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

    в качестве типа main (8.3.5).

12. ISO 14882: 2011 3.6.1 Main функция

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

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

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

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

return 1? return 0?

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

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

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

$ ./a.out
$ echo $?

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

что нужно main() return в C и C++?

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

если int main () затем возвращает 1 или возвращает 0?

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

в C++ основная функция должна быть объявлена как int main (), а не void main (), поскольку компилятор затем выдает ошибку в случае void main. Основная функция может принимать любое количество аргументов, таких как int main(int k,int l,int arr[]) или int main(void).

#include <iostream>
using namespace std;

int main(void) {
    // your code goes here
    cout<<"a";
    return 0;
}

выход:

Success #stdin #stdout 0s 4416KB
a

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

пример

#include <iostream>
using namespace std;

int main(int k,float m,char g, int arr[]) {
    // your code goes here
    k=0;
    cout<<k;
    g='a';
    cout<<g;
    cout<<"a";
    return 1;
}

выход:

Runtime error   #stdin #stdout 0s 4448KB
0aa

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

при использовании различных инструментов, предоставляемых терминалом 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 return 1, и мы проверяем, был ли код возврата grep равен 0. Второе условное утверждение повторяет свое сообщение в последняя строка, так как она истинна из-за CHECK == 1.

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

пропустить return 0

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

Примечание:

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