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

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

же алгоритм для различных типов данных, имели одно и то

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

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

resolution в смысле «уточнение»).
Тип возвращаемого функцией значения в разрешении не участвует.

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

int); // Возвращает наибольшее из двух целых
char* max(char*, char*); /*

Возвращает подстроку наибольшей длины */
int max (int, char*); /* Возвращает наибольшее из первого параметра и длины второго */
int max (char*, int); /* Возвращает наибольшее из второго параметра и длины первого */

void f(int a, int b, char* c, char* d){
cout << max (a, b) << max(c, d) << max(a, c) << max(c, b);
}

параметров вариант функции.
в приведенном примере будут последовательно вызваны все

четыре варианта функции.

получено более чем одним способом, вызов считается неоднозначным и выдается

сообщение об ошибке.

умолчанию.

"function float f(float i)"

"function double f(double i)" << endl;
return i*2;
}
int main(){
float x = 10.09;
double y = 10.09;
cout << f(x) << endl; // Вызывается f(float)
cout << f(y) << endl; // Вызывается f(double)
cout « f(10) « endl;
/*Неоднозначность - как преобразовать 10: во float или double? */
return 0;
}

Для устранения этой неоднозначности требуется явное приведение типа для константы 10.

между вызовом функции, которая получает параметр по значению, и вызовом

функции, которая получает параметр по ссылке.

если одна из перегружаемых функций объявлена как
int f(int a, int b),
а другая — как
int f (int a, int &b),
то компилятор не сможет узнать, какая из этих функций вызывается

a;}
int f(int a, int b = 1){return a * b;}
int

main(){
cout << f(10,2); // Вызывается f(int, int)
cout << f(10); /* Неоднозначность - что вызывается: f(int, int) или f(int) ? */
return 0;
}

Перегрузка функций.

видимости, иначе произойдет сокрытие аналогично одинаковым именам переменных во вложенных

блоках.
Перегруженные функции могут иметь параметры по умолчанию, при этом значения одного и того же параметра в разных функциях должны совпадать. В различных вариантах перегруженных функций может быть различное количество параметров по умолчанию.
Функции не могут быть перегружены, если описание их параметров отличается только модификатором const или использованием ссылки (например, int и const int или int и int&).

они работают.
классический пример — сортировка.
Естественно, возникает желание, параметризовать алгоритм

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

о типе в качестве параметра
например, одним параметром в функцию передается

указатель на данные, а другим — длина элемента данных в байтах

Использование дополнительного параметра означает генерацию дополнительного кода, что снижает эффективность программы

особенно при рекурсивных вызовах и вызовах во внутренних циклах

Кроме того, отсутствует возможность контроля типов

данных нескольких перегруженных функций
Но в таком случае в программе будет

несколько одинаковых по логике функций, и для каждого нового типа придется вводить новую

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

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

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

простейшей функции-шаблона:
Вместо слова Туре может использоваться произвольное имя.
В общем случае

шаблон функции может содержать несколько параметров, каждый из которых может быть не только типом, но и просто переменной, например:
template void f(){ ... }

типа, в виде шаблона может выглядеть так:
template
void sort_vybor(Type

*b, int n){
Type а; //буферная переменная для обмена элементов
for (int i = 0; i int imin = I;
for (int j = i + 1; j if (b[j] < b[imin]) imin = j;
а = b[i]; b[i] = b[imin]; b[imin] = a;
}
}

template void sort_vybor(Type *b, int n);
int main(){
const int

n = 20;
int i, b[n];
for (i = 0; i> b[i];
sort_vybor(b, n); // Сортировка целочисленного массива
for (i = 0; i cout << endl;
double a[] = {0.22, 117, -0.08, 0.21, 42.5};
sort_vybor(a, 5); // Сортировка массива вещественных чисел
for (i = 0; i<5; i++) cout << a[i] << ' ';
return 0;
}

приводит к созданию компилятором кода для соответствующей версии функции.
Этот

процесс называется инстанцированием шаблона (instantiation).
Конкретный тип для инстанцирования либо определяется компилятором автоматически, исходя из типов параметров при вызове функции, либо задается явным образом.
При повторном вызове с тем же типом данных код заново не генерируется.

На месте параметра шаблона, являющегося не типом, а переменной, должно указываться константное выражение.

Y, class Z> void f(Y, Z);
void g(){
f("Vasia", 3.0);
f

char*>("Vasia". 3.0);
// Z определяется как double
f("Vasia", 3.0);
// Y определяется как char*, a Z - как double
// f("Vasia", 3.0); ошибка: Х определить невозможно
}

или классу), требуется перегрузить операции для этого типа данных, используемые

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

Можно предусмотреть специальную обработку отдельных параметров и типов с помощью
специализации шаблона функции.

для целых чисел.
В этом случае можно «вручную» задать вариант шаблона

функции для работы с целыми числами :

void sort_vibor (int *b, int n){
... // Тело специализированного варианта функции
}

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

не считается специализацией шаблона,
несмотря на то, что может иметь то же имя и тип возвращаемого значения.

main.

Функция main()

и принимать параметры из внешнего окружения.
Возвращаемое значение должно быть целого

типа.

*/}
с двумя параметрами:
тип main(int argc, char* argv[]){ /* ... */}

могут быть любыми, но принято использовать argc и argv.
Первый

параметр (argc) определяет количество параметров, передаваемых функции, включая имя самой программы, второй параметр (argv) является указателем на массив указателей типа char*.
Каждый элемент массива содержит указатель на отдельный параметр командной строки, хранящийся в виде С-строки, оканчивающейся нуль-символом.
Первый элемент массива (argv[0]) ссылается на полное имя запускаемого на выполнение файла, следующий (argv[l]) указывает на первый параметр, argv[2] — на второй параметр, и так далее.
Параметр argv[argc] должен быть равен 0.

значение, означающее успешное завершение.
Ненулевое значение означает аварийное завершение.
Оператор возврата

из main() можно опускать.

из командной строки:
D:\BC\ MAIN.EXE
one
two
three
#include
void main(int argc, char* argv[]){
for (int

i = 0; i}

d:\BC\main.exe one two three

На экран будет выведено: