В языке C++, как и в подавляющем большинстве других языков программирования, стейтменты объединяются в логические блоки — функции.
Функция — это последовательность стейтментов. Каждая программа, написанная на C++, должна содержать главную функцию main(). Именно с первого стейтмента, находящегося в функции main(), и начинается выполнение всей программы (в нашем случае ф-ция main() находится в движке - Storm Engine).
Функции, как правило, выполняют конкретное задание. Например, функция rand(100) содержит стейтменты, которые генерируют случайное число в заданном диапазоне, а функция GetMainCharacter() возвращает главного персонажа.

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

Тип возврата указывается перед именем функции. Если ф-ция в результате своего выполнения должна вернуть какое-то значение - указываем его тип; если ф-ция ничего не возвращает - пишем void.

Далее нужно придумать имя. Здесь есть некоторые ограничения: имя должно начинаться с буквы или подчеркивания и не может содержать пробелы.
В идеальном случае имя должно четко описывать назначение функции.

Аргументы указываются в круглых скобках после имени. Здесь всё в точности как с переменными - тип и имя. Если аргументов несколько - они перечисляются через запятую. Также аргументов может не быть вовсе - тогда указываются пустые скобки.

И после этого всего в фигурных скобках пишется тело функции - стейтменты, из которых она состоит.
Вот так объявление функции выглядит в коде:

void SomeFunction(int a, int b) {
    // тело ф-ции
}

После того, как мы объявили функцию, можно к ней обратиться. Такое обращение в программировании называется "вызов функции".
Обращение происходит посредством указания имени функции и перечисления передаваемых аргументов в круглых скобках. Если функция не принимает никаких аргументов - скобки всё равно указываются, только пустые.

int x = 2;
int y = 9;

SomeFunction(x, y);

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

int myFunc ()
{
    int a;          // объявляем переменную a
    a = rand(5);    // помещаем в переменную а случайное число от 0 до 5
    return a;       // возвращаем значение а
}

Во втором стейтменте мы помещаем в переменную а результат выполнения ф-ции rand(5). Но для того, чтобы получить результат выполнения, очевидно, необходимо выполнить код этой функции.
Представте, что вы читаете книгу и вспомнили, что должны были сделать телефонный звонок. Вы оставляете закладку в книге, берёте телефон и набираете номер. После окончания разговора вы возвращаетесь к чтению: к той странице, на которой остановились.
То же самое происходит и здесь. Когда процессор доходит до стейтмента вызова функции rand(5) он прекращает выполнение myFunc(), «оставляет закладку» в текущей точке выполнения и переходит к выполнению rand(5). После её выполнения возвращается к закладке и продолжает выполнение myFunc().
Такой процесс называется прерыванием. Функция, в которой находится вызов, называется caller, а функция, которую вызывают — вызываемая функция.

В примере выше мы поместили в переменную а результат выполнения ф-ции rand(5). Так происходит потому, что ф-ция rand(5), в результате своего выполнения, возвращает какое-то значение туда, откуда была вызвана (в caller).

Сама функция myFunc(), из того же примера выше, также возвращает некое значение. Последний её стейтмент return a; это и есть операция возврата.
Но это ещё не всё. Как говорилось в начале урока, если мы хотим, чтобы наша функция возвращала какое-то значение, необходимо указать тип возвращаемых данных при объявлении функции.
Разумеется, тип данных, которые мы пишем после оператора return, должен соответствовать типу, указанному при объявлении, иначе это вызовет ошибку.

Здесь есть и обратная сторона - если функция возвращает какие-то данные, то в её теле обязательно должен присутствовать оператор return.
Сам оператор return прекращает выполнение функции, возвращает данные в caller и точка выполнения также переходит в caller. То есть любой код, написанный после return, выполнен НЕ_будет. Имейте это в виду.

Функция может возвращать только одно значение через return обратно в caller. Это может быть либо число (например, 5), либо значение переменной, либо выражение (у которого есть результат), либо определенное значение из набора возможных значений.
Существуют способы обойти правило возврата одного значения, возвращая сразу несколько значений, но об этом детально мы поговорим на соответствующем уроке.

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

Аргумент функции — это значение, которое передается из caller-а в функцию и которое указывается в скобках при вызове функции.

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

По своей сути аргументы, которые принимает функция - это переменные, действительные только внутри этой функции. При её вызове будут созданы две локальные переменные с именами и типом, указанными при объявлении, и в них будут помещены данные, переданные при вызове.
Рассмотрим пример:

int multiply(int a, int b)
{
    return a * b;
}

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

multiply(2, 4);

В нашем случае оба аргумента - целые числа, но их последовательность все равно важна. Число 2 попадёт в переменную a, а число 4 - в b.
Чтобы понять, почему важна последовательность, представте, что наша ф-ция выполняет не умножение, а деление.