Return 0


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

Часто, ваши программы должны будут прерывать то, что они делают, чтобы выполнить что-то другое. Вы делаете это в реальной жизни всё время. Например, вы читаете книгу и вспомнили, что нужно сделать телефонный звонок. Вы оставляете закладку в своей книге, звоните и когда уже поговорили, возвращаетесь к той странице, на которой остановились.

Программы в C++ работают также. Иногда, когда программа выполняет код, она может столкнуться с вызовом функции (function call). Вызов функции – это выражение, которое указывает процессору прервать текущую функцию и выполнить другую. Процессор «оставляет закладку» в текущей точке выполнения, а затем вызывает (выполняет) определенную функцию. Когда выполнение вызываемой функции завершается, процессор возвращается к месту, где «осталась закладка» и возобновляет выполнение.

Функция, в которой находится вызов — называется caller, а функция, которую вызывают – callee (либо «вызываемая функция»).

Ниже приведен пример программы с вызовом функции:

Результат выполнения программы выше:

Starting main()



In doPrint()
Ending main()

Эта программа начинает выполнение с функции main() и первая строка выводит текст Starting main(). Вторая строка вызывает функцию doPrint(). На этом этапе выполнение инструкций в main() приостанавливается и процессор переходит к doPrint(). Первая (и единственная) строка в doPrint() выводит текст In doPrint(). Когда doPrint() завершает выполнение, caller (main ()) возобновляет выполнение с места остановки. Следовательно, следующая инструкция – вывод строки Ending main().

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

Правило: Не забывайте указывать скобки () при вызове функции.

Возвращаемые значения


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

Функции, которые вы пишете, также могут возвращать значения. Для этого нужно установить тип возвращаемого значения (или тип возврата). Он указывается при объявлении функции, перед её именем. Обратите внимание, тип возврата не указывает, какое конкретно значение будет возвращаться. Он указывает только, какого типа будет это значение.

Затем внутри вызываемой функции мы используем оператор return, чтобы указать, какое конкретно значение будет возвращаться в caller. Это значение, возвращаемое функцией, называется возвращаемым значением.

Рассмотрим простую функцию, которая возвращает целочисленное значение:

В первом вызове функции return7() функция возвращает значение 7 обратно в caller, которое затем передается в std::cout для вывода.

Во втором вызове функции return7() функция снова возвращает значение 7 обратно в caller. Выражение 7+3 производит значение 10. Значение 10 передается в std::cout для вывода.

В третьем вызове функции return7() функция возвращает значение 7 обратно в caller. Однако main() ничего не делает с возвращаемым значением, поэтому ничего и не происходит (возвращаемое значение игнорируется).

Примечание: Возвращаемые значения не будут выведены, если caller не отправит их в std::cout. В последнем вызове функции значение не отправляется в std::cout, поэтому ничего и не происходит.

Возвращаемые значения типа void


Функции могут и не возвращать значения. Чтобы сообщить компилятору, что функция не возвращает значение — нужно использовать тип возврата void. Посмотрим еще раз на функцию doPrint() из примера выше:

Эта функция имеет тип возврата void, который означает, что функция не возвращает значение обратно в caller. Поскольку значение не возвращается, то и оператор возврата (return) не требуется.

Вот еще один пример функции с типом возврата void:

В первом вызове функции returnNothing() выводится «Hey!», а затем ничего не возвращается обратно в caller. Точка выполнения возвращается в main(), и программа продолжает своё выполнение.

Второй вызов функции returnNothing() даже не скомпилируется. Функция returnNothing() имеет тип возврата void, который означает, что функция не возвращает значение. Однако main() пытается отправить это значение (которое не возвращается) в std::cout для вывода. std::cout не может обработать этот случай, так как значения не вывод не предоставлено. Следовательно, компилятор выдаст ошибку. Вам нужно будет закомментировать эту строку, чтобы компиляция прошла успешно.

Возврат в main

Теперь у вас есть понимание того, как работает функция main(). Когда программа выполняется, операционная система делает вызов функции main() и начинается её выполнение. Инструкции в main() выполняются последовательно. В конце main() возвращает целое значение (обычно 0) обратно в операционную систему. Поэтому main() объявляется как int main()


.

Почему нужно возвращать значение обратно в операционную систему? Возвращаемое значение в main() – это код состояния и он сообщает операционной системе успешно ли выполнена программа. Обычно, возвращаемое значение 0 (нуль) означает успех, а любое другое — ошибку.

Обратите внимание, по стандартам C++ функция main() должна возвращать целое число. Однако, если вы не укажете return в конце main(), то компилятор вернет 0 автоматически, если ошибок не будет. Но мы рекомендуем указывать return в main() и использовать тип возврата int для main().

