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

<p>как правильно (наиболее эффективно) определить функцию <code>main()</code> в c и c++ - <code>int main()</code> или <code>void main()</code> - и почему? если <code>int main()</code>, то <code>return 1</code> или <code>return 0</code>?</p><hr><p><em> существует множество дубликатов этого вопроса, в том числе: </em></p><ul> <li> <a href="https://stackoverflow.com/questions/2108192/what-are-the-valid-signatures-for-cs-main-function/">каковы действительные подписи для функции <code>main()</code> в c?</a> </li> <li> <a href="https://stackoverflow.com/questions/17715008/the-return-type-of-main-function/">тип возврата функции <code>main()</code></a> </li> <li> <a href="https://stackoverflow.com/questions/636829/difference-between-void-main-and-int-main">разница между <code>void main()</code> и <code>int main()</code>?</a> </li> <li> <a href="https://stackoverflow.com/questions/1621574/mains-signature-in-c">подпись <code>main()</code> в c++</a> </li> <li> <a href="https://stackoverflow.com/questions/4207134/what-is-the-proper-declaration-of-main">что такое правильное объявление <code>main()</code>?</a> - для c++, с очень хорошим ответом.</li> <li> <a href="https://stackoverflow.com/questions/8692120/styles-of-main-functions-in-c">стили функций <code>main()</code> в c</a> </li> <li> <a href="https://stackoverflow.com/questions/10915713/return-type-of-main-method-in-c">возвращаемый тип метода <code>main()</code> в c</a> </li> <li> <a href="https://stackoverflow.com/questions/9356510/int-main-vs-void-main-in-c"><code>int main()</code> vs <code>void main()</code> в c</a> </li> </ul><p>связанные с:</p><ul> <li> <a href="https://stackoverflow.com/questions/5191965/c-int-mainint-argc-char-argv">c++ - <code>int main(int argc, char **argv)</code></a> </li> <li> <a href="https://stackoverflow.com/questions/5217395/c-int-mainint-argc-char-argv">c++ - <code>int main(int argc, char *argv[])</code></a> </li> <li> <a href="https://stackoverflow.com/questions/10321435/is-char-envp-as-a-third-argument-to-main-portable">является ли <code>char *envp[]</code> третьим аргументом для <code>main()</code> portable?</a> </li> <li> <a href="https://stackoverflow.com/questions/18402853/must-the-int-main-function-return-a-value-in-all-compilers">должна ли функция <code>int main()</code> возвращать значение во всех компиляторах?</a> </li> <li> <a href="https://stackoverflow.com/questions/5296163/why-is-the-type-of-the-main-function-in-c-and-c-left-to-the-user-to-define">почему тип функции <code>main()</code> в c и c++ оставлен на усмотрение пользователя?</a> </li> <li> <a href="https://stackoverflow.com/questions/22239/why-does-int-main-compile">почему <code>int main(){}</code> компилируется?</a> </li> <li> <a href="https://stackoverflow.com/questions/26470912/legal-definitions-of-main-in-c14">юридические определения <code>main()</code> в c++ 14?</a> </li> </ul>

<p>возвращаемое значение для <code>main</code> должно указывать на выход программы. обычный выход, как правило, представлен возвращаемым значением 0 из <code>main</code>. ненормальный выход обычно сигнализируется ненулевым возвратом, но не существует стандарта для интерпретации ненулевых кодов. также, как отмечают другие, <code>void main()</code> явно запрещен стандартом c++ и не должен использоваться. допустимые подписи c++ <code>main</code>:</p><pre><code>int main() </code></pre><p>а также</p><pre><code>int main(int argc, char* argv[]) </code></pre><p>что эквивалентно</p><pre><code>int main(int argc, char** argv) </code></pre><p>также стоит отметить, что в c++ <code>int main()</code> можно оставить без оператора return, после чего по умолчанию возвращается 0. это также верно для программы c99. вопрос о том, должен ли <code>return 0;</code> быть пропущен или нет, открыт для обсуждения. диапазон действительных основных сигнатур программы на си намного больше.</p><p>кроме того, эффективность не является проблемой с функцией <code>main</code>. он может быть введен и оставлен только один раз (отмечен запуск и завершение программы) в соответствии со стандартом c++. для c дело обстоит иначе, и повторный ввод <code>main()</code> разрешен, но его следует избегать.</p>

<p>принятый ответ, по-видимому, предназначен для c++, поэтому я подумал, что добавлю ответ, относящийся к c, и он отличается в нескольких отношениях.</p><p>исо/мэк 9899: 1989 (с90):</p><p><code>main()</code> должен быть объявлен как:</p><pre><code>int main(void) int main(int argc, char **argv) </code></pre><p>или эквивалент. например, <code>int main(int argc, char *argv[])</code> эквивалентно второму. кроме того, возвращаемый тип <code>int</code> может быть опущен, так как он используется по умолчанию.</p><p>если реализация разрешает это, <code>main()</code> может быть объявлена другими способами, но это делает реализацию программы определенной, и больше не является строго соответствующей.</p><p>стандарт определяет 3 значения для возврата, которые строго соответствуют (то есть не зависят от поведения, определенного реализацией): <code>0</code> и <code>exit\_success</code> для успешного завершения и <code>exit\_failure</code> для неудачного завершения. любые другие значения являются нестандартными и определяются реализацией. <code>main()</code> должен иметь явное выражение <code>return</code> в конце, чтобы избежать неопределенного поведения.</p><p>наконец, нет ничего плохого с точки зрения стандартов в вызове <code>main()</code> из программы.</p><p>iso/iec 9899: 1999 (c99):</p><p>для c99 все то же самое, что и выше, за исключением:</p><ul> <li>возвращаемый тип <code>int</code> не может быть опущен.</li> <li>вы можете опустить оператор возврата из <code>main()</code>. если вы это сделаете, и <code>main()</code> завершится, то будет скрытый <code>return 0</code>.</li> </ul>

