Цели обучения

После завершения этого урока вы сможете:

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

Объявление, вызов и определение функций

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

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

1. Объявление функции

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

   Объявление функции сообщает компилятору три важных аспекта:

   • Тип данных, который функция возвращает (или void, если функция ничего не возвращает).
   • Имя функции.
   • Параметры, которые она принимает (если таковые имеются), а также их типы.

   Общий синтаксис объявления функции:

   tip_vozvrashaemogo_znacheniya imya_funkcii (spisok_parametrov);
   

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

2. Вызов функции

   После объявления функции можно выполнить ее вызов, то есть запустить выполнение ее кода.

   При вызове функции происходит следующее:

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

   Синтаксис вызова функции:

   imya_funkcii(argumenty);
   

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

   Определение функции – это часть, в которой реализуется ее логика. Здесь указываются инструкции, выполняемые при вызове функции.

   Общий синтаксис определения функции:

   tip_vozvrashaemogo_znacheniya imya_funkcii (spisok_parametrov) {
       // Telo funkcii: vypolnyaemye instrukcii
       return znachenie; // (esli funkciya vozvrashaet znachenie)
   }
   

   Каждое определение функции должно соответствовать следующим правилам:

   • Должно совпадать с объявлением (если оно было выполнено ранее).
   • Если функция возвращает значение (например, int), должна присутствовать инструкция return с возвращаемым значением.
   • Если функция не возвращает значение (void), она просто выполняет инструкции и не требует return.

Поток выполнения

Когда программа выполняется, функции вызываются в порядке, определенном в main(). Последовательность выполнения следующая:

1. Компилятор распознает объявление функции.
2. В main() при встрече вызова функции управление передается определению этой функции.
3. Функция выполняет инструкции, содержащиеся в ее теле.
4. Если функция возвращает значение, оно передается в строку, где был выполнен вызов.
5. Управление возвращается в main() или в функцию, вызвавшую данную функцию.

Важность предварительного объявления

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

Существует два основных способа решения этой проблемы:

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

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

Подход: Объявить — Вызвать — Определить

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

1. Объявление: Сообщаем компилятору о существовании функции до ее использования, указывая ее имя, возвращаемый тип и параметры (если они есть).
2. Вызов: Функция вызывается в основном коде (main() в большинстве случаев), выполняя заложенную в ней логику.
3. Определение: Подробно описываем реализацию функции, указывая инструкции, которые она должна выполнять при вызове.

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

Пример: Функция consoladice()

В следующем коде используется последовательность объявить — вызвать — определить:

#include <iostream>
using namespace std;
 
// Snachala obyavlyaem funkciyu
void consoladice();
 
int main() {
    // Vyzyvaem funkciyu
    consoladice();
    return 0;
}
 
// Opredelyaem funkciyu, ranee obyavlennuyu, opisav ee vnutrennyuyu logiku
void consoladice() {
    cout << "Eto prostaya stroka simvolov ili literaly." << endl;
    cout << "Seichas pokazhu chislo pyat. Vot ono: " << 5 << endl;
    cout << "Posmotrim, kakoi rezultat my poluchim esli delim 10 na 5. Rezultat: " << 10/5 << endl;
    cout << "Odin iz tipichnyh sposobov priblizit chislo Pi - eto 22/7. Rezultat: " << 22/7 << endl;
    cout << "V C++ ne odno i to zhe pisat 22/7 i 22.0/7, obrabotka raznaya." << endl;
    cout << "S etim nebolshim izmeneniem mozhno uvidet, chto 22.0/7 raven " << 22.0/7 << endl;
    cout << "Ne schitaesh li ty eto luchshei approksimaciei?" << endl;
}

Ожидаемый вывод этого кода:

Eto prostaya stroka simvolov ili literaly.
Seichas pokazhu chislo pyat. Vot ono: 5
Posmotrim, kakoi rezultat my poluchim esli delim 10 na 5. Rezultat: 2
Odin iz tipichnyh sposobov priblizit chislo Pi - eto 22/7. Rezultat: 3
V C++ ne odno i to zhe pisat 22/7 i 22.0/7, obrabotka raznaya.
S etim nebolshim izmeneniem mozhno uvidet, chto 22.0/7 raven 3.14286
Ne schitaesh li ty eto luchshei approksimaciei?

