Функции и указатели

Функции в C++ объявляются так:

<Тип возвращаемого объекта> <Название функции>(<Тип аргумента1> <Имя аргумента1>, <Тип аргумента2> <Имя аргумента2> ...){
	<Блок инструкции>
	return <Значение>; // Тип значения должен совпадать с "типом возвращаемого значения"
}

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

void printValue(int a){
	cout << a << endl;
	
	//return void; или return; можно не писать.
} // данная функция выводит на экран значение, передаваемого в качестве аргумента

Вот пример простой фунцкии, которая складывает два числа:

int sum(int a, int b){
	return a + b;
}

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

#include <iostream>

using namespace std;

void swap(int a, int b){
	int c = b;
	b = a;
	a = c;
}

int main(){
	int a = 1;
	int b = 10;
	swap(a, b);
	cout << a << ' ' << b << endl; // выведет 1 и 10, а не 10 и 1, как ожидалось...
	
	return 0;
}

Возникшая проблема объясняется тем, что внутри функции swap() создаютя новые переменные a и b, чьи значения удаляются после завершения работы функции. Для решения данной проблемы существует механизм работы с указателями. Указатель - это номер ячейки памяти, в которой лежит значение данной переменной.
Тип int* обозначает указатель, выражение &<имя переменной> возвращает указатаель на нее (номер ячейки памяти). Если переменная имеет тип int* (или long long* и т.д.), то выражение *<имя переменной> возвращает то, что хранится в данной ячейке.
Вот простой пример:

int a = 9;
int *b = &a; // теперь b - номер ячеки, где зранится a (9)

Теперь напишем правильную реализацию функции swap():

void myswap(int *x, int *y){
    int z = *x;
    *x = *y;
    *y = z;
} // при вызове функции писать нужно так: swap(&a, &b), где a и b - переменные типа int.

То же самое, но более удобным способом можно писать так: (этот метод называется передачей по значению)

void myswap(int &x, int &y){
	int z = x;
	x = y;
	y = z;
} // при вызове надо писать myswap(a, b), где a, b - переменные типа int.

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