<h2>стандарт с - размещенная среда</h2><p>для размещенной среды (это нормальная среда) стандарт c11 (iso/iec 9899: 2011) гласит:</p><blockquote> <h3>5.1.2.2.1 запуск программы</h3> <p>функция, вызываемая при запуске программы, называется <code>main</code>. реализация не объявляет прототип для этой функции. он должен быть определен с типом возврата <code>int</code> и без параметров:</p> <pre><code>int main(void) { /* ... */ } </code></pre> <p>или с двумя параметрами (именуемыми здесь <code>argc</code> и <code>argv</code>, хотя могут использоваться любые имена, поскольку они являются локальными для функции, в которой они объявлены):</p> <pre><code>int main(int argc, char *argv[]) { /* ... */ } </code></pre> <p>или эквивалент;<sup>10)</sup> или каким-либо другим способом, определяемым реализацией.</p> <p>если они объявлены, параметры главной функции должны подчиняться следующим ограничениям:</p> <ul> <li>значение <code>argc</code> должно быть неотрицательным.</li> <li><code>argv[argc]</code> должен быть нулевым указателем.</li> <li>если значение <code>argc</code> больше нуля, члены массива от <code>argv[0]</code> до <code>argv[argc-1]</code> включительно должны содержать указатели на строки, которым перед установкой программы присваиваются значения, определяемые реализацией средой host. намерение состоит в том, чтобы предоставить программе информацию, определенную до ее запуска, из другого места в размещенной среде. если среда хоста не может предоставлять строки с буквами как в верхнем, так и в нижнем регистре, реализация должна обеспечивать получение строк в нижнем регистре.</li> <li>если значение <code>argc</code> больше нуля, строка, на которую указывает <code>argv[0]</code>, представляет имя программы; <code>argv[0][0]</code> должен быть нулевым символом, если имя программы недоступно из среды хоста. если значение <code>argc</code> больше единицы, строки, на которые указывают коды от <code>argv[1]</code> до <code>argv[argc-1]</code>, представляют параметры программы.</li> <li>параметры <code>argc</code> и <code>argv</code> и строки, на которые указывает массив <code>argv</code>, должны изменяться программой и сохранять свои последние сохраненные значения между запуском программы и ее завершением.</li> </ul> <p><sup>10)</sup> таким образом, <code>int</code> может быть заменено именем typedef, определенным как <code>int</code>, или тип <code>argv</code> может быть записан как <code>char **argv</code>, и так далее.</p> </blockquote><h3>завершение программы в c99 или c11</h3><p>значение, возвращаемое из <code>main()</code>, передается в "среду" способом, определяемым реализацией.</p><blockquote> <h3>5.1.2.2.3 завершение программы</h3> <p>1 если возвращаемый тип функции <code>main</code> является типом, совместимым с <code>int</code>, возврат из начального вызова функции <code>main</code> эквивалентен вызову функции <code>exit</code> со значением, возвращаемым функцией <code>main</code> в качестве аргумента;<sup>11)</sup> при достижении <code>}</code>, завершающего функцию <code>main</code>, возвращается значение 0. если возвращаемый тип несовместим с <code>int</code>, состояние завершения, возвращаемое в среду хоста, не указано.</p> <p><sup>11)</sup> в соответствии с 6.2.4 время жизни объектов с автоматической продолжительностью хранения, объявленной в <code>main</code>, закончится в первом случае, даже если в последнем случае их не будет.</p> </blockquote><p>обратите внимание, что <code>0</code> обозначен как "успех". вы можете использовать <code>exit\_failure</code> и <code>exit\_success</code> из <code><stdlib.h></code>, если хотите, но 0 точно установлено, как и 1. см. также <a href="https://stackoverflow.com/questions/179565/exitcodes-bigger-than-255-possible/">выходные коды больше 255 - возможно?</a> .</p><p>в c89 (и, следовательно, в microsoft c) нет заявления о том, что произойдет, если функция <code>main()</code> вернется, но не определит возвращаемое значение; следовательно, это ведет к неопределенному поведению.</p><blockquote> <h3>7.22.4.4 функция <code>exit</code></h3> <p>finally5 наконец, управление возвращается в среду хоста. если значение <code>status</code> равно нулю или <code>exit\_success</code>, возвращается определяемая реализацией форма успешного завершения статуса <em> </em>. если значение <code>status</code> равно <code>exit\_failure</code>, возвращается форма реализации неудачного завершения состояния <em> </em>. в противном случае возвращаемый статус определяется реализацией.</p> </blockquote><h2>стандарт c++ - хостинг-среда</h2><p>стандарт c++ 11 (iso/iec 14882: 2011) гласит:</p><blockquote> <h3>3.6.1 основная функция [basic.start.main]</h3> <p>program1 программа должна содержать глобальную функцию, называемую main, которая является назначенным началом программы. [...]</p> <p>an2 реализация не должна предопределять основную функцию. эта функция не должна быть перегружена. он должен иметь возвращаемый тип типа int, но в противном случае его тип определяется реализацией. все реализации должны позволять оба следующих определения main:</p> <pre><code>int main() { /* ... */ } </code></pre> <p>а также</p> <pre><code>int main(int argc, char* argv[]) { /* ... */ } </code></pre> <p>в последней форме <code>argc</code> должно быть количеством аргументов, переданных программе из среды, в которой она запущена. если <code>argc</code> отличен от нуля, эти аргументы должны быть указаны от <code>argv[0]</code> до <code>argv[argc-1]</code> как указатели на начальные символы многобайтовых строк с нулевым символом в конце (ntmbss) (17.5.2.1.4.2), а <code>argv[0]</code> должен быть указателем на начальный символ ntmbs, который представляет имя, используемое для вызова программы или <code>""</code>. значение <code>argc</code> должно быть неотрицательным. значение <code>argv[argc]</code> должно быть 0. [примечание. рекомендуется добавлять любые дополнительные (необязательные) параметры после <code>argv</code>. —конечная записка]</p> <p>¶3 функция <code>main</code> не должна использоваться в программе. связь (3.5) <code>main</code> определяется реализацией. [...]</p> <p>statement5 оператор возврата в main приводит к выходу из функции main (уничтожению любых объектов с автоматическим хранением) и вызову <code>std::exit</code> с возвращаемым значением в качестве аргумента. если управление достигает конца main, не встречая оператора return, эффект заключается в выполнении</p> <pre><code>return 0; </code></pre></blockquote><p>стандарт c++ прямо говорит: "он [основная функция] должен иметь тип возвращаемого значения типа <code>int</code>, но в противном случае его тип определяется реализацией", и для поддержки в качестве опций требуются те же две подписи, что и для стандарта c. так что void main () напрямую не разрешен стандартом c++, хотя он ничего не может сделать, чтобы остановить нестандартную реализацию, допускающую альтернативы. обратите внимание, что c++ запрещает пользователю вызывать <code>main</code> (но стандарт c этого не делает).</p><p>в стандарте c++ 11 есть параграф §18.5 <strong> начало и окончание </strong>, идентичный абзацу §7.22.4.4 <strong> функция <code>exit</code> </strong> в стандарте c11 (цитируется выше), кроме сноски (которая просто документирует, что <code>exit\_success</code> и <code>exit\_failure</code> определены в <code><cstdlib></code>).</p><h2>стандарт c - общее расширение</h2><p>классически unix-системы поддерживают третий вариант:</p><pre><code>int main(int argc, char **argv, char **envp) { ... } </code></pre><p>третий аргумент представляет собой список указателей на строки с нулевым символом в конце, каждый из которых является переменной окружения, которая имеет имя, знак равенства и значение (возможно, пустое). если вы не используете это, вы все равно можете попасть в среду через '<code>extern char **environ;</code>'. долгое время у этого не было заголовка, который объявил его, но стандарт <a href="http://en.wikipedia.org/wiki/posix">posix</a> 2008 теперь требует, чтобы он был объявлен в <code><unistd.h></code>.</p><p>это признано стандартом c как общее расширение, документированное в приложении j:</p><blockquote> <h3>j.5.1 аргументы среды</h3> <p>in1 в размещенной среде главная функция получает третий аргумент <code>char *envp[]</code>, который указывает на массив указателей с нулевым символом в конце на <code>char</code>, каждый из которых указывает на строку, которая предоставляет информацию о среде для выполнения этой программы ( 5.1.2.2.1).</p> </blockquote><h2>microsoft c</h2><p>компилятор <a href="http://msdn.microsoft.com/en-us/library/6wd819wh%28v=vs.100%29.aspx">microsoft vs 201</a> интересен. веб-сайт говорит:</p><blockquote> <p>синтаксис объявления для main</p> <pre><code> int main(); </code></pre> <p>или, необязательно,</p> <pre><code>int main(int argc, char *argv[], char *envp[]); </code></pre> <p>кроме того, функции <code>main</code> и <code>wmain</code> могут быть объявлены как возвращающие <code>void</code> (без возвращаемого значения). если вы объявляете <code>main</code> или <code>wmain</code> как возвращающие void, вы не можете вернуть код выхода в родительский процесс или операционную систему с помощью оператора return. чтобы вернуть код завершения, когда <code>main</code> или <code>wmain</code> объявлены как <code>void</code>, вы должны использовать функцию <code>exit</code>.</p> </blockquote><p>мне не ясно, что происходит (какой код завершения возвращается родительскому или ос), когда программа с <code>void main()</code> завершает работу - и веб-сайт ms тоже молчит.</p><p>интересно, что ms не предписывает версию с двумя аргументами <code>main()</code>, которая требуется в стандартах c и c++. он только предписывает форму с тремя аргументами, где третьим аргументом является <code>char **envp</code>, указатель на список переменных среды.</p><p>на странице microsoft также перечислены некоторые другие альтернативы - <code>wmain()</code>, которая принимает строки широких символов, и некоторые другие.</p><p>microsoft <a href="http://en.wikipedia.org/wiki/microsoft\_visual\_studio#visual\_studio\_2005">visual studio 2005</a> версия <a href="http://msdn.microsoft.com/en-us/library/6wd819wh%28v=vs.80%29.aspx">эта страница</a> не перечисляет <code>void main()</code> в качестве альтернативы. <a href="http://msdn.microsoft.com/en-us/library/6wd819wh%28v=vs.90%29.aspx">версии</a> от microsoft <a href="http://en.wikipedia.org/wiki/microsoft\_visual\_studio#visual\_studio\_2008">visual studio 2008</a> и далее.</p><h2>стандарт с - автономная среда</h2><p>как уже отмечалось ранее, приведенные выше требования применяются к размещенным средам. если вы работаете с автономной средой (которая является альтернативой размещенной среде), то о стандарте можно сказать гораздо меньше. для автономной среды функцию, вызываемую при запуске программы, не нужно называть <code>main</code>, и нет никаких ограничений на ее тип возвращаемого значения. стандарт гласит:</p><blockquote> <h3>5.1.2 среды исполнения</h3> <p>определены две среды исполнения: автономная и размещенная. в обоих случаях запуск программы происходит, когда назначенная функция c вызывается средой выполнения. все объекты со статической продолжительностью хранения должны быть инициализированы (установлены их начальные значения) перед запуском программы. способ и время такой инициализации в остальном не определены. завершение программы возвращает управление среде выполнения.</p> <h3>5.1.2.1 отдельно стоящая среда</h3> <p>в автономной среде (в которой выполнение программы на с может происходить без какой-либо выгоды от операционной системы), имя и тип функции, вызываемой при запуске программы, определяются реализацией. любые библиотечные средства, доступные для автономной программы, кроме минимального набора, требуемого в разделе 4, определяются реализацией.</p> <p>эффект завершения программы в автономной среде определяется реализацией.</p> </blockquote><p>перекрестная ссылка на пункт 4 соответствие относится к этому:</p><blockquote> <p>a5 a <em> строго соответствующая программа </em> должна использовать только те функции языка и библиотеки, которые указаны в настоящем международном стандарте.<sup>3)</sup> он не должен генерировать выходные данные, зависящие от какого-либо неопределенного, неопределенного или определенного реализацией поведения, и не должен превышать какого-либо минимального предела реализации.</p> <p>¶6 двумя формами соответствующей реализации являются <em> hosted </em> и <em> отдельно стоящие </em>. соответствующая <em> размещенная реализация </em> должна принимать любую строго соответствующую программу. соответствующая автономная реализация <em> </em> должна принимать любую строго соответствующую программу, в которой использование функций, указанных в разделе библиотеки (пункт 7), ограничено содержимым стандартных заголовков <code><float.h></code>, <code><iso646.h></code> , <code><limits.h></code>, <code><stdalign.h></code>, <code><stdarg.h></code>, <code><stdbool.h></code>, <code><stddef.h></code>, <code><stdint.h></code> и <code><stdnoreturn.h></code>. соответствующая реализация может иметь расширения (включая дополнительные библиотечные функции), при условии, что они не изменяют поведение любой строго соответствующей программы.<sup>4)</sup></p> <p>¶7 <em> соответствующая программа </em> - это программа, которая приемлема для соответствующей реализации.<sup>5)</sup></p> <p><sup>3)</sup> строго соответствующая программа может использовать условные функции (см. 6.10.8.3), при условии, что использование защищено соответствующей директивой предварительной обработки условного включения с использованием соответствующего макроса. например:</p> <pre><code>#ifdef \_\_stdc\_iec\_559\_\_ /* fe\_upward defined */ /* ... */ fesetround(fe\_upward); /* ... */ #endif </code></pre> <p><sup>4)</sup> это подразумевает, что соответствующая реализация не оставляет никаких идентификаторов, кроме тех, которые явно зарезервированы в этом международном стандарте.</p> <p><sup>5)</sup> строго соответствующие программы предназначены для максимальной переносимости среди соответствующих реализаций. соответствующие программы могут зависеть от непереносимых функций соответствующей реализации.</p> </blockquote><p>заметно, что единственный отдельный заголовок, необходимый для автономной среды, которая фактически определяет какие-либо функции, - это <code><stdarg.h></code> (и даже они могут быть - и часто это - просто макросы).</p><h2>стандарт c++ - автономная среда</h2><p>так же, как стандарт c признает как размещенную, так и автономную среду, то же самое относится и к стандарту c++. (цитаты из исо/мэк 14882: 2011.)</p><blockquote> <h3>1.4 соответствие реализации [intro.compliance]</h3> <p>two7 определены два вида реализаций: размещенная реализация <em> </em> и автономная реализация <em> </em>. для размещенной реализации этот международный стандарт определяет набор доступных библиотек. автономная реализация - это та, в которой выполнение может осуществляться без использования операционной системы, и имеет определенный набор реализаций библиотек, который включает в себя определенные библиотеки поддержки языка (17.6.1.3).</p> <p>implementation8 соответствующая реализация может иметь расширения (включая дополнительные библиотечные функции), при условии, что они не изменяют поведение любой правильно сформированной программы. внедрения необходимы для диагностики программ, использующих такие расширения, которые неправильно сформированы в соответствии с настоящим международным стандартом. сделав это, однако, они могут компилировать и выполнять такие программы.</p> <p>each9 каждая реализация должна включать документацию, которая идентифицирует все условно поддерживаемые конструкции, которые она не поддерживает, и определяет все специфичные для локали характеристики.<sup>3</sup></p> <p><sup>3)</sup> эта документация также определяет поведение, определяемое реализацией; см. 1.9.</p> <h3>17.6.1.3 отдельно стоящие реализации [соответствие]</h3> <p>определены два вида реализаций: размещенный и автономный (1.4). для размещенной реализации этот международный стандарт описывает набор доступных заголовков.</p> <p>автономная реализация имеет определенный набор реализаций заголовков. этот набор должен включать как минимум заголовки, показанные в таблице 16.</p> <p>предоставленная версия заголовка <code><cstdlib></code> должна объявлять как минимум функции <code>abort</code>, <code>atexit</code>, <code>at\_quick\_exit</code>, <code>exit</code> и <code>quick\_exit</code> (18.5). другие заголовки, перечисленные в этой таблице, должны соответствовать тем же требованиям, что и для размещенной реализации.</p> <p>таблица 16 - заголовки c++ для автономных реализаций</p> <pre><code>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> </code></pre></blockquote><h2>как насчет использования <code>int main()</code> в c?</h2><p>стандарт §5.1.2.2.1 стандарта c11 показывает предпочтительную нотацию - <code>int main(void)</code> - но есть также два примера в стандарте, которые показывают <code>int main()</code>: <a href="https://port70.net/~nsz/c/c11/n1570.html#6.5.3.4p8">§6.5.3.4 ¶8</a> и <a href="https://port70.net/~nsz/c/c11/n1570.html#6.7.6.3p20">§6.7.6.3 )2</a> . теперь важно отметить, что примеры не являются "нормативными"; они только иллюстративны. если в примерах есть ошибки, они не влияют напрямую на основной текст стандарта. тем не менее, они строго указывают на ожидаемое поведение, поэтому, если стандарт включает в себя <code>int main()</code> в примере, он предполагает, что <code>int main()</code> не запрещена, даже если это не предпочтительная нотация.</p><blockquote> <h3>6.5.3.4 операторы <code>sizeof</code> и <code>\_alignof</code></h3> <p>...</p> <p>пример 8 в этом примере размер массива переменной длины вычисляется и возвращается из функции:</p> <pre><code>#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; } </code></pre></blockquote>

