# Лекция 3. Функции, указатели, ссылки, структуры
## Функции (повторение)
Функция — это именованный блок кода с формальными параметрами
и возвращаемым значением.
Пример:
```cpp
double
multiply(double x, int y) {
return x * y;
}
```
Здесь `double` — тип возвращаемого значения (результата),
`multiply` — имя функции,
`(double x, int y)` — список формальных параметров,
а в фигурных скобках — тело функции.
Если вместо типа возвращаемого значения указать `void`,
это значит, что функция значения не возвращает.
Тип возвращаемого значения, имя функции и список формальных параметров
могут быть разнесены по строкам в соответствии со стилем и читаемостью.
Например, мы в лабораторных работах предпочитаем тип возвращаемого значения
писать на отдельной строке.
С точки зрения C++ это безразлично.
Типы ее формальных параметров составляют *сигнатуру* функции.
Отметим, что тип возвращаемого значения, имя функции и имена параметров
в сигнатуру не входят.
Например, сигнатура `multiply`: `(double, int)`.
Оператор `return` определяет возвращаемое значение
и немедленно завершает функцию.
В `void`-функциях тоже можно использовать `return` без указания результата,
чтобы немедленно выйти из функции.
**Внимание.**
Выполнение не-`void` функции всегда должно заканчиваться `return`,
хотя C++ не отслеживает это жестко (но может выдать предупреждение).
Внутри тела функции её формальные параметры являются локальными переменными.
Они независимы от переменных в месте вызова функции,
даже если у них одинаковые имена:
```cpp
void func(int x) {
x = 66;
}
...
int x = 42;
func(x);
// x == 42
```
При вызове функции значения, переданные ей в качестве аргументов,
*копируются* в её переменные-параметры.
## Указатели (повторение)
**Примечание.**
В этой лекции не рассматривается динамическое выделение памяти,
а только сами указатели как тип данных и их применение в связи с функциями.
Всю память компьютера можно представить как массив байтов.
Тогда индекс в этом массиве, то есть номер ячейки памяти,
называется *адресом,* а переменная, содержащая адрес, называется *указателем.*
При объявлении указателей перед именем переменной ставится звездочка.
Например, так объявляется указатель на действительное число:
```cpp
double* r1;
```
Часто звездочку прижимают к имени типа, а не переменной, как в примере.
Есть известная «ловушка»:
```cpp
double* x, y;
```
Здесь только `x` является указателем (имеет тип `double*`),
а `y` является обычной переменной (имеет тип `double`).
Надо либо ставить звездочку перед каждой переменной-указателем,
либо объявлять каждую переменную отдельно (это почти всегда нагляднее).
В указатель записывается не значение переменной, а ее адрес.
Адрес берется *оператором взятия адреса* в виде амперсанда (`&`):
```cpp
double x = 3.14;
double* p = &x;
```
Вот как расположены при этом данные в памяти:
```
адреса: 0 1 8 9 10 11 12 42 43 44 45 46
+---+- -+---+---+---+---+- -+---+---+---+---+-
ячейки: | | ..... | 3.14 | ..... | 8 | ...
+---+- -+---+---+---+---+- -+---+-.'+---+---+-
↑\_____________/ \__.'_________/
| x .' p
| .'
&x = 8 = ...............'
```
Чтобы, имея указатель, обратиться к тем данным, адрес которых он хранит,
используется оператор *разыменования* в виде звездочки:
```cpp
*p = 2.71; // x = 2.71
```
Есть специальное значение указателя — нулевой: `NULL`, `0` или `nullptr`.
Указатель, хранящий такой адрес, запрещено разыменовывать.
Начальное значение указателя, если оно не присвоено явно, не определено,
как и для любых других переменных встроенных типов.
Таким образом, переменной-указателем нельзя корректно пользоваться,
пока ей что-нибудь не присвоено.
### Висячие указатели (dangling pointers)
К сожалению, C++ не отслеживает, что значение указателя всегда корректно.
Рассмотрим пример:
```cpp
int* p = nullptr;
if (...) {
int x;
p = &x;
...
}
cout << *p;
```
В последней строке `p` указывает на переменную, которая объявлена внутри `if`
и уже не существует после выхода из фигурных скобок.
Поэтому, хотя указатель и хранит не `nullptr`, разыменовывать его нельзя.
Такие указатели на данные, которых уже нет, называются *висячими (dangling).*
Другой пример:
```cpp
int* func() {
int x = 42;
return &x;
}
...
auto p = func();
cout << *p;
```
Здесь функция возвращает адрес локальной переменной.
Однако локальные время жизни локальных переменных ограничено функцией,
поэтому пользоваться таким возвращаемым значением нельзя.
При работе с указателями надо всегда думать о том,
чтобы время жизни указателя не превышало время жизни данных,
адрес которых указатели хранят.
## Ссылки
Ссылка (reference) — это новое имя для существующего объекта.
Объект может быть переменной или её частью, такой как элемент массива.
Ссылки объявляются с использованием амперсанда:
```cpp
int var = 42;
int& ref = var;
```
Не следует путать амперсанд при объявлении ссылок
с амперсандом-оператором взятия адреса!
Обращение к ссылке эквивалентно обращению к тому, на что она ссылается:
```cpp
cout << ref; // 42
ref = 66;
cout << var; // 66
```
В частности, так как ссылка не является самостоятельной переменной,
её адрес — это адрес того, на что она ссылается,
а явное разыменование не нужно (если это не ссылка на указатель, конечно):
```cpp
if (&var == &ref) { ... } // истинно
*ref = 66; // ОШИБКА: обращение к ref — обращение к var,
// а var не указатель, разыменовать её нельзя.
```
Поскольку ссылка — новое имя для *существующего* объекта,
у нее всегда должно быть начальное значение:
```cpp
int& ref; // ОШИБКА: новое имя для чего?
```
Не бывает «нулевой ссылки», подобной нулевому указателю.
Даже вне связи с функциями ссылки могут применяться,
чтобы дать более короткие или понятные имена в коде:
```cpp
double& first = some_vector[0];
// ...
fisrt = 0;
```
### Передача входных параметров функций по ссылкам
Рассмотрим функцию, суммирующую элементы вектора:
```cpp
double sum(vector<double> xs) {
double total{};
for (double x : xs) {
total += x;
}
return total;
}
```
Вспомним, что при вызове функции значения аргументов *копируются*
в переменные-формальные параметры, то есть в `xs` будет помещена копия вектора,
который передан функции.
Если этот вектор большой, будет потрачено много лишней памяти,
кроме того, это копирование бесполезно — функция не меняет `xs` даже внутри.
Можно передавать `xs` по ссылке, чтобы не копировать вектор,
а работать с той переменной, которую передали функции, напрямую:
```cpp
double sum(vector<double>& xs) { ... }
...
vector<double> xs;
double s = sum(xs);
```
Однако есть две проблемы:
* Нельзя вызвать `sum({1, 2, 3})`,
потому что `{1, 2, 3}` — выражение, а не переменная.
Это запрещено, потому что с помощью ссылки возможно поменять то,
на что она ссылается, однако выражение поменять нельзя в принципе.
(Можно изменить значение переменной, содержащей `5 = 3 + 2`,
но нельзя поменять саму `5`, «пятерку как таковую».)
* При чтении кода непонятно, не меняет ли `sum()` свой аргумент,
и нет гарантий, что она этого не начнет делать в будущем.
Итак, нужно сослаться на аргумент, но сделать этот так,
чтобы с точки зрения `sum()` эта переменная была неизменяемой,
даже если в месте вызова менять ее можно.
Это делается с помощью константной ссылки:
```cpp
double sum(const vector<double>& xs) { ... }
```
При передаче параметров нетривиального типа (не `int`, `double` и т. п.),
в том числе при передаче `std::vector<T>` и `std::string`,
рекомендуется по умолчанию использовать константную ссылку.
## Выходные параметры функций через указатели и ссылки
Составим функцию для решения квадратного уравнения в действительных числах.
Очевидно, что она принимает коэффициенты уравнения.
Возвращает она три значения:
* признак, что действительные решения есть;
* корень `x1`;
* корень `x2`.
Однако у функции возвращаемое значение только одно, допустим, признак.
Как вернуть корни?
Можно сделать это через ссылки:
```cpp
bool solve(double a, double b, double c, double& x1, double& x2) {
auto d = b*b - 4*a*c;
if (d < 0) {
return false;
}
x1 = (-b + sqrt(d)) / 2*a;
x2 = (-b - sqrt(d)) / 2*a;
return true;
}
```
Вызов функции будет выглядеть так:
```cpp
double x1, x2;
if (solve(3, 2, 1, x1, x2)) {
cout << "x1 = " << x1 << "\n"
<< "x2 = " << x2 << "\n";
} else {
cout << "Нет действительных корней.\n";
}
```
Можно было бы использовать указатели:
```cpp
bool solve(double a, double b, double c, double* x1, double* x2) {
auto d = b*b - 4*a*c;
if (d < 0) {
return false;
}
*x1 = (-b + sqrt(d)) / 2*a;
*x2 = (-b - sqrt(d)) / 2*a;
return true;
}
```
Вызов функции будет выглядеть так:
```cpp
double x1, x2;
if (solve(3, 2, 1, &x1, &x2)) {
cout << "x1 = " << x1 << "\n"
<< "x2 = " << x2 << "\n";
} else {
cout << "Нет действительных корней.\n";
}
```
Какой вариант лучше и почему?
В случае с указателями в функцию мог бы быть передан нулевой указатель:
```cpp
solve(3, 2, 1, nullptr, &x2);
```
Программа успешно компилировалась бы, но при запуске аварийно завершилась,
поскольку в функции `solve()` был бы разыменован нулевой указатель `x1`.
Может показаться, что из-за этого вариант с указателями хуже:
функция должна проверять, что ей не передали нулевой указатель,
а со ссылками этого не потребовалось бы — ведь «нулевых ссылок» нет.
Однако наличие особого значения у указателя — не только проблема,
но и возможность связать с этим значением особую логику.
Например, функция могла бы быть реализована так:
```cpp
bool solve(double a, double b, double c, double* x1, double* x2) {
auto d = b*b - 4*a*c;
if (d < 0) {
return false;
}
if (x1) {
*x1 = (-b + sqrt(d)) / 2*a;
}
if (x2) {
*x2 = (-b - sqrt(d)) / 2*a;
}
return true;
}
```
Теперь, если передать в функцию `nullptr` в качестве `x1` или `x2`,
она не будет вычислять соответствующий корень.
Таким образом программа может сэкономить вычисления,
если оба корня ей заведомо не нужны.
Можно даже передать `nullptr` в качестве и `x1`, и `x2`,
тогда функция просто проверит, есть ли действительные решения —
возможно, конкретной программе, которая использует `solve()`,
только это и нужно.
Вывод: использовать для передачи выходных параметров указатели или ссылки
зависит от того, нужна ли дополнительная гибкость логики,
которую дает наличие особого значения — нулевого указателя.
Заметим, что некоторые проекты предпочитают всегда использовать указатели,
даже если предполагается, что они обязаны не быть `nullptr` никогда.
Причина в том, что в случае ссылок по вызову `solve(a, b, c, x1, x2)`
невозможно определить, какие из переменных после этой строки могут поменяться.
Вызов же `solve(a, b, c, &x1, &x2)` ясно показывает,
что `solve()` может поменять `x1` и `x2`.
## Структуры
Структура — это пользовательский тип данных,
представляющий собой совокупность именованных полей различных типов.
Структуры удобны для того, чтобы сгруппировать несколько переменных,
которые используются в программе совместно.
Например, в задаче ЛР № 1 можно было бы объединить входные данные в структуру:
```cpp
struct Input {
std::vector<double> numbers;
size_t bin_count;
};
```
Здесь `Input` — имя структуры, а `numbers` и `bin_count` — её поля.
Важно понять, что определение выше описывает тип данных (аналог `std::vector`
или `std::string`), а не переменную, то есть код выше не описывает переменные
`numbers` и `bin_count`, куда можно сохранить значения. Он описывает,
что каждая переменная типа `Input` содержит поля `numbers` и `bin_count`,
в которые уже можно сохранить конкретные данные.
Переменные типа структур объявляются так же, как переменные других типов;
именем типа выступает имя структуры:
```cpp
Input x;
```
Говорят, что переменная `x` — экземпляр структуры.
К полям структуры обращаются через точку:
```cpp
cout << x.numbers.size(); // 0
cin >> x.bin_count;
if (x.bin_count == 0) { ... }
```
Можно объявить несколько переменных типа структуры:
```cpp
Input y;
Input z;
y.bin_count = 3;
z.bin_count = 4;
```
Значения, хранимые в `x`, `y` и `z` будут независимы друг от друга.
### Инициализация полей
Вернемся к объявлению `x`, чему было равно `x.bin_count` до её ввода?
Так как в определении структуры
для поля `bin_count` не было указано значения по умолчанию,
то и конкретное начальное значение `x.bin_count` не определено.
Удобно, чтобы у всех полей были начальные значения.
Например, так можно инициализировать нулем `bin_count`
любой новой переменной типа `Input`:
```cpp
struct Input {
vector<double> numbers;
size_t bin_count{}; // или size_t bin_count = 0;
};
```
Как известно, переменные типа `vector<T>` по умолчанию содержат пустой вектор,
поэтому для поля `numbers` о начальном значении заботиться не нужно.
### Оператор «стрелка» (`->`)
На переменные типа структуры могут быть указатели:
```cpp
Input* p = new Input;
```
Чтобы использовать оператор `.` для доступа к полям структуры,
на которую указывает `p`, нужно сначала разыменовать `p`.
Оператор `.` имеет наивысший приоритет, поэтому нужны скобки: `(*p).bin_count`.
Это громоздко, поэтому в C++ введено оператор «стрелки» `->`,
чтобы записать то же самое проще: `p->bin_count`.
## Перегрузка функций
Можно объявить набор функций с одинаковыми именами, но разными сигнатурами:
```cpp
// print(3.14) -> 3.14
void print(double x) {
cout << x;
}
// print({1, 2, 3}) -> {1, 2, 3};
void print(const std::vector<double>& xs) {
cout << "{";
bool need_comma = false;
for (auto x : xs) {
if (need_comma) {
cout << ", ";
} else {
need_comma = true;
}
print(x); // вызов print(double), а не рекурсия
}
cout << "}";
}
```
Говорят, что функция `print()` *перегружена (overloaded),*
а каждая из конкретных функций называется её *перегрузкой.*
Когда компилятор встречает вызов `print()`, он анализирует типы параметров
и вызывает соответствующую перегрузку.
Перегрузки бывают полезны в обобщенном коде,
то есть таком, который готов работать с различными типами данных.
Об это будет рассказано на последующих лекциях.
## Объявление и определение функции
Будет ли компилироваться программа такого вида?
```cpp
void foo() {
bar();
}
void bar() {
foo();
}
```
Функция `foo()` вызывает функцию `bar()` раньше, чем она описана,
что вызовет ошибку.
Однако перенести описание `bar()` выше описания `foo()` нельзя:
`bar()` содержит вызов `foo()`, который тогда окажется выше,
чем описана `foo()`.
Рассуждая логически, для того, чтобы скомпилировать `foo()`,
компилятору не нужно тело функции `bar()` — достаточно знать,
что такая функция есть, и какие у нее параметры (нет параметров).
Сообщить компилятору о сигнатуре функции можно с помощью
*объявления функции (declaration)*.
В отличие от уже знакомого *определения функции (definition),*
объявление не содержит тела, а кончается точкой с запятой:
```cpp
void bar(); // объявление bar()
void foo() {
bar(); // вызов bar()
}
void bar() { // определение bar()
foo();
}
```
Объявления и определения важны при делении программы на файлы.