какое значение возвращает функция main
Функция main. Аргументы и возвращаемое значение
Даже если не передавать программе никаких значений — argc будет равен единице, т.к. argv[0] всегда содержит имя запущенной программы. Последний элемент массива параметров ( argv[argc] ) всегда равен нулю — это может использоваться при переборе параметров.
Часто делают так, что при запуске программы без аргументов она начинает диалог с пользователем, но если аргументы переданы — то использует их (не задает лишних вопросов):
Приведенная программа выводит на экран первое число из файла. При этом если имя файла передается в качестве аргумента, но если аргумент не задан — программа спросит требуемое имя у пользователя во время работы:
Многие утилиты требуют определенное количество входных аргументов, например если приложение на вход всегда должно принимать входной и выходной файл — программа может для начала проверить количество параметров:
В последнем примере функция main() возвращает значение. Значением всегда является целое число, которое обрабатывается операционной системой — процесс, завершающийся с кодом ноль отработал без ошибок, во всех остальных случаях операционная система знает что произошла какая-то ошибка (при этом значения могут быть любыми, на них нет никакого стандарта). Нулевое значение функция main() вернет автоматически (при нормальном завершении программы) — это зафиксировано стандартом языка, все остальные значения рекомендуется именовать при помощи констант или перечислений ( enum ).
Урок №12. Функции и оператор возврата return
Обновл. 11 Сен 2021 |
Вы уже знаете, что каждая программа должна содержать функцию main() (с которой она и начинает свое выполнение). Тем не менее, большинство программ используют и много других функций.
Функции
Функция — это последовательность стейтментов для выполнения определенного задания. Часто ваши программы будут прерывать выполнение одних функций ради выполнения других. Вы делаете аналогичные вещи в реальной жизни постоянно. Например, вы читаете книгу и вспомнили, что должны были сделать телефонный звонок. Вы оставляете закладку в своей книге, берете телефон и набираете номер. После того, как вы уже поговорили, вы возвращаетесь к чтению: к той странице, на которой остановились.
Программы на языке C++ работают похожим образом. Иногда, когда программа выполняет код, она может столкнуться с вызовом функции. Вызов функции — это выражение, которое указывает процессору прервать выполнение текущей функции и приступить к выполнению другой функции. Процессор «оставляет закладку» в текущей точке выполнения, а затем выполняет вызываемую функцию. Когда выполнение вызываемой функции завершено, процессор возвращается к закладке и возобновляет выполнение прерванной функции.
Функция, в которой находится вызов, называется caller, а функция, которую вызывают — вызываемая функция, например:
Результат выполнения программы:
Starting main()
In doPrint()
Ending main()
Правило: Не забывайте указывать круглые скобки () при вызове функций.
Возвращаемые значения
Когда функция main() завершает свое выполнение, она возвращает целочисленное значение обратно в операционную систему, используя оператор return.
Функции, которые мы пишем, также могут возвращать значения. Для этого нужно указать тип возвращаемого значения (или «тип возврата»). Он указывается при объявлении функции, перед её именем. Обратите внимание, тип возврата не указывает, какое именно значение будет возвращаться. Он указывает только тип этого значения.
Затем, внутри вызываемой функции, мы используем оператор return, чтобы указать возвращаемое значение — какое именно значение будет возвращаться обратно в caller.
Рассмотрим простую функцию, которая возвращает целочисленное значение:
Результат выполнения программы:
Первый вызов функции return7() возвращает 7 обратно в caller, которое затем передается в std::cout для вывода.
Третий вызов функции return7() опять возвращает 7 обратно в caller. Однако функция main() ничего с ним не делает, поэтому ничего и не происходит (возвращаемое значение игнорируется).
Примечание: Возвращаемые значения не выводятся на экран, если их не передать объекту std::cout. В последнем вызове функции return7() значение не отправляется в std::cout, поэтому ничего и не происходит.
Тип возврата void
Функции могут и не возвращать значения. Чтобы сообщить компилятору, что функция не возвращает значение, нужно использовать тип возврата void. Взглянем еще раз на функцию doPrint() из вышеприведенного примера:
Эта функция имеет тип возврата void, который означает, что функция не возвращает значения. Поскольку значение не возвращается, то и оператор return не требуется.
Вот еще один пример использования функции типа void:
Второй вызов функции returnNothing() даже не скомпилируется. Функция returnNothing() имеет тип возврата void, который означает, что эта функция не возвращает значения. Однако функция main() пытается отправить это значение (которое не возвращается) в std::cout для вывода. std::cout не может обработать этот случай, так как значения на вывод не предоставлено. Следовательно, компилятор выдаст ошибку. Вам нужно будет закомментировать эту строку, чтобы компиляция прошла успешно.
Возврат значений функцией main()
Почему нужно возвращать значения обратно в операционную систему? Дело в том, что возвращаемое значение функции main() является кодом состояния, который сообщает операционной системе об успешном или неудачном выполнении программы. Обычно, возвращаемое значение 0 (ноль) означает что всё прошло успешно, тогда как любое другое значение означает неудачу/ошибку.
Обратите внимание, по стандартам языка C++ функция main() должна возвращать целочисленное значение. Однако, если вы не укажете return в конце функции main(), компилятор возвратит 0 автоматически, если никаких ошибок не будет. Но рекомендуется указывать return в конце функции main() и использовать тип возврата int для функции main().
Еще о возвращаемых значениях
Во-вторых, когда процессор встречает в функции оператор return, он немедленно выполняет возврат значения обратно в caller и точка выполнения также переходит в caller. Любой код, который находится за оператором return в функции — игнорируется.
Функция может возвращать только одно значение через return обратно в caller. Это может быть либо число (например, 7 ), либо значение переменной, либо выражение (у которого есть результат), либо определенное значение из набора возможных значений.
Но есть способы обойти правило возврата одного значения, возвращая сразу несколько значений, но об этом детально мы поговорим на соответствующем уроке.
Наконец, автор функции решает, что означает её возвращаемое значение. Некоторые функции используют возвращаемые значения в качестве кодов состояния для указания результата выполнения функции (успешно ли выполнение или нет). Другие функции возвращают определенное значение из набора возможных значений. Кроме того, существуют функции, которые вообще ничего не возвращают.
Повторное использование функций
Одну и ту же функцию можно вызывать несколько раз, даже в разных программах, что очень полезно:
Функция main и выполнение программ
Все программы, написанные на языке C, содержат основную функцию, которая должна иметь имя main. Если код соответствует модели программирования Юникода, можно использовать версию функции main для многобайтовых символов с именем wmain. Функция main является начальной точкой для выполнения программы. Она обычно управляет выполнением программы, вызывая другие ее функции. Как правило, выполнение программы завершается в конце функции main, но по разным причинам это может случиться и в других местах программы. Иногда (возможно, при обнаружении некоторой ошибки) может потребоваться принудительно завершить программу. Для этого используйте функцию exit. Сведения о функции exit и пример ее использования см. в Справочнике по библиотеке времени выполнения.
Синтаксис
Примечания
Функции в исходном коде программы выполняют одну или несколько конкретных задач. Функция main может вызывать эти функции для выполнения соответствующих задач. Когда функция main вызывает другую функцию, она передает ей управление выполнением, и работа программы продолжается с первого оператора вызываемой функции. Вызываемая функция возвращает управление функции main, когда выполняется оператор return или достигается конец этой функции.
Для любой функции, включая функцию main, можно объявить наличие параметров. Термин «параметр» или «формальный параметр» относится к идентификатору, получающему значение, передаваемое функции. Сведения о передаче аргументов в качестве параметров вы найдете в статье Параметры. Когда одна функция вызывает другую, вызываемая функция получает значения своих параметров от вызывающей функции. Эти значения называются аргументами. Для функции main можно объявить формальные параметры, и тогда она будет принимать аргументы из командной строки в следующем формате.
Описание версии main для расширенных символов см. в статье Использование wmain.
Что должно возвращать main () в C и c++?
существует множество повторений этого вопроса, в том числе:
18 ответов
также стоит отметить, что в C++, int main() может быть оставлено без возвращаемого значения, в котором по умолчанию возвращается 0. Это также верно для программы C99. Должен ли быть опущен возврат 0 или нет, открыто для обсуждения. Диапазон допустимых основных сигнатур программы C намного больше.
принятый ответ, похоже, предназначен для C++, поэтому я подумал, что добавлю ответ, относящийся к C, и это отличается несколькими способами.
ISO / IEC 9899: 1989 (C90):
main() должно быть объявлено как:
или эквивалент. Например, int main(int argc, char *argv[]) эквивалентно второму. Далее, int возвращаемый тип может быть опущен, поскольку он является значением по умолчанию.
если реализация допускает, main() может быть объявлен в другими способами, но это делает реализацию программы определенной и уже не строго соответствующей.
стандарт определяет 3 значения для возврата, которые строго соответствуют (то есть не зависят от определенного поведения реализации): 0 и EXIT_SUCCESS для успешного завершения, и EXIT_FAILURE для неудачного завершения. Любые другие значения являются нестандартными и определяются реализацией. main() должен иметь явную return оператор в конце, чтобы избежать неопределенного поведение.
наконец, нет ничего неправильно с точки зрения стандартов с вызовом main() из программы.
ISO / IEC 9899: 1999 (C99):
для C99 все то же самое, что и выше, за исключением:
Стандартная C-Размещенная Среда
для размещенной среды (это обычная среда) стандарт C11 (ISO/IEC 9899:2011) говорит:
5.1.2.2.1 запуск программы
или с двумя параметры (называемые здесь argc и argv хоть какие-то имена могут быть использованы, так как они являются локальными для функции, в которой они объявлены):
или эквивалент; 10) или каким-либо другим образом, определенным для реализации.
если они объявлены, параметры основной функции должны подчиняться следующему ограничения:
завершение работы программы в C99 или C11
значение, возвращаемое из main() передается в «среду» определенным способом реализации.
завершение программы 5.1.2.2.3
11) в соответствии с 6.2.4, продолжительность жизни объектов с автоматической продолжительностью хранения, объявленной в main закончились бы в первом случае, даже там, где их не было бы в последний.
обратите внимание, что 0 является обязательным как «успех». Вы можете использовать EXIT_FAILURE и EXIT_SUCCESS С если вы предпочитаете, но 0 хорошо установлен, а также 1. См. также коды выхода больше 255-возможно?.
в C89 (и, следовательно, в Microsoft C) нет утверждения о том, что произойдет, если main() функция возвращает, но не указывает возвращаемое значение; поэтому это приводит к неопределенному поведению.
7.22.4.4 в exit функции
стандарт C++11 (ISO / IEC 14882: 2011) говорит:
3.6.1 основная функция [basic.начать.main]
¶1 программа должна содержать глобальную функцию main, которая является назначенным началом программы. [. ]
¶2 реализация не должна предопределять основную функцию. Эта функция не должна быть перегружена. Он должен иметь тип возвращаемого типа int, но в противном случае ее тип определяется реализацией. Все реализации должны допускаться оба следующих определения main:
¶3 функции main не должны использоваться в рамках программы. Связь (3.5) из main реализация-определено. [. ]
¶5 оператор return в main имеет эффект выхода из основной функции (уничтожение любых объектов с помощью автоматического длительность хранения) и вызов std::exit с возвращаемым значением в качестве аргумента. Если управление достигает конца из main без встречая оператор return, эффект заключается в выполнении
есть параграф §18.5 Пуск и прекращение в стандарте C++11, который идентичен абзацу из §7.22.4.4 на exit функции в стандарте C11 (цитируется выше), кроме сноски (которая просто документирует, что EXIT_SUCCESS и EXIT_FAILURE определена в ).
Стандартное Расширение C-Common
классически системы Unix поддерживают третий вариант:
это признано стандартом C в качестве общего расширения, документально подтвержденного в приложении J:
J. 5.1 окружающая среда доводы
Microsoft C
на Microsoft VS 2010 компилятор интересные. Веб-сайт говорит:
обратите внимание, что стандарты C и c++ определяют два вида реализаций: автономные и размещенные.
размещенная среда C90
разрешенные формы 1 :
первые два явно указаны как разрешенные формы, другие неявно разрешены, потому что C90 разрешил «неявный int» для возвращаемых параметров типа и функции. Никакая другая форма допустимый.
C90 автономная среда
размещенная среда C99
разрешенные формы 3 :
C99 удален «неявный int» so main() больше не действует.
странное, двусмысленное предложение «или в каком-то другом вводится определенный порядок осуществления». Это может быть интерпретировано как «параметры int main() может отличаться» или как «main может иметь любую форму, определенную реализацией».
некоторые компиляторы решили интерпретировать стандарт последним способом. Вероятно, нельзя легко утверждать, что они не соответствуют строго, ссылаясь на стандарт сам по себе, поскольку он неоднозначен.
C99 автономная среда
размещенная среда C11
разрешенные формы 7 :
C11 автономная среда
обратите внимание, что int main() никогда не был указан в качестве допустимой формы для любой размещенной реализации C в любой из вышеуказанных версий. В C, в отличие от c++, () и (void) имеют разные значения. Первый является устаревшим элементом, который может быть удален из языка. См. C11 будущие языковые направления:
использование деклараторов функций с пустыми круглые скобки (а не деклараторы типов параметров формата прототипа) являются устаревшей функцией.
C++03 размещенная среда
разрешенные формы 9 :
обратите внимание на пустую скобку в первой форме. В этом случае C++ и C отличаются, потому что в C++ это означает, что функция не принимает параметров. Но в C это означает, что может потребоваться любой параметр.
C++03 автономная среда
имя функции, вызываемой при запуске, определяется реализацией. Если он называется main() он должен следовать указанной форме 10 :
в C++11, размещенных среды
разрешенные формы 11 :
текст стандарта изменился, но суть та же.
C++11 автономная среда
имя функции, вызываемой при запуске, определяется реализацией. Если он называется main() он должен следовать указанной форме 12 :
ссылки
ANSI X3.159-1989 2.1.2.2 размещенная среда. «Программа startup»
функция, вызываемая при запуске программы, называется главным. Этот реализация не объявляет прототип для этой функции. Оно должно быть определяется с возвращаемым типом int и без параметров:
или с двумя параметрами (упоминаемый здесь как argc и argv, хотя могут использоваться любые имена, поскольку они являются локальными для функции, в которой они объявлены):
ANSI X3.159-1989 2.1.2.1 автономная среда:
в отдельно стоящей среде (в которой выполнение программы C может занять место без каких-либо преимуществ операционной системы), имя и тип функции, вызываемой при запуске программы, определяются реализацией.
функция, вызываемая при запуске программы, называется главным. Этот реализация не объявляет прототип для этой функции. Оно должно быть определяется с возвращаемым типом int и без параметров:
или с двумя параметрами (упоминаемый здесь как argc и argv, хотя могут использоваться любые имена, поскольку они являются локальными для функция, в которой они объявлены):
или эквивалент; 9) или в каком-либо другом реализация-определена манера.
поведение аргументов в main и взаимодействия exit, main и atexit (см. §7.20.4.2) был кодифицирован для ограничения некоторого нежелательного разнообразия в представлении argv строки, и в значении значений, возвращаемых главный.
спецификация argc и argv в качестве аргументов для main признает обширную предыдущую практику. argv[argc] должен быть нулевым указателем для обеспечения избыточной проверки конца списка, также на основе общей практики.
main-единственная функция, которая может быть объявлена с нулевым или двумя аргументами. (Число аргументов других функций должно точно совпадать между вызовом и определением.) Этот особый случай просто признает распространенную практику отказа от аргументов в main, когда программа не получает доступ к строкам аргументов программы. Хотя многие реализации поддерживают более двух аргументов main, такая практика не благословлена и не запрещена стандартом; программа, которая определяет main с тремя аргументами, не строго соответствует (см. §J. 5.1.).
если возвращаемый тип основной функции является типом, совместимым с int, возврат от начального вызова основной функции эквивалентен вызову функции выхода со значением, возвращаемым основной функцией в качестве ее аргумента; 11) достижение > при завершении основной функции возвращается значение 0. Если возвращаемый тип не совместим с int, состояние завершения, возвращаемое в среду узла неопределенный.
ISO 9899: 1999 5.1.2.1 автономная среда
в автономной среде (в которой выполнение программы на языке C может происходить без использования операционной системы) имя и тип функции, вызываемой при запуске программы, определяются реализацией.
этот раздел идентичен приведенному выше разделу C99.
ISO 9899: 1999 5.1.2.1 автономная среда
этот раздел идентичен приведенному выше разделу C99.
ISO 14882: 2003 3.6.1 основная функция
реализация не должна предопределять основную функцию. Эта функция не должна быть перегружена. Он должен иметь возвращаемый тип типа int, но в противном случае его тип определяется реализацией. Все реализации должны допускать оба следующих определения main:
ISO 14882: 2003 3.6.1 основная функция
это реализация-определяется, требуется ли программа в автономной среде для определения основной функции.
ISO 14882: 2011 3.6.1 основная функция
An осуществление не предопределяет основную функцию. Эта функция не должна быть перегружена. Он должен иметь возвращаемый тип типа int, но в противном случае его тип определяется реализацией. Все реализации разрешить
— функция (), возвращающая int и
— функция (int, указатель на указатель на char), возвращающая int
в качестве типа main (8.3.5).
ISO 14882: 2011 3.6.1 Main функция
этот раздел идентичен c++03 приведенному выше.
возврат 0 при успехе и ненулевой для ошибки. Это стандарт, используемый сценариями UNIX и DOS, чтобы узнать, что произошло с вашей программой.
имейте в виду, что, хотя вы возвращаете int, некоторые ОС (Windows) усекают возвращаемое значение до одного байта (0-255).
main() в C89 и K&R C неопределенные возвращаемые типы по умолчанию ‘int’.
если вы не пишете оператор return в int main() закрытие < по умолчанию возвращает 0.
в сценариях Unix и DOS, return 0 на успех и ненулевые для ошибки обычно возвращаются. Это стандарт, используемый сценариями Unix и DOS, чтобы узнать, что произошло с вашей программой и контролировать весь поток.
возвращаемое значение может использоваться операционной системой для проверки закрытия программы.
возвращаемое значение 0 обычно означает OK в большинстве операционных систем (те, о которых я могу думать в любом случае).
Он также может быть проверен, когда вы вызываете процесс самостоятельно, и посмотреть, если программа вышла и закончена должным образом.
Это не просто соглашение о программировании.
возвращаемое значение main() показывает, как программа завершится. Если возвращаемое значение zero это означает, что выполнение было успешным, в то время как любое ненулевое значение будет представлять, что что-то пошло не так в выполнении.
У меня создалось впечатление, что standard указывает, что main не нуждается в возвращаемом значении, поскольку успешное возвращение было основано на ОС (ноль в одном может быть либо успешным, либо неудачным в другом), поэтому отсутствие возврата было сигналом для компилятора, чтобы вставить успешное возвращение само.
однако я обычно возвращаю 0.
возврат 0 должен сообщить программисту, что программа успешно завершила работу.
что для возврата зависит от того, что вы хотите сделать с исполняемым файлом. Например, если вы используете свою программу с оболочкой командной строки, вам нужно вернуть 0 для успеха и ненулевое значение для сбоя. Тогда вы сможете использовать программу в оболочках с условной обработкой в зависимости от результата вашего кода. Также вы можете назначить любое ненулевое значение в соответствии с вашей интерпретацией, например, для критических ошибок различные точки выхода программы могут завершить программу с различные значения выхода и которые доступны вызывающей оболочке, которая может решить, что делать, проверив возвращаемое значение. Если код не предназначен для использования с оболочками и возвращаемое значение никого не беспокоит, его можно опустить. Я лично использую подпись int main (void)
Если у вас действительно есть проблемы, связанные с эффективностью возврата целого числа из процесса, вам, вероятно, следует избегать вызова этого процесса так много раз, что это возвращаемое значение становится проблемой.
Если вы делаете это (вызовите процесс так много раз), вы должны найти способ поместить свою логику непосредственно внутри вызывающего абонента или в DLL-файл, не выделяя конкретный процесс для каждого вызова; несколько распределений процессов приносят вам соответствующую проблему эффективности в этом случай.
подробно, если вы только хотите знать, является ли возврат 0 более или менее эффективным, чем возврат 1, это может зависеть от компилятора в некоторых случаях, но в целом, предполагая, что они считываются из одного источника (локальный, поле, константа, встроенный в код, результат функции и т. д.) для этого требуется точно такое же количество тактов.
если int main () затем возвращает 1 или возвращает 0?
0 для успеха, ненулевое для неудачи. Опять же, не то, что вам нужно (или нужно) выбрать: это определяется интерфейсом, которому вы должны соответствовать.
в C++ основная функция должна быть объявлена как int main (), а не void main (), поскольку компилятор затем выдает ошибку в случае void main. Основная функция может принимать любое количество аргументов, таких как int main(int k,int l,int arr[]) или int main(void).
приходя к возвращаемой части, он должен возвращать только 0, иначе компилятор выдает ошибку. например, если вы вернете 1,вы получите желаемый результат, но он также бросает время выполнения ошибка.
вот небольшая демонстрация использования кодов возврата.
при использовании различных инструментов, предоставляемых терминалом Linux, можно использовать код возврата, например, для обработки ошибок после завершения процесса. Представьте, что присутствует следующий текстовый файл myfile:
это некоторый пример, чтобы проверить, как работает grep.
при выполнении команды grep процесс создания. Как только это закончится (и не сломался) он возвращает некоторый код между 0 и 255. Например:
вы получите 0. Почему? Потому что grep найдено совпадение и возвращен код выхода 0, который является обычным значением для выхода с успехом. Давайте проверим еще раз, но с чем-то не внутри нашего текстового файла и, следовательно, не будет:
поскольку grep не смог сопоставить токен «foo» с содержимым нашего файла, код возврата 1 (это обычный случай, когда происходит сбой, но, как указано выше, у вас есть много значений на выбор).
теперь следующий скрипт bash (просто введите его в терминал Linux), хотя очень простой должен дать некоторое представление об обработке ошибок:
после второй строки ничего не печатается на терминал, так как» foo » сделал grep return 1, и мы проверяем, был ли код возврата grep равен 0. Второе условное утверждение повторяет свое сообщение в последняя строка, так как она истинна из-за CHECK == 1.
как вы можете видеть, если вы вызываете этот и этот процесс, иногда важно увидеть, что он вернул (по возвращаемому значению main ()).
пропустить return 0
[. ] возврат от первоначального вызова к main функция эквивалентна вызову exit функция со значением, возвращаемым main функция в качестве аргумента; достижение > что расторгает main функция возвращает значение 0.
для C++, начиная с первого стандарта в 1998 году; см. раздел ISO / IEC 14882:1998 3.6.1:
если элемент управления достигает конца main, не встречая оператора return, эффект заключается в выполнении return 0;
все версии обоих стандартов с тех пор (C99 и C++98) поддерживали одну и ту же идею. Мы полагаемся на автоматически генерируемые функции-члены В C++, и мало кто пишет явные return; заявления в конце