<p>я считаю, что <code>main()</code> должен возвращать либо <code>exit\_success</code>, либо <code>exit\_failure</code>. они определены в <code>stdlib.h</code></p>

<p>обратите внимание, что стандарты c и c++ определяют два вида реализаций: автономные и размещенные.</p><ul> <li> <p><strong>среда размещения c9</strong></p> <p>разрешенные формы <sup>1</sup>:</p> <pre><code>int main (void) int main (int argc, char *argv[]) main (void) main (int argc, char *argv[]) /*... etc, similar forms with implicit int */ </code></pre> <p>комментарии:</p> <p>первые два явно указаны как разрешенные формы, остальные неявно разрешены, потому что c90 допускает "неявное int" для возвращаемого типа и параметров функции. никакая другая форма не допускается.</p> </li> <li> <p><strong>c90 автономная среда</strong></p> <p>разрешается любая форма или имя главного <sup>2</sup>,.</p> </li> <li> <p><strong>среда размещения c99</strong></p> <p>разрешенные формы <sup>3</sup>:</p> <pre><code>int main (void) int main (int argc, char *argv[]) /* or in some other implementation-defined manner. */ </code></pre> <p>комментарии:</p> <p>c99 удалил "implicit int", поэтому <code>main()</code> больше недействителен.</p> <p>было введено странное, неоднозначное предложение "или каким-то другим образом, определяемым реализацией". это может быть либо интерпретировано как "параметры <code>int main()</code> могут различаться", либо как "main может иметь любую форму, определяемую реализацией".</p> <p>некоторые компиляторы решили интерпретировать стандарт последним способом. можно утверждать, что нелегко утверждать, что они не являются строго соответствующими, цитируя стандарт сам по себе, поскольку он неоднозначен.</p> <p>однако разрешить совершенно дикие формы <code>main()</code>, вероятно, (?) не было целью этого нового предложения. обоснование c99 (не нормативное) подразумевает, что предложение относится к дополнительным параметрам <code>int main</code> <sup>4</sup>,.</p> <p>тем не менее, раздел для завершения программы размещенной среды продолжает спорить о случае, когда main не возвращает int <sup>5</sup>, хотя этот раздел не является нормативным для того, как main должен быть объявлен, он определенно подразумевает, что main может быть объявлен полностью определяемым реализацией способом даже в размещенных системах.</p> </li> <li> <p><strong>автономная среда c99</strong></p> <p>разрешается любая форма или имя главного <sup>6</sup>,.</p> </li> <li> <p><strong>среда размещения c11</strong></p> <p>разрешенные формы <sup>7</sup>:</p> <pre><code>int main (void) int main (int argc, char *argv[]) /* or in some other implementation-defined manner. */ </code></pre></li> <li> <p><strong>c11 автономная среда</strong></p> <p>разрешается любая форма или имя главного <sup>8</sup>,.</p> </li> </ul><hr><p>обратите внимание, что <code>int main()</code> никогда не указывался в качестве допустимой формы для любой размещенной реализации c в любой из вышеуказанных версий. в c, в отличие от c++, <code>()</code> и <code>(void)</code> имеют разные значения. первый является устаревшей функцией, которая может быть удалена из языка. смотрите c11 будущие языковые направления:</p><blockquote> <p>6.11.6 объявление функций</p> <p>использование деклараторов функций с пустыми скобками (не деклараторы типов параметров в формате prototype) является устаревшей функцией.</p> </blockquote><hr><ul> <li> <p><strong>размещенная среда c++ </strong></p> <p>разрешенные формы <sup>9</sup>:</p> <pre><code>int main () int main (int argc, char *argv[]) </code></pre> <p>комментарии:</p> <p>обратите внимание на пустые скобки в первой форме. c++ и c в этом случае различны, потому что в c++ это означает, что функция не принимает параметров. но в c это означает, что он может принимать любой параметр.</p> </li> <li> <p><strong>c++ 03 автономная среда</strong></p> <p>имя функции, вызываемой при запуске, определяется реализацией. если он называется <code>main()</code>, он должен следовать указанным формам <sup>10</sup>:</p> <pre><code>// implementation-defined name, or int main () int main (int argc, char *argv[]) </code></pre></li> <li> <p><strong>размещенная среда c++ 11</strong></p> <p>разрешенные формы <sup>11</sup>:</p> <pre><code>int main () int main (int argc, char *argv[]) </code></pre> <p>комментарии:</p> <p>текст стандарта был изменен, но он имеет то же значение.</p> </li> <li> <p><strong>автономная среда c++ 11</strong></p> <p>имя функции, вызываемой при запуске, определяется реализацией. если он называется <code>main()</code>, он должен следовать указанным формам <sup>12</sup>:</p> <pre><code>// implementation-defined name, or int main () int main (int argc, char *argv[]) </code></pre></li> </ul><hr><p><strong>ссылки</strong></p><ol> <li> <p>ansi x3.159-1989 2.1.2.2 размещенная среда. "запуск программы"</p> <blockquote> <p>функция, вызываемая при запуске программы, называется основной. реализация не объявляет прототип для этой функции. он должен быть определен с типом возврата int и без параметров:</p> </blockquote> <pre><code>int main(void) { /* ... */ } </code></pre> <blockquote> <p>или с двумя параметрами (именуемыми здесь как argc и argv, хотя могут использоваться любые имена, поскольку они являются локальными для функции, в которой они объявлены):</p> </blockquote> <pre><code>int main(int argc, char *argv[]) { /* ... */ } </code></pre></li> <li> <p>ansi x3.159-1989 2.1.2.1 отдельно стоящая среда:</p> <blockquote> <p>в автономной среде (в которой выполнение программы на с может происходить без какой-либо выгоды от операционной системы), имя и тип функции, вызываемой при запуске программы, определяются реализацией.</p> </blockquote> </li> <li> <p>iso 9899: 1999 5.1.2.2 размещенная среда -> 5.1.2.2.1 запуск программы</p> <blockquote> <p>функция, вызываемая при запуске программы, называется основной. реализация не объявляет прототип для этой функции. он должен быть определен с типом возврата int и без параметров:</p> </blockquote> <pre><code>int main(void) { /* ... */ } </code></pre> <blockquote> <p>или с двумя параметрами (именуемыми здесь как argc и argv, хотя могут использоваться любые имена, поскольку они являются локальными для функции, в которой они объявлены):</p> </blockquote> <pre><code>int main(int argc, char *argv[]) { /* ... */ } </code></pre> <blockquote> <p>или эквивалентный; 9) или каким-либо другим способом, определяемым реализацией.</p> </blockquote> </li> <li> <p>обоснование международного стандарта - языки программирования - c, редакция 5.10. 5.1.2.2 размещенная среда -> 5.1.2.2.1 запуск программы</p> <blockquote> <p>поведение аргументов main и взаимодействия exit, main и atexit (см. §7.20.4.2) было кодифицировано, чтобы обуздать некоторое нежелательное разнообразие в представлении строк argv и в значении значений, возвращаемых main.</p> <p>спецификация argc и argv в качестве аргументов для main признает обширную предшествующую практику. argv [argc] должен быть нулевым указателем, чтобы обеспечить избыточную проверку конца списка, также на основе обычной практики.</p> <p>main - единственная функция, которая может быть объявлена переносимым образом либо с нулем, либо с двумя аргументами. (число аргументов других функций должно точно совпадать между вызовом и определением.) этот особый случай просто признает широко распространенную практику исключения аргументов из main, когда программа не имеет доступа к строкам аргументов программы. хотя многие реализации поддерживают более двух аргументов для main, такая практика не благословлена и не запрещена стандартом; программа, которая определяет main с тремя аргументами, не является строго соответствующей (см. §j.5.1.).</p> </blockquote> </li> <li> <p>iso 9899: 1999 5.1.2.2 размещенная среда -> 5.1.2.2.3 завершение программы</p> <blockquote> <p>если возвращаемый тип главной функции является типом, совместимым с int, возврат из начального вызова основной функции эквивалентен вызову функции выхода со значением, возвращаемым главной функцией в качестве аргумента; 11) достижение <code>}</code>, который прекращает, основная функция возвращает значение 0. если возвращаемый тип не совместим с int, состояние завершения, возвращаемое в среду хоста, не указывается.</p> </blockquote> </li> <li> <p>iso 9899: 1999 5.1.2.1 отдельно стоящая среда</p> <blockquote> <p>в автономной среде (в которой выполнение программы на с может происходить без какой-либо выгоды от операционной системы), имя и тип функции, вызываемой при запуске программы, определяются реализацией.</p> </blockquote> </li> <li> <p>iso 9899: 2011 5.1.2.2 размещенная среда -> 5.1.2.2.1 запуск программы</p> <p>этот раздел идентичен c99, приведенному выше.</p> </li> <li> <p>iso 9899: 1999 5.1.2.1 отдельно стоящая среда</p> <p>этот раздел идентичен c99, приведенному выше.</p> </li> <li> <p>iso 14882: 2003 3.6.1 основная функция</p> <blockquote> <p>реализация не должна предопределять основную функцию. эта функция не должна быть перегружена. он должен иметь возвращаемый тип типа int, но в остальном его тип определяется реализацией. все реализации должны позволять оба следующих определения main:</p> </blockquote> <pre><code>int main() { /* ... */ } </code></pre> <blockquote> <p>а также</p> </blockquote> <pre><code>int main(int argc, char* argv[]) { /* ... */ } </code></pre></li> <li> <p>iso 14882: 2003 3.6.1 основная функция</p> <blockquote> <p>определяется реализацией, требуется ли программе в автономной среде для определения главной функции.</p> </blockquote> </li> <li> <p>iso 14882: 2011 3.6.1 основная функция</p> <blockquote> <p>реализация не должна предопределять основную функцию. эта функция не должна быть перегружена. он должен иметь возвращаемый тип типа int, но в остальном его тип определяется реализацией. все реализации должны позволять</p> <p>- функция (), возвращающая int и</p> <p>- функция (int, указатель на указатель на символ), возвращающая int</p> <p>как тип основного (8.3.5).</p> </blockquote> </li> <li> <p>iso 14882: 2011 3.6.1 основная функция</p> <p>этот раздел идентичен c++ 03, приведенному выше.</p> </li> </ol>

