Функции в C++

1.

ЯЗЫК ПРОГРАММИРОВАНИЯ C++
Функции
Заголовок и тело функции, их использование.
Классификация параметров.
int sum(int a, int b)
{
return a + b;
}
Простыми словами, с примерами кода

2.

Что такое функция?
Функция — это отдельный кусочек программы, у которого есть имя. Мы описываем его один раз, а пользуемся
сколько угодно раз: пишем имя функции — и код выполняется.
ВХОД
ОБРАБОТКА
Данные, которые мы передаём
функции (аргументы)
→
Функция выполняет свои
команды
ВЫХОД
→
Готовый результат, который
функция возвращает
Аналогия: кофемашина
?
Засыпали зёрна и воду (передали данные) → нажали кнопку (вызвали функцию) → получили кофе (результат). Что
происходит внутри — знать не обязательно, важно только, что даём и что получаем.
01

3.

Зачем нужны функции
1
Не повторять код
2
Написали один раз — используем в любом месте
программы. Нужно что-то поправить — правим в
одном месте.
3
Проще искать ошибки
Если что-то посчиталось неверно, ошибку ищем внутри
одной небольшой функции, а не во всей программе.
Программу легче читать
Вместо 30 строк расчёта — одна понятная строка:
calculatePrice(). Сразу видно, что делает код.
4
Удобно работать вместе
Большую задачу можно разбить на функции и раздать
разным людям — каждый пишет свою часть.
Правило хорошего тона: одна функция — одна задача. Если функция делает сразу пять разных дел, её лучше разделить.
02

4.

Из чего состоит функция
int sum(int a, int b)
{
int s = a + b;
return s;
}
// ЗАГОЛОВОК
// начало тела
// отдаём результат
// конец тела
ЗАГОЛОВОК
Говорит, как функцию зовут, какие данные ей нужны
и что она возвращает.
ТЕЛО
Сами команды: что функция делает. Всегда стоит в
фигурных скобках { }.
Скобки { } обязательны
Тело может быть пустым
Функции не вкладывают
Даже если внутри всего одна строка
кода.
{ } — так делают заготовки функций на
будущее.
Нельзя описать одну функцию внутри
другой.
03

5.

Заголовок функции по частям
double area(double w, double h)
1
Тип результата
2
Имя функции
3
Список параметров
double
area
(double w, double h)
Что функция отдаёт наружу. Если она
ничего не возвращает — пишем void.
По нему функцию вызывают. Имя
лучше делать говорящим: area, sum,
printMenu.
Какие данные нужны функции. Если
данные не нужны — пустые скобки ().
Порядок всегда один: тип → имя → скобки с параметрами. Такой же заголовок, но с точкой с запятой на конце — это уже
объявление (прототип).
04

6.

Тело функции и return
Возвращает значение
Тело — это всё, что стоит между { и }.
Внутри может быть что угодно: расчёты, условия, циклы,
вызовы других функций.
return отдаёт результат и сразу завершает работу
функции.
Если тип функции void, то return можно не писать
вообще.
!
Важно
int square(int x)
{
return x * x;
}
// результат уходит наружу
Ничего не возвращает
void greet()
{
cout << "Привет!" << endl;
// return не нужен
}
Строки после return не выполнятся никогда — функция
уже закончила работу и вернула результат.
05

7.

Пример целиком: как это работает
#include <iostream>
using namespace std;
int sum(int a, int b)
{
return a + b;
}
int main()
{
int r = sum(3, 5);
cout << r;
return 0;
}
1
Программа идёт по main и доходит до
sum(3, 5).
// тело
2
Числа 3 и 5 попадают в параметры a и b.
// вызов функции
// 8
3
Выполняется тело: считается 3 + 5 = 8.
4
return отдаёт 8 обратно в main, и r
становится равным 8.
// заголовок
Вызов функции — это её имя и круглые скобки со значениями: sum(3, 5). Без скобок функция не вызовется.
06

8.

Объявление (прототип) и определение
ОБЪЯВЛЕНИЕ — ТОЛЬКО ЗАГОЛОВОК
int sum(int a, int b);
ОПРЕДЕЛЕНИЕ — ЗАГОЛОВОК И ТЕЛО
int sum(int a, int b)
{
return a + b;
}
Зачем это нужно
Компилятор читает файл сверху вниз. Если вызов стоит раньше самой функции, без прототипа будет
ошибка.
Где что писать
Прототипы кладут наверх файла или в заголовочный файл .h, а определения — ниже или в .cpp.
Маленькая хитрость
В прототипе имена параметров можно не писать: int sum(int, int); — компилятору важны только
типы.
07

9.

