Функции
- Функция
- Вызов функции
- Определение функции
- Параметр, аргумент
- Возвращаемое значение,
return - Как обозначается интерфейс функции
Вопросы на понимание
Заголовок раздела «Вопросы на понимание»В данных примерах, объясните:
- Сколько переменных будет существовать на разных этапах выполнения программы;
- Скомпилируется ли вообще программа и если нет, почему;
- Какие значения будут в каждой из переменных по окончанию программы.
1. Две разные переменные
Заголовок раздела «1. Две разные переменные»void func(){ int b = 6;}int main(){ int a = 5; func();}Ответ:
Одна переменная a создается в main, она имеет значение 5.
После этого, при вызове функции func, функция создает еще одну переменную b, со значением 6.
Она попадает в следующую свободную ячейку после a (если игнорировать другие данные, попадающие
в стек, необходимые для вызова функций) во временной памяти (стеке).
При завершении func, вторая переменная b перестает существовать -
то есть к ее памяти невозможно будет сослаться из main, однако значение 6
продолжает существовать в этой ячейке памяти.
2. Две переменные с тем же именем
Заголовок раздела «2. Две переменные с тем же именем»void func(){ int a = 6;}int main(){ int a = 5; func();}Ответ:
Ситуация эквивалентна предыдущему примеру.
Разница в том, что локальная переменная b теперь носит тоже имя a.
Память этих переменных также различна.
3. Перезапись переменной в другой функции
Заголовок раздела «3. Перезапись переменной в другой функции»void func(){ int b = 6;}int main(){ int a = 5; func(); b = 7;}Ответ:
Данный код иллюстрирует тот факт, что переменная b перестает существовать.
Код не скопмилируется.
4. Перезапись переменной из main в другой функции
Заголовок раздела «4. Перезапись переменной из main в другой функции»void func(){ a = 6;}int main(){ int a = 5; func();}Ответ:
Данный код иллюстрирует тот факт, что переменная a из main не видна внутри func.
Код не скомпилируется.
5. Перезапись переданной переменной
Заголовок раздела «5. Перезапись переданной переменной»void func(int b){ b = 6;}int main(){ int a = 5; func(a);}Ответ:
При вызове функции, для ее параметров выделится по локальной переменной.
В эти переменные перекопируются значения аргументов,
то есть выражений в соответствующих позициях при вызове (a).
b = 6 изменит локальную переменную, существующую при вызове func.
b = 6 не повлияет на a.
В a будет 5.
6. Перезапись переданной переменной с тем же именем
Заголовок раздела «6. Перезапись переданной переменной с тем же именем»void func(int a){ a = 6;}int main(){ int a = 5; func(a);}Ответ:
Ситуация эквивалентна предыдущей.
a как параметр в функции func это имя локальной переменной, создаваемой при вызове func.
Этот a не привязан к a в main.
В a будет 5.
7. Передача структуры
Заголовок раздела «7. Передача структуры»struct A{ int f1; int f2;};void func(A a){ a.f1 = 1; a.f2 = 2;}int main(){ A a; a.f1 = 3; a.f2 = 4; func(a);}Ответ:
A здесь работает как тип параметра.
При передаче значения типа A передастся его копия - копия каждого из полей по отдельности.
Опять же, имена переменных и параметров не имеют значения, они не будут свзянаны друг с другом.
Код из func не повлияет на a из main.
8. Передача адреса
Заголовок раздела «8. Передача адреса»#include <iostream>
void func(int* a){ *a = 1;}int main(){ int a{2}; func(&a);
std::cout << a << std::endl;}Ответ:
Здесь в функцию приходит адрес локальной переменной.
a в func это адрес, а не копия.
Используя его, можно сослаться на память локальной переменной из main, и воздествовать на нее.
a перезапишется функцией на 1.
9. Передача адреса структуры
Заголовок раздела «9. Передача адреса структуры»#include <iostream>
struct A{ int f1; int f2;};void func(A* a){ a->f1 = 1; a->f2 = 2;}int main(){ A a; a.f1 = 3; a.f2 = 4; func(&a);
std::cout << a.f1 << std::endl; std::cout << a.f2 << std::endl;}Ответ:
Ситуация аналогична той, что выше.
a в func это адрес, а не копия всех полей.
Здесь перезапишется значение обоих полей переменной a в main.
10. Два параметра (1)
Заголовок раздела «10. Два параметра (1)»int func(int a, int b){ return a + b;}int main(){ int b = 6; func(1, b);}Ответ:
Несмотря на то, что func возвращает ответ, он никуда не сохраняется.
В b будет ее старое значение.
11. Два параметра (2)
Заголовок раздела «11. Два параметра (2)»int func(int a, int b){ return a + b;}int main(){ int b = 6; int s = func(1, b); b = s;}Ответ:
В b и в s будет 7.
12. Передача вызова функции параметром
Заголовок раздела «12. Передача вызова функции параметром»int func(int a, int b){ return a + b;}int main(){ int b = 6; int s = func(func(1, func(2, b)), b);}Ответ:
func(func(1, func(2, b)), b) - это сложное выражение, оно будет вычисляться наизнанку:
func(2, b)->func(2, 6)->8;func(1, 8)->9;func(9, b)->func(9, 6)->15.
13. Функция, вызывающая себя
Заголовок раздела «13. Функция, вызывающая себя»void func(int a){ func(a);}int main(){ func(1);}Ответ:
Здесь будет выделятся бесконечно памяти при каждом вызове func самой себя,
как минимум для переменной a, поскольку при вызове каждой последующей
func, будет создаваться a локальная ей, инициализированная a из func,
что была вызвана до этого (то есть, 1).
В определенный момент, память в стеке кончится, и программа крашнется (stack overflow).
14. Копирование аргументов
Заголовок раздела «14. Копирование аргументов»#include <iostream>
void func(int sum, int* a){ std::cout << sum << std::endl; *a = 3; std::cout << sum << std::endl;}int main(){ int a { 1 }; func(a + 2, &a);}Ответ:
Выведется 3 2 раза, потому что сначала высчитывается результат выражения a + 2,
после чего этот результат передается функции.
Функция всегда принимает параметром не выражение, а результат вычисления выражения.
Изменение a никак не влияет на сумму, поскольку это две никак не связанные ячейки памяти.
15. Передача параметра, его смена после вызова
Заголовок раздела «15. Передача параметра, его смена после вызова»#include <iostream>
int func(int x){ return x;}
int main(){ int a { 1 }; int b { func(a) }; a = 2;
std::cout << a << std::endl; std::cout << b << std::endl;}Ответ:
В a будет 2, в b будет 1.
На строчке int b { func(a) }; происходит 3 вещи:
- выделяется память для переменной
b; - высчитывается результат выражения
func(a); - результат выражения присваивается к
b.
Результат выражения присваивается к b!
Какой тип у результата выражения func(a)?
Результат выражения берется от выполнения функции,
значит ее возвращаемый тип и есть тип результата выражения.
А ее возвращаемый тип прописан в определении функции — int.
Поскольку у b тоже тип int, результат сможет сохранится туда.
Если бы тип был несовместимый, произошла бы ошибка компиляции.
Что произойдет при вычислении func(a)?
- Создаются локальные переменные для параметров.
В данном случае, создается одна переменная для параметра
x. - В
xзаписывается значение аргумента — результат вычисления выраженияa—1. - Выполнение переходит на первую инструкцию функции
func. - Выполняется
return x, что выставляет результат выражения послеreturnкак результат вызоваfunc. Результат выраженияx(считывание из локальной переменнойx), что есть значение1, становится результатом вызова функции. - Все локальные переменные, созданные при вызове
func, пропадают. В данном случае, пропадает переменнаяx.
Так как в b на строчке int b { func(a) } попадет результат
вызова функции, в b попадает a после всех вышеописанных операций.
16. Тип auto берётся из возвращаемого типа, а не из типа параметра
Заголовок раздела «16. Тип auto берётся из возвращаемого типа, а не из типа параметра»#include <cstdint>#include <iostream>
int func(uint8_t x){ return x;}
int main(){ uint8_t a { 200 }; auto b { func(a) };
std::cout << sizeof(a) << std::endl; std::cout << sizeof(b) << std::endl;}Ответ:
Программа скомпилируется.
В a будет 200, в b будет 200.
Но типы у них разные: у a — uint8_t, а у b — int.
Поэтому напечатается 1, а затем 4 (второй размер — это sizeof(int), обычно 4).
auto выводит тип из результата выражения, а результат func(a) имеет тип
возвращаемого значения функции — int.
Тип параметра (uint8_t) и тип аргумента (uint8_t) на это не влияют.
Какой тип у результата выражения func(a)?
Результат выражения берется от выполнения функции,
значит ее возвращаемый тип и есть тип результата выражения.
А ее возвращаемый тип прописан в определении функции — int.
Поэтому у b, объявленной через auto, тоже тип int.
Что произойдет при вычислении func(a)?
- Создаются локальные переменные для параметров.
В данном случае, создается одна переменная для параметра
xтипаuint8_t. - В
xзаписывается значение аргумента — результат вычисления выраженияa—200. - Выполнение переходит на первую инструкцию функции
func. - Выполняется
return x, что выставляет результат выражения послеreturnкак результат вызоваfunc. Значение200изuint8_t-переменнойxнеявно преобразуется кint, поскольку возвращаемый тип функции —int. Именно это значение типаintстановится результатом вызова функции. - Все локальные переменные, созданные при вызове
func, пропадают. В данном случае, пропадает переменнаяx.
Так как в b на строчке auto b { func(a) } попадет результат
вызова функции, в b попадает 200 типа int.
17. Реальный пример: вектор
Заголовок раздела «17. Реальный пример: вектор»#include <iostream>
struct Vector{ int x; int y;};
Vector multiply(Vector pos, int scalar){ Vector result; result.x = pos.x * scalar; result.y = pos.y * scalar; return result;}
int main(){ Vector v { 2, 3 }; Vector v2 { multiply(v, 2) };
std::cout << v2.x << std::endl; std::cout << v2.y << std::endl;}Сработает ли, если тип у v2 заменить с Vector на int
Имеется ввиду подобный код main:
int main(){ Vector v { 2, 3 }; int v2 { multiply(v, 2) };
std::cout << v2 << std::endl;}Ответ
Не скомпилируется, потому что тип выражения
(тип результата выражение — то же самое)
multiply(v, 2) это Vector, а int нельзя создать из Vector.
18. Приготовление рыбы: изменение входных данных и возврат значения
Заголовок раздела «18. Приготовление рыбы: изменение входных данных и возврат значения»Считайте, что указатель на костёр действителен и топлива достаточно.
#include <iostream>
struct Fire{ int fuel;};
struct RawFish{ int weight; int fuelRequired;};
struct CookedFish{ int weight;};
CookedFish cookFish(Fire* fire, RawFish fish){ fire->fuel -= fish.fuelRequired; return CookedFish{ fish.weight };}
int main(){ Fire fire{ 10 }; RawFish fish{ 100, 3 }; CookedFish cooked{ cookFish(&fire, fish) }; std::cout << fire.fuel << std::endl; std::cout << fish.weight << std::endl; std::cout << cooked.weight << std::endl;}Ответ
Печатает 7, 100 и 100.
Указатель позволяет функции расходовать топливо в переменной fire вызывающего кода.
Сырая рыба передаётся по значению, а результат — новое значение типа CookedFish, возвращаемый по значению.
У исходной переменной сырой рыбы по-прежнему вес 100.
19. Продвинутый уровень: данных в неинициализированных переменных
Заголовок раздела «19. Продвинутый уровень: данных в неинициализированных переменных»void f(){ int a; std::cout << a << std::endl; a = 2;}
void g(){ int b{ 1 }; std::cout << b << std::endl;}
int main(){ g(); f(); f();}Ответ
Если не давать флаги -Wall и -Werror при компиляции, это скомпилируется.
Но не забывайте, что чтение неинициализированных переменных — это UB!
При чтении неинициализированной переменной a в f,
получите то, что было в этой ячейке памяти до этого.
А до этого был вызван g, которому была выделена эта ячейка памяти под переменную b.
Поэтому, неинициализированная a будет иметь последнее значение b,
когда она еще существовала, оставшееся в выделенной ей памяти.
Аналогичная ситуация и при вызове f во второй раз:
в a будет то, что было в этой ячейке до этого.
А до этого, там было 2, записанное при выполнении предыдущей f.
112