<p>вернуть 0 в случае успеха и ненулевое значение в случае ошибки. это стандарт, используемый сценариями unix и dos для определения того, что случилось с вашей программой.</p>

<p><code>main()</code> в c89 и k & r c неопределенные типы возвращаемых значений по умолчанию имеют значение int.</p><pre><code>return 1? return 0? </code></pre><ol> <li> <p>если вы не пишете инструкцию возврата в <code>int main()</code>, закрывающий <code>{</code> по умолчанию вернет 0.</p> </li> <li> <p><code>return 0</code> или <code>return 1</code> будут получены родительским процессом. в оболочке он переходит в переменную оболочки, и если вы запускаете свою программу из оболочки и не используете эту переменную, вам не нужно беспокоиться о возвращаемом значении <code>main()</code>.</p> </li> </ol><p>смотрите <a href="https://stackoverflow.com/q/8626109/775964">как я могу получить то, что вернула моя основная функция?</a> .</p><pre><code>$ ./a.out $ echo $? таким образом, вы можете видеть, что это переменная $?</code>, которая получает младший байт возвращаемого значения <code>main()</code>.</p><p>в сценариях unix и dos обычно возвращается <code>return 0</code> в случае успеха и ненулевое значение в случае ошибки. это стандарт, используемый сценариями unix и dos для выяснения того, что случилось с вашей программой и контроля всего потока.</p>

<p>имейте в виду, что, даже если вы возвращаете int, некоторые ос (windows) усекают возвращаемое значение до одного байта (0-255).</p>

<p>возвращаемое значение может использоваться операционной системой для проверки того, как программа была закрыта.</p><p>возвращаемое значение 0 обычно означает ок в большинстве операционных систем (те, которые я могу думать в любом случае).</p><p>это также может быть проверено, когда вы сами вызываете процесс, и смотрите, правильно ли программа завершилась.</p><p>это <strong>не</strong> просто соглашение о программировании.</p>

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

<p>у меня сложилось впечатление, что стандарт определяет, что main не нуждается в возвращаемом значении, поскольку успешное возвращение основано на ос (ноль в одном может быть либо успехом, либо неудачей в другом), поэтому отсутствие возврата было сигналом для компилятор для вставки самого успешного возврата.</p><p>однако я обычно возвращаю 0.</p>

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

<h2>пропустить <code>return 0</code></h2><p>когда программа на c или c++ достигает конца <code>main</code>, компилятор автоматически генерирует код, возвращающий 0, поэтому нет необходимости явно указывать <code>return 0;</code> в конце <code>main</code>.</p><p><strong> примечание: </strong> когда я делаю это предложение, за ним почти всегда следует один из двух видов комментариев: "я этого не знал". или "это плохой совет!" мое обоснование заключается в том, что безопасно и полезно полагаться на поведение компилятора, явно поддерживаемое стандартом. для c, так как c99; см. исо/мэк 9899: 1999, раздел 5.1.2.2.3:</p><blockquote> <p>[...] возврат из начального вызова функции <code>main</code> эквивалентен вызову функции <code>exit</code> со значением, возвращаемым функцией <code>main</code> в качестве аргумента; при достижении <code>}</code>, который завершает функцию <code>main</code>, возвращается значение 0.</p> </blockquote><p>для c++, начиная с первого стандарта в 1998 году; см. исо/мэк 14882: 1998 раздел 3.6.1:</p><blockquote> <p>если управление достигает конца main, не встречая оператора return, результатом является выполнение return 0;</p> </blockquote><p>с тех пор все версии обоих стандартов (c99 и c++ 98) придерживались той же идеи. мы полагаемся на автоматически сгенерированные функции-члены в c++, и немногие люди пишут явные операторы <code>return;</code> в конце функции <code>void</code>. причины против пропуска, кажется, сводятся к <a href="https://stackoverflow.com/questions/2581993/what-the-reasons-for-against-returning-0-from-main-in-iso-c/2582015#2582015">"это выглядит странно"</a> . если, как и я, вас интересует обоснование изменения стандарта c <a href="https://stackoverflow.com/questions/31394171/what-was-the-rationale-for-making-return-0-at-the-end-of-main-optional">прочитайте этот вопрос</a> . также обратите внимание, что в начале 1990-х это считалось "небрежной практикой", потому что в то время это было неопределенное поведение (хотя и широко поддерживаемое).</p><p>кроме того, <a href="https://github.com/isocpp/cppcoreguidelines/blob/master/cppcoreguidelines.md">c++ core guidelines</a> содержит несколько случаев пропуска <code>return 0;</code> в конце <code>main</code> и ни одного случая, в которых записан явный возврат. хотя в этом документе пока нет конкретного руководства по этой конкретной теме, это, по крайней мере, является молчаливым одобрением этой практики.</p><p>так что я призываю опустить это; другие не согласны (часто яростно!). в любом случае, если вы столкнетесь с кодом, который его пропускает, вы будете знать, что он явно поддерживается стандартом, и вы будете знать, что это значит.</p>