Чтобы лучше понять метод объявить — вызвать — определить, рассмотрим три ключевые части кода:

1. Строка 5: Объявление функции
   • void consoladice(); сообщает компилятору, что где-то в коде будет функция consoladice().
   • Указывается, что ее возвращаемый тип — void, то есть она не возвращает значение.
   • Хотя реализация consoladice() пока неизвестна, объявление позволяет компилятору распознать ее при использовании в дальнейшем.
2. Строка 9: Вызов функции
   • Внутри main() строка consoladice(); выполняет вызов функции.
   • Компилятор уже знает о существовании consoladice() благодаря объявлению.
   • При вызове функции управление передается ее определению, и выполняется ее содержимое.
3. Строки 14–22: Определение функции
   • Здесь приводится детализированная реализация consoladice().
   • Функция выводит на экран различные сообщения, включая числа и математические вычисления.
   • Важно отметить разницу между 22/7 и 22.0/7. В первом случае оба числа — целые, что приводит к целочисленному делению и результату 3. Однако при использовании 22.0/7 операция выполняется с числами с плавающей запятой, давая результат 3.14286.

Подход: Объявить и реализовать перед вызовом

В C++ помимо метода объявить — вызвать — определить существует еще один способ структурирования функций: объявить и реализовать перед вызовом. Этот подход объединяет объявление и определение функции в одном месте перед ее использованием в main().

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

Общая структура этого метода:

// Opredelyaem funkciyu pered main()
tip_vozvrashaemogo_znacheniya imya_funkcii(spisok_parametrov) {
    // Telo funkcii
    return znachenie; // esli neobhodimo
}
 
int main() {
    // Vyzov funkcii
    imya_funkcii(argumenty);
}

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

Пример: Функция consoladice() без предварительного объявления

Рассмотрим практический пример, где применяется этот метод:

#include <iostream>
using namespace std;
 
// Opredelyaem funkciyu pered vyzovom
void consoladice() {
    cout << "Eto prostaya stroka simvolov ili literaly." << endl;
    cout << "Seichas pokazhu chislo pyat. Vot ono: " << 5 << endl;
    cout << "Posmotrim, kakoi rezultat my poluchim esli delim 10 na 5. Rezultat: " << 10/5 << endl;
    cout << "Odin iz tipichnyh sposobov priblizit chislo Pi - eto 22/7. Rezultat: " << 22/7 << endl;
    cout << "V C++ ne odno i to zhe pisat 22/7 i 22.0/7, obrabotka raznaya." << endl;
    cout << "S etim nebolshim izmeneniem mozhno uvidet, chto 22.0/7 raven " << 22.0/7 << endl;
    cout << "Ne schitaesh li ty eto luchshei approksimaciei?" << endl;
}
 
int main() {
    // Vyzyvaem funkciyu
    consoladice();
    return 0;
}

В этом коде можно заметить следующее:

1. На строках 5–13 объединены объявление и определение

   Функция consoladice() определяется прямо перед main(), без отдельного объявления.

2. На строке 17 функция вызывается внутри main()

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

3. Результат остается таким же

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

✅ Преимущества:

• Более компактный и понятный код в небольших программах.
• Не требует отдельного объявления, что уменьшает количество строк кода.
• Упрощает чтение в небольших скриптах, где все функции находятся в одном файле.

❌ Недостатки:

• В больших программах может затруднить организацию, если перед main() определено много функций.
• Менее удобно при работе с несколькими файлами (.h и .cpp), где предпочтительно держать объявления отдельно.

Передача возвращаемого значения

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

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

Практический пример: Функция, вычисляющая площадь прямоугольника

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

#include <iostream>
using namespace std;
 
// Funkciya vychislyaet ploshchad pryamougolnika i vozvrashaet rezultat
double calculateArea(double base, double height) {
    return base * height;
}
 
int main() {
    double base, height;
     
    // Zaprashivaem u polzovatelya vvod znacheniy
    cout << "Vvedite osnovanie pryamougolnika: ";
    cin >> base;
    cout << "Vvedite vysotu pryamougolnika: ";
    cin >> height;
 
    // Vyzyvaem funkciyu i sohranyaem rezultat
    double area = calculateArea(base, height);
 
    // Vyvodim rezultat
    cout << "Ploshchad pryamougolnika: " << area << endl;
     
    return 0;
}