Еще немного о возвращаемых значениях

Во-первых, если функция имеет тип возврата не void, то она должна возвращать значение указанного типа (через оператор return). Единственно исключение — функция main(), которая возвращает значение 0, если иное явно не предустановлено.

Во-вторых, когда в функции точка выполнения доходит до оператора return, то функция немедленно возвращает значение в caller и точка выполнения переходит также в caller. Любой код, который находится дальше за return-ом — игнорируется.

Функция может возвращать только одно значение через return обратно в caller. Это может быть одно число (например, 5), значение переменной или выражения (которое производит одно значение). Или же определенное значение из набора возможных значений.


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

Наконец, обратите внимание, функция может свободно определять, что означает её возвращаемое значение. Некоторые функции используют возвращаемые значения в качестве кодов состояния для указания результата выполнения (успешно или нет). Другие функции возвращают вычисленное или выбранное (из набора) значение. Еще другие функции ничего не возвращают. То, что функция возвращает, и значение этого значения — всё это определяется автором функции. Из-за большого разнообразия всего — было бы неплохо оставлять комментарии к собственным функциям, указывая не только, что они возвращают, но и что значат возвращаемые значения.

Повторное использование функций

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

Результат выполнения программы выше:

Enter an integer: 4
Enter an integer: 9
4 + 9 = 13

Здесь main() прерывается 2 раза. Обратите внимание, в обоих случаях, полученное значение, которое мы сохраняем в переменной x, передается обратно в main() с помощью return, а затем присваивается переменной a или b!

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

Результат выполнения программы выше:

Starting main()



O
K
Ending main()

Вложенные функции

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

Правильно вот так:

Тест

Рассмотрите следующие программы и укажите, что они выводят, и какие из них не скомпилируются (и почему).

1.

Ответ 1

Результатом выполнения программы будет значение 13.

2.

Ответ 2

Эта программа не скомпилируется. Вложенные функции запрещены.

3.

Ответ 3

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

4.

Ответ 4

Эта программа не скомпилируется. Функция printO() возвращает void, который main() пытается отправить в std::cout. Это приведет к ошибке компиляции.

5.

Ответ 5


Эта программа выведет 6 дважды (в отдельных строках). Оба раза, когда вызывается функция getNumbers(), возвращается значение 6. Когда выполняется оператор return 6, то функция немедленно завершается и точка выполнения переходит в main(), return 8 никогда не выполняется.

6.

Ответ 6

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

7.

Ответ 7

Эта программа скомпилируется, но функция не будет вызываться, так как в вызове функции отсутствуют скобки. То, что выведется — зависит от компилятора.

ravesli.com

Функция — это группа операторов у которой есть имя. Во всех предыдущих уроках, код наших программ располагался в одной функции — main. Функции позволяют разбить программу на небольшие части, каждая из которых выполняет какую-то небольшую задачу. Посмотрите на полный код морского боя (раздел — Листинги). В нём больше 500 строк кода. Без функций было бы довольно проблематично написать эту программу. В ней используется 11 функций, самая длинная из которых состоит из 50 строк кода.

Обязательными для функции являются два компонента: определение и вызовы.

Определение функции

Определение функции должно располагаться в глобальной области видимости, до начала функции main. Рассмотрим пример, простого определения:


Определение функции состоит из заголовка и тела. Заголовок фукнции включает в себя:
Тип возвращаемого значения

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

int simple_function()
float simple_function()
char simple_function()

В первом случае функция должна вернуть целое число (int), во втором — вещественное число (float), а в третьем случае — символ (char).

Возвращаемые значения используются для передачи данных из функции в вызывающее окружение. Вызывающее окружение — это то место, откуда вызывается данная функция, подробнее ниже.
Идентификатор или имя функции

Идентификатор (имя) функции задаётся точно также, как и любой другой идентификатор. В данном примере мы создали функцию с идентификатором simple_function (simple — простой).
Список аргументов или параметров

Список аргументов функции записывается в круглых скобках после имени функции. В данном примере список аргументов пуст.

Список аргументов записывается через запятую. Каждый элемент списка состоит из типа и идентификатора. Рассмотрим пример заголовка функции со списком из двух аргументов:


int simple (int a, float b)

В скобках мы записали два аргумента: a и b. У аргумента a тип int, а у аргумента b тип float.

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

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

Здесь, simple_function всегда будет возвращать 0. Надо признать, что данная функция бесполезна. Напишем функцию, которая принимает из вызывающего окружения два значения, складывает их и возвращает результат в вызывающее окружение. Назовём эту функцию sum (сумма):

В функцию передаётся два аргумента: a и b типа int. В теле функции они используются как обычные переменные (они и являются обычными переменными). Давайте договоримся: снаружи функции, переменные, которые передаются в неё, мы будем называть аргументами, а эти же переменные в теле функции — параметрами.

