Инструкция return почему возвращает 0 от чего зависит возвращаемое значение

Рассмотрим следующую программу:

#include <iostream>
 
int main()
{
	// получаем значение от пользователя
	std::cout << "Enter an integer: ";
	int num{};
	std::cin >> num;
 
	// выводим удвоенное значение
	std::cout << num << " doubled is: " << num * 2 << 'n';
 
	return 0;
}

Эта программа состоит из двух концептуальных частей: во-первых, мы получаем значение от пользователя. Затем мы сообщаем пользователю, чему равно это значение, умноженное на два.

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

Итак, давайте напишем программу для этого:

// Эта программа не работает
#include <iostream>
 
void getValueFromUser()
{
 	std::cout << "Enter an integer: ";
	int input{};
	std::cin >> input;  
}
 
int main()
{
	getValueFromUser(); // Просим пользователя ввести данные
 
	int num{}; // Как нам получить значение из getValueFromUser() 
               // и использовать его для инициализации этой переменной??
 
	std::cout << num << " doubled is: " << num * 2 << 'n';
 
	return 0;
}

Хотя эта программа – хорошая попытка решения, она не совсем работает.

Когда вызывается функция getValueFromUser, пользователя просят ввести целое число, как и ожидалось. Но введенное им значение теряется, когда getValueFromUser завершает работу и управление возвращается к main. Переменная num никогда не инициализируется значением, введенным пользователем, поэтому программа всегда печатает ответ 0.

Чего нам не хватает, так это того, чтобы getValueFromUser могла вернуть значение, введенное пользователем, обратно в main, чтобы main могла использовать эти данные.

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

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

Во-первых, ваша функция должна указать, значение какого типа будет возвращено. Это делается путем установки типа возвращаемого значения функции, который является типом, определенным перед именем функции. В приведенном выше примере функция getValueFromUser имеет тип возвращаемого значения void, а функция main имеет тип возвращаемого значения int. Обратите внимание, что это не определяет, какое конкретное значение будет возвращено – только тип значения.

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

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

#include <iostream>
 
// int - это тип возвращаемого значения
// Тип возвращаемого значения int означает, что функция вернет вызывающей стороне
// некоторое целочисленное значение (конкретное значение здесь не указано)
int returnFive()
{
    // инструкция возврата указывает конкретное значение, которое будет возвращено
    return 5; // возвращаем конкретное значение 5 обратно вызывающей стороне
}
 
int main()
{
    std::cout << returnFive() << 'n';     // печатает 5
    std::cout << returnFive() + 2 << 'n'; // печатает 7
 
    returnFive(); // хорошо: значение 5 возвращается, но игнорируется, 
                  // поскольку main() ничего с ним не делает
 
    return 0;
}

При запуске эта программа печатает:

5
7

Выполнение начинается с верхней части main. В первой инструкции вычисляется вызов функции returnFive, в результате чего вызывается функция returnFive. Функция returnFive возвращает конкретное значение 5 обратно вызывающей стороне, которое затем выводится в консоль через std::cout.

Во второй инструкции вычисляется вызов функции returnFive, что приводит к повторному вызову функции returnFive. Функция returnFive возвращает значение 5 обратно вызывающей стороне. Выражение 5 + 2 вычисляется для получения результата 7, который затем выводится в консоль через std::cout.

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

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

Исправляем нашу тестовую программу

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

#include <iostream>
 
int getValueFromUser() // эта функция теперь возвращает целочисленное значение
{
 	std::cout << "Enter an integer: ";
	int input{};
	std::cin >> input;  
 
	return input; // возвращаем значение, введенное пользователем, обратно вызывающей функции
}
 
int main()
{
	int num { getValueFromUser() }; // инициализируем num значением, возвращаемым getValueFromUser()
 
	std::cout << num << " doubled is: " << num * 2 << 'n';
 
	return 0;
}

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

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

Отсутствие возвращаемого значения

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

void doPrint() // void is the return type
{
    std::cout << "In doPrint()" << 'n';
    // Эта функция не возвращает значение, поэтому инструкция return не требуется
}

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

Вот еще один пример функции, ничего не возвращающей, и пример программы, которая ее вызывает:

#include <iostream>
 
// void означает, что функция не возвращает значение вызывающей стороне
void returnNothing()
{
    std::cout << "Hi" << 'n';
    // Эта функция не возвращает значение, поэтому инструкция return не требуется
}
 
int main()
{
    returnNothing(); // хорошо: вызывается функция returnNothing(), значение не возвращается
 
    std::cout << returnNothing(); // ошибка: эта строка не компилируется. 
                                  // Вам нужно будет закомментировать ее, чтобы продолжить.
 
    return 0;
}

При первом вызове функции returnNothing функция печатает «Hi», а затем ничего не возвращает вызывающей функции. Управление возвращается в main, и программа продолжает выполнение.

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

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