1. Функция calculateArea() возвращает значение
   • Принимает два значения (base и height) в качестве параметров.
   • Вычисляет площадь с помощью операции умножения base * height.
   • Использует return, чтобы отправить результат операции в вызывающий код.
2. Использование возвращаемого значения в main()
   • Значения base и height вводятся пользователем.
   • Функция calculateArea() вызывается, и ее результат сохраняется в переменной area.
   • Наконец, результат выводится в консоль.
3. Ключевое отличие от функции void

   Если бы calculateArea() была функцией void, нам пришлось бы выводить результат прямо внутри нее, а не передавать его в main() для дальнейшего использования.

Пример: Функция, определяющая, является ли число четным или нечетным

#include <iostream>
using namespace std;
bool isEven(int number) {
    return number % 2 == 0;
}
int main() {
    int number;
    cout << "Vvedite chislo: "; cin >> number;
    if (isEven(number)) {
        cout << "Chislo chetnoe." << endl;
    } else {
        cout << "Chislo nechetnoe." << endl;
    }
    return 0;
}

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

Рекурсия: Функции, вызывающие сами себя

Рекурсия — это техника, при которой функция вызывает саму себя для решения задачи, разбивая её на более мелкие подзадачи. Она особенно полезна в алгоритмах, таких как вычисление факториала, последовательность Фибоначчи и обход структур данных, например деревьев.

Пример: Факториал числа

Факториал числа n определяется как n!=n\cdot(n-1)\cdot(n-2) \cdots 3 \cdot2 \cdot 1. Эта формулировка имеет рекурсивную структуру, которую можно выразить математически следующим образом:

\begin{array}{rl} 0! &=1\\ n! &= n\cdot(n-1)!\\ \end{array}

Учитывая это, мы можем реализовать данную функцию на C++ следующим образом:

#include <iostream>
using namespace std;
 
int factorial(int n) {
    if (n == 0 || n == 1) {
        return 1;
    }
    return n*factorial(n - 1);
}
 
int main() {
    int numero;
    cout << "Vvedite chislo: "; cin >> numero;
    cout << "Faktorial chisla " << numero << " ravno " << factorial(numero) << endl;
    return 0;
}

В этом коде:

• Функция factorial(n) вызывает саму себя с n-1 до тех пор, пока не достигнет базового случая (n == 0 или n == 1).
• Функция вычисляется рекурсивно, перемножая значения до получения результата.

Пример: Числа Фибоначчи

Числа Фибоначчи представляют собой последовательность 1, 1, 2, 3, 5, 8, 13, \cdots. Эта последовательность характеризуется тем, что каждое число является суммой двух предыдущих.

Математически, если fibo(n) — это функция, вычисляющая числа Фибоначчи, то она имеет следующую структуру:

\begin{array}{rl} fibo(0) &= 1\\ fibo(1) &= 1 \\ fibo(n) &= fibo(n-1) + fibo(n-2) \end{array}

Пример кода на C++, который вычисляет числа Фибоначчи:

#include<iostream>
 
using namespace std;
 
int fibo(int numero){
    if (numero==0||numero==1){
        return 1;
    }
    return fibo(numero-1)+fibo(numero-2);
}
 
int main(){
    int x=0, i=0;
    cout << "Vvedite chislo: "; cin >> x;
     
    while (i < x){
        cout <<"Chislo Fibonachchi na pozicii " << i+1 << " ravno: " << fibo(i) << endl;
        i=i+1;
    }   
}

Множественный возврат значений в функциях

В C++ функция может возвращать более одного значения, используя структуры, такие как std::pair, std::tuple или ссылки на переменные.

Пример: Функция, возвращающая два значения с std::pair

#include <iostream>
#include <utility> // Dlya ispolzovaniya std::pair
using namespace std;
  
pair<int, int> divide(int a, int b) {
    return make_pair(a / b, a % b);
}
  
int main() {
    int numerator = 0, denominator = 1;
      
    cout << "Vvedite chislo (chislitel): "; cin >> numerator;
    cout << "Vvedite chislo (znamenatel): "; cin >> denominator;
      
    pair<int, int> result = divide(numerator, denominator);
  
    cout << "Chastnoe: " << result.first << endl;
    cout << "Ostatok: " << result.second << endl;
  
    return 0;
}

Здесь функция divide() возвращает два значения: частное и остаток от целочисленного деления.