Параметры и аргументы — в чём разница
int sum(int a, int b)
// <- параметры
Параметры (формальные) — это имена-«коробочки» в заголовке. Пока функцию не вызвали, они пустые.
3→a
sum(3, 5);
5→b
// <- аргументы
Аргументы (фактические) — реальные значения, которые мы подставляем при вызове.
Параметр живёт только внутри
Аргументом может быть многое
Он создаётся при вызове и исчезает, когда функция закончила
работу.
Число, переменная, выражение и даже вызов другой
функции: sum(x, sum(1, 2)).
08

10.

Классификация параметров
Как данные попадают в функцию?
▼
По значению
int x
Функция получает копию данных.
Оригинал остаётся нетронутым.
▼
По ссылке
▼
По указателю
int& x
Функция работает с самим
оригиналом. Копия не создаётся.
int* x
Функция получает адрес переменной и
работает по адресу.
Параметры делят и по другому признаку: обязательные и со значением по умолчанию (их можно не указывать при вызове). Об
этом — ближе к концу.
09

11.

Передача по значению: int x
void inc(int x)
{
x = x + 1;
}
int main()
{
int a = 5;
inc(a);
cout << a;
return 0;
}
Создаётся копия
// меняем свою копию
Значение переменной копируется в параметр.
Оригинал в безопасности
Что бы ни делали внутри — снаружи ничего не
меняется.
// 5 - не изменилось!
Когда применять
Для простых небольших данных: int, double, char,
bool.
Итог: функция работала со своей копией, поэтому переменная a осталась равна 5.
10

12.

Передача по ссылке: int& x
void inc(int& x)
{
x = x + 1;
}
int main()
{
int a = 5;
inc(a);
cout << a;
return 0;
}
Копии нет
// меняем сам оригинал
Знак & означает: работаем с самой переменной.
Изменения видны снаружи
Это способ вернуть из функции сразу несколько
значений.
// 6 - изменилось
const& для чтения
const string& s — без копии и без права менять.
Быстро и безопасно.
Итог: параметр x — это другое имя той же переменной a, поэтому a стала равна 6.
11

13.

Передача по указателю: int* x
void inc(int* x)
{
if (x == nullptr) return;
*x = *x + 1;
// работаем по адресу
}
int main()
{
int a = 5;
inc(&a);
cout << a;
return 0;
}
Передаём адрес
При вызове пишем &a, а внутри обращаемся через
звёздочку: *x.
Оригинал меняется
Как и со ссылкой, изменения видны снаружи.
// передаём адрес
// 6
Может быть пустым
Указатель бывает nullptr, поэтому его стоит
проверять.
Итог: тот же результат, что и со ссылкой, но запись сложнее. В современном C++ чаще выбирают ссылку.
12

14.

Сравним три способа
Оригинал
меняется?
Копия
создаётся?
Способ
Как пишется
Когда использовать
По значению
int x
Нет
Да
Простые небольшие данные: числа, символы
По ссылке
int& x
Да
Нет
Когда функция должна изменить переменную
По const-ссылке
const string& s
Нет
Нет
Большие данные только для чтения — быстро
По указателю
int* x
Да
Нет
Значения может не быть (nullptr), массивы
Простое правило выбора: нужно только прочитать маленькое значение — по значению; нужно изменить переменную — по
ссылке; данные большие, но менять их не нужно — по const-ссылке.
13

15.

Ещё два полезных приёма
Значения по умолчанию
double price(double p, double disc = 0.1);
price(100);
price(100, 0.25);
// скидка 0.1
// скидка 0.25
Такой параметр можно не указывать при вызове —
подставится заготовленное значение.
Правило: параметры со значением по умолчанию всегда идут в
конце списка.
Перегрузка функций
int
maxOf(int a, int b);
double maxOf(double a, double b);
maxOf(2, 7);
maxOf(2.5, 7.1);
// выберется первая
// выберется вторая
Несколько функций с одним именем, но разными
параметрами. Компилятор сам выберет подходящую по типам
аргументов.
Обе возможности нужны для одного и того же — сделать вызов функции короче и удобнее.
14

16.

Частые ошибки новичков
!
Забыли return в функции, которая должна вернуть значение — результат будет случайным.
!
Ждали, что переменная изменится, но передали её по значению — функция меняла копию.
!
Прототип и определение не совпадают по типам — программа не соберётся.
!
Вернули ссылку или указатель на локальную переменную — после выхода из функции её уже нет.
!
У функции 7-8 параметров — читать и вызывать такую тяжело, лучше объединить данные в структуру.
15

17.

Коротко о главном
✓
Функция состоит из двух частей: заголовка и тела.
✓
Заголовок — это тип результата, имя и список параметров.
✓
Тело — команды в фигурных скобках; return отдаёт результат.
✓
Параметр стоит в заголовке, аргумент подставляется при вызове.
✓
Данные передают по значению (копия), по ссылке (оригинал) или по указателю (адрес).
Пишите маленькие функции с понятными именами — и код будет читаться как обычный текст.