Возвращаясь к main

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

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

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

#include <cstdlib> // для EXIT_SUCCESS и EXIT_FAILURE
 
int main()
{
    return EXIT_SUCCESS;
}

C++ запрещает явный вызов функции main.

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

Несколько дополнительных замечаний о возвращаемых значениях

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

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

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

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

Например:

// Функция просит пользователя ввести значение
// Возвращаемое значение - это целое число, введенное пользователем с клавиатуры
int getValueFromUser()
{
 	std::cout << "Enter an integer: ";
	int input{};
	std::cin >> input;  
 
	return input; // возвращаем значение, введенное пользователем, обратно вызывающей функции
}

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

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

#include <iostream>
 
int main()
{
	int x{};
	std::cout << "Enter an integer: ";
	std::cin >> x; 
 
	int y{};
	std::cout << "Enter an integer: ";
	std::cin >> y; 
 
	std::cout << x << " + " << y << " = " << x + y << 'n';
 
	return 0;
}

Пока эта программа работает, но она немного избыточна. Фактически, эта программа нарушает один из основных принципов хорошего программирования: «Не повторяйся» (или англоязычная аббревиатура DRY, т.е. «Don’t Repeat Yourself»).

Почему повторяющийся код плох? Если бы мы хотели изменить текст «Enter an integer:» на что-то другое, нам пришлось бы обновить его в двух местах. А что, если бы мы захотели инициализировать 10 переменных вместо 2? Это было бы большое количество избыточного кода (что сделало бы наши программы длиннее и сложнее для понимания) и много места для вкрадывания опечаток.

Давайте обновим эту программу, чтобы использовать нашу функцию getValueFromUser, которую мы разработали выше:

#include <iostream>
 
int getValueFromUser()
{
 	std::cout << "Enter an integer: ";
	int input{};
	std::cin >> input;  
 
	return input;
}
 
int main()
{
    int x{ getValueFromUser() }; // первый вызов getValueFromUser
    int y{ getValueFromUser() }; // второй вызов getValueFromUser
 
    std::cout << x << " + " << y << " = " << x + y << 'n';
 
    return 0;
}

Эта программа создает следующий вывод:

Enter an integer: 5
Enter an integer: 7
5 + 7 = 12

В этой программе мы дважды вызываем getValueFromUser: один раз для инициализации переменной x и один раз для инициализации переменной y. Это избавляет нас от дублирования кода для ввода пользовательских данных и снижает вероятность ошибки. Как только мы узнаем, что getValueFromUser работает для одной переменной, она будет работать для любого их количества, сколько нам будет нужно.

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

Заключение

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

Функции позволяют минимизировать избыточность наших программ.

Небольшой тест

Вопрос 1

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

1а)

#include <iostream>
 
int return7()
{
    return 7;
}
 
int return9()
{
    return 9;
}
 
int main()
{
    std::cout << return7() + return9() << 'n';
 
    return 0;
}

Ответ

Эта программа печатает число 16.

1b)

#include <iostream>
 
int return7()
{
    return 7;
 
    int return9()
    {
        return 9;
    }
}
 
int main()
{
    std::cout << return7() + return9() << 'n';
 
    return 0;
}

Ответ

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

1c)

#include <iostream>
 
int return7()
{
    return 7;
}
 
int return9()
{
    return 9;
}
 
int main()
{
    return7();
    return9();
 
    return 0;
}

Ответ

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

1d)

#include <iostream>
 
void printA()
{
    std::cout << "An";
}
 
void printB()
{
    std::cout << "Bn";
}
 
int main()
{
    printA();
    printB();
 
    return 0;
}

Ответ

Эта программа печатает буквы A и B в отдельных строках.

1e)

#include <iostream>
 
void printA()
{
    std::cout << "An";
}
 
int main()
{
    std::cout << printA() << 'n';
 
    return 0;
}

Ответ

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

1f)

#include <iostream>
 
int getNumbers()
{
    return 5;
    return 7;
}
 
int main()
{
    std::cout << getNumbers() << 'n';
    std::cout << getNumbers() << 'n';
 
    return 0;
}

Ответ

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

1g)

#include <iostream>
 
int return 5()
{
    return 5;
}
 
int main()
{
    std::cout << return 5() << 'n';
 
    return 0;
}

Ответ

1h) Чуть сложнее.

#include <iostream>
 
int returnFive()
{
    return 5;
}
 
int main()
{
    std::cout << returnFive << 'n';
 
    return 0;
}

Ответ

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

Вопрос 2

Что означает «DRY» и почему это полезно?

Ответ

DRY означает «Don’t Repeat Yourself» (не повторяйся). Это практика, которая включает в себя написание кода таким образом, чтобы минимизировать избыточность. Это делает ваши программы более краткими, менее подверженными ошибкам и более удобными для поддержки.

Теги

C++ / CppLearnCppДля начинающихОбучениеПрограммирование