В теле функции определяется переменная c. А затем, в эту переменную мы помещаем значение суммы двух параметров.

Последняя строчка возвращает значение переменной c во внешнее окружение.

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


return 32;
return a;
return b;
return a+b;

В последнем случае в вызывающее окружение будет возвращён результат суммы переменных a и b.

Обратите внимание, что оператор return не только возвращает значение, но и служит как бы выходом из функции, после него не будет выполнен ни один оператор:

return a;
c = a+b; // этот оператор не будет выполнен

Благодаря этому, с помощью return удобно создавать условия выхода из функций:

Здесь, из функции будет возвращено число в зависимости от значения переменной a: если a больше нуля, то будет возвращён 0, в противном случае — 1.
Вызов функции

После того как создано определение функции, её можно вызвать.

В результате выполнения программы, на экран будет выведено: 4.

Вызов функции состоит из идентификатора функции и списка аргументов в круглых скобках. Вот несколько вызовов функции sum:

int x = 5;
int y = 4;
int z;

sum(0,1); // 1
sum(x,2); // 7
sum(x,y); // 9
z = sum(x,y); // z = 9

Вызывающее окружение

То место, откуда вызывается функция, называется вызывающим окружением. Вызывающим окружением функции sum является функция main, а вызывающим окружением функции main является отладчик или операционная система.

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

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

В списке аргументов мы указали тип int, а в функцию передаётся вещественное значение 0.5. Так делать нельзя.

Рассмотрим более полезный пример: напишем функцию для передвижения персонажа:

Обратите внимание, что для тела if и else if не стоит скобочек. Скобочки ветвлений можно опускать, если в теле ветвления всего один оператор.

Функция move_x двигает персонажа на одну единицу влево или вправо в зависимости от клавиши, которую нажал пользователь.

Создадим ещё одну функцию, а заодно уберём из main часть кода:

Обратите внимание, что в функции move на месте типа возвращаемого значения стоит void, кроме того, в теле move нет оператора return.

Объявления функций (прототипы)

В последнем примере, определение функции move_x должно располагаться выше определения move (а определения move_x и move должны располагаться до main), так как в функции move происходит вызов move_x.

Обычно определения всех пользовательских функций располагаются после определения main. При этом используются объявления функций (прототипы). Внесём изменения в предыдущую программу:

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

int move_x(int dx);
int move_x(int);

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

Объявление функции может находиться в любом месте программы (за пределами определений функций программы или в любом определении), главное, чтобы оно появилось до первого вызова функции. Если вы не используете объявления, то до первого вызова функции должно стоять определение, которое также может располагаться в любом месте программы.
Возврат void
На месте возвращаемого типа, в определении (и в объявлении) функции move стоит ключевое слово void (void — пусто, пустой). Это значит, что функция не возвращает никакого значения. Следовательно не требуется и оператор return, так как функции нечего вернуть в вызывающее окружение.

gamesmaker.ru

Из данной статьи Вы узнаете о передаче параметров в функцию и о возврате результата с помощью оператора return. Рассмотрим теоретический материал.

Передача параметров в функцию

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

Передача параметров выполняется следующим образом. Вычисляются выражения, стоящие на месте фактических параметров. Затем формальным параметрам присваиваются значения фактических. Выполняется проверка типов и при необходимости выполняется их преобразование.

Передача параметров в функцию может осуществляться по значению и по адресу.

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

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

тип имя_функции (const тип_переменной* имя_переменной, …)

Пример

Возврат результата с помощью оператора return

Возврат результата из функции в вызывающую ее функцию осуществляется оператором

return (значение);

Работает оператор так. Вычисляется значение выражения, указанного после return и преобразуется к типу возвращаемого функцией значения. Выполнение функции завершается, а вычисленное значение передается в вызывающую функцию. Любые операторы, следующие в функции за оператором return, игнорируются. Программа продолжает свою работу с оператора следующего за оператором вызова данной функции.

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

Также функция может содержать несколько операторов return, если это определенно потребностями алгоритма. Например, в следующей программе функция f сравнивает значение переменной с нулем. Если число положительное, то в программу передается значение равное 1, если отрицательное, то -1, а если нулевое, то 0.

Этот урок не последний в теме «функции». Но, что касается передачи параметров и оператора return, то думаю этого вполне достаточно для дальнейшего изучения C++.

kvodo.ru


You May Also Like

About the Author: admind

Добавить комментарий

Ваш e-mail не будет опубликован. Обязательные поля помечены *

Этот сайт использует Akismet для борьбы со спамом. Узнайте как обрабатываются ваши данные комментариев.