Пример: Функция, возвращающая три значения с std::tuple

#include <iostream>
#include <tuple>
using namespace std;
tuple<int, int, int> operations(int a, int b) {
    return make_tuple(a + b, a - b, a * b);
}
int main() {
    int sum=0, difference=0, product=0;
    int a=0, b=0;
    
    cout << "Vvedite chislo: "; cin >> a;
    
    cout << "Vvedite eshche odno chislo: "; cin >> b;
    
    std::tie(sum, difference, product) = operations(a, b);
    cout << "Summa: " << sum << ", Raznost: " << difference << ", Proizvedenie: " << product << endl;
    return 0;
}

Перегрузка функций (overloading)

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

#include <iostream>
#include <string> // Dlya ispolzovaniya std::string
#include <cmath>
 
using namespace std;
 
// Ploshchad kvadrata ili kruga (figury s odnim parametrom)
double area(double side) {
    return side * side;
}
 
// Ploshchad pryamougolnika (figury s dvumya parametrami)
double area(double base, double height) {
    return base * height;
}
 
// Ploshchad treugolnika (figury s tremya parametrami)
double area(double a, double b, double c){
    return 0.25 * sqrt((a+b+c) * (a+b-c) * (a-b+c) * (-a+b+c));
}
 
int main() {
    string shape;
    double result = 0;
    double l1=0, l2=0, l3=0;
 
    // Zapros figury
    cout << "Kakaya figura? (kvadrat, krug, pryamougolnik ili treugolnik): ";
    cin >> shape;
 
    // Proverka figury cherez if-else
    if (shape == "kvadrat") {
        cout << "Kakova dlinna storony? "; cin >> l1;
        result = area(l1);
        cout << "Ploshchad kvadrata: " << result << endl;
    } 
    else if (shape == "pryamougolnik"){
        cout << "Kakova dlinna osnovania? "; cin >> l1;
        cout << "Kakova vysota? "; cin >> l2;
        result = area(l1, l2);
        cout << "Ploshchad pryamougolnika: " << result << endl;
    } 
    else if (shape == "krug") {
        l1 = 3.141592653;
        cout << "Kakova dlinna radiusa? "; cin >> l2;
        result = area(l1, l2);
        cout << "Ploshchad kruga: " << result << endl;
    } 
    else if (shape == "treugolnik"){
        cout << "Kakova dlinna ego storon?" << endl;
        cout << "storona 1: "; cin >> l1;
        cout << "storona 2: "; cin >> l2;
        cout << "storona 3: "; cin >> l3;
             
        if ((l1+l2+l3) * (l1+l2-l3) * (l1-l2+l3) * (-l1+l2+l3) < 0){
            cout << "Treugolnik nevozmozhen";
        }   
        else {
            result = area(l1, l2, l3);
            cout << "Ploshchad treugolnika: " << result << endl;
        }           
    }
    else {
        cout << "Figura ne yavlyaetsya dopustimoi." << endl;
    }
    return 0;
}

Inline-функции в C++

Функции inline в C++ позволяют оптимизировать производительность программы, уменьшая затраты на вызовы функций. Вместо выполнения традиционного вызова компилятор пытается вставить код функции непосредственно в каждое место, где она вызывается.

Синтаксис inline-функции

inline tip_vozvrashaemogo_znacheniya imya_funkcii(spisok_parametrov) {
    // Telo funkcii
    return znachenie; // Esli neobhodimo
}

Использование inline устраняет необходимость выполнения перехода к другому адресу памяти, что может уменьшить время выполнения.

Различия между inline-функцией и обычной функцией

Пример inline-функции

#include <iostream>
using namespace std;
inline int square(int x) {
    return x * x;
}
int main() {
    cout << "Kvadrat chisla 5: " << square(5) << endl;
    return 0;
}

🔍 Работа компилятора:

1. Компилятор заменяет вызов square(5) непосредственно на 5 * 5.
2. Нет необходимости выполнять переход к коду функции.
3. Вычисление производится непосредственно в месте вызова.

Преимущества и недостатки inline

✅ Преимущества

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

❌ Недостатки

• Увеличение размера бинарного файла: если inline-функция используется часто, ее код дублируется в каждом месте вызова.
• Компилятор может проигнорировать inline: если он сочтет, что это неэффективно.