<blockquote> <p>как правильно (наиболее эффективно) определить функцию main () в c и c++ - int main () или void main () - и почему?</p> </blockquote><p>эти слова "(наиболее эффективные)" не меняют вопрос. если вы не находитесь в автономной среде, существует один универсально правильный способ объявления <code>main()</code>, и это как возвращение int.</p><blockquote> <p>что должна возвращать <code>main()</code> в c и c++?</p> </blockquote><p>это не то, что <em>должно</em> <code>main()</code> вернуть, это то, что <em>делает</em> <code>main()</code> вернуть. <code>main()</code> - это, конечно, функция, которую кто-то еще вызывает. вы не имеете никакого контроля над кодом, который вызывает <code>main()</code>. следовательно, вы должны объявить <code>main()</code> с правильной сигнатурой для соответствия вызывающей стороне. у вас просто нет выбора в этом вопросе. вам не нужно спрашивать себя, что является более или менее эффективным, что лучше или хуже, или что-то в этом роде, потому что ответ для вас уже совершенно четко определен стандартами c и c +. просто следуй за ними.</p><blockquote> <p>если int main (), тогда вернуть 1 или вернуть 0?</p> </blockquote><p>0 для успеха, ненулевое значение для отказа. опять же, не то, что вам нужно (или нужно) выбирать: это определяется интерфейсом, которому вы должны соответствовать.</p>

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

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

