Функции в языке С++ презентация

места программы.
Функции в С/С++ определяются именем функции, принимаемыми аргументами и возвращаемым значением.
Прямая аналогия - функции в математике.
y = f(x)
f: X -> Y
где: f - имя функции,
x - аргумент,
y - возвращаемое значение

<значение функции>;
}

На примере функции возведения в степень:
double mpow(const double x, int n) {
int result = x;
while (--n != 0) {
result*=x;
}
return result;
}
//в коде можно уже будет просто обратиться к функции
double y = mpow(2, 5); //y = 32

Благодаря механизму неявного приведения типов в С++, аргументами такой функции могут стать и переменные других типов. Возвращаемое значение так же может записаться в переменную другого типа, если компилятор сможет выполнить преобразование.
Но за всем этим лучше следить самому, иногда неявные преобразования могут привести к непредсказуемым результатам:
char y = mpow(2,9); //выполнится без ошибок, но результат будет достаточно странным

не вернет (вернется "пустышка" void).
В таких функция можно не писать return.

void printArray(int* arr, const int sizeArr) {
for (int i = 0; i < sizeArr; ++i) {
std::cout << arr[i] << " ";
}
std::cout << endl;
//return;
}

код функции надо напрямую вставлять в место вызова.
Может не сработать, если компилятор посчитает, что это не нужно ¯\_(ツ)_/¯.
Редко встречаются, разве что в специфических задачах, требующих огромной скорости работы.

inline double mAbs(const double value) {
return value >= 0 ? value : -value;
}
...
int a = mAbs(-6);

Компилятор будет в итоге работать с таким кодом:
int a = return -6 >= 0 ? value : -value;

гарантируется, что к началу работы функции они будут вычислены.

printf("%d %d %d \n", i, ++i + ++i, i);

Такая ситуация называется неопреленным поведением (Undefined Behavior).

аргумента, следовательно, ЛОКАЛЬНЫМ переменным-аргументам просто присваиваются переданные значения.
Сами передаваемые в момент вызова функции переменные НЕ ИЗМЕНЯТСЯ.

void sum2(double a, const double b) { //a = 5.5, b = 4.2
a+=b; //a = 9.7
}
...
double a = 5.5, b = 4.2;
sum2(a, b); //a = 5.5, b = 4.2

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

void sum2(double &a, const double &b) { //a = 5.5, b = 4.2
a+=b; //a = 9.7
b = 0;
}
...
double a = 5.5, b = 4.2;
sum2(a, b); //a = 9.7, b = 0

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

double sumArray(double *arr, int n) {
sum = 0;
for (int i = 0; i < n; ++i) {
sum+=arr[i];
}
return sum;
}
...
double staticArray[5] = {0, 1, 2, 3, 4};
double firstSum = sumArray(staticArray, 5); //array - указатель на первый элемент массива
double *dynamicArray = new int[5];
... //заполнение массива
double secondSum = sumArray(dynamicArray, 5);

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

Пример рекурсивной функции (бинарный поиск):

int binarySearch(int *arr, int elem, int left, int right) {
int med = (left + right) / 2;
if (arr[med] == elem) {
return med;
}
if (med == left || med == right) {
return -1;
}
if (arr[med] > elem) {
binarySearch(arr, elem, 0, med);
}
else {
binarySearch(arr, elem, med + 1, right);
}
}

к верхнему регистру

Задача 3 (*)
Реализовать функцию сортировки массива методом быстрой сортировки (quicksort)