<p>вот небольшая демонстрация использования кодов возврата ...</p><p>при использовании различных инструментов, предоставляемых терминалом linux, можно использовать код возврата, например, для обработки ошибок после завершения процесса. представьте, что присутствует следующий текстовый файл myfile:</p><blockquote> <p>это пример того, как проверить, как работает grep.</p> </blockquote><p>когда вы выполняете команду grep, процесс создается. по завершении (и без прерывания) возвращается код от 0 до 255. например:</p><pre><code>$ grep order myfile если вы делаете$ echo $? $ 0 </code></pre><p>вы получите 0. почему? потому что <a href="http://en.wikipedia.org/wiki/grep">grep</a> нашел совпадение и возвратил код выхода 0, который является обычным значением для выхода с успехом. давайте проверим это снова, но с чем-то, чего нет в нашем текстовом файле, и, следовательно, совпадение не будет найдено:</p><pre><code>$ grep foo myfile $ echo $? $ 1 </code></pre><p>поскольку grep не удалось сопоставить токен "foo" с содержимым нашего файла, код возврата равен 1 (это обычный случай, когда происходит сбой, но, как указано выше, у вас есть множество значений на выбор).</p><p>теперь следующий скрипт bash (просто введите его в терминале linux), хотя и очень простой, должен дать некоторое представление об обработке ошибок:</p><pre><code>$ grep foo myfile $ check=$? $ [ $check -eq 0] && echo 'match found' $ [ $check -ne 0] && echo 'no match was found' $ no match was found </code></pre><p>после второй строки ничего не выводится на терминал, так как "foo" заставляет grep возвращать 1, и мы проверяем, был ли код возврата grep равен 0. второе условное выражение повторяет свое сообщение в последней строке, так как оно истинно из-за check == 1.</p><p>как вы можете видеть, вызываете ли вы этот и тот процесс, иногда важно увидеть, что он вернул (по возвращаемому значению main ()).</p>