Функции в C++ для начинающих. Перегрузка функций
- Для понимания этой темы нужно знать:
- Знакомство с функциями
В С++ существует понятие Перегрузка функций.
- Перегрузка функций — это механизм, который позволяет двум родственным функциям иметь одинаковые имена.
Благодаря возможностям языка С++ программисты, пишущие на этом языке собственные функции, могут давать функциям одинаковые названия.
Простейший вариант, показывающий, что это значит, можно посмотреть на примере функции сложения двух чисел:
|
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 |
//Borland C++ 3.1 Перегрузка функций Листинг #1 #include <iostream.h> #include <iostream> using namespace std; //Функция sum void sum(int , int ){ cout << "int, int" << '\n'; } //Функция sum void sum(double , int ){ cout << "double, int" << '\n'; } //Функция sum void sum(double, double){ cout << "double, double" << '\n'; } //Функция main int main() { double a, b; //переменные, уходящие в функцию int c,d; /*ВЫЗОВЫ ФУНКЦИЙ*/ sum(a,b); //double, double sum(a,c); //double, int sum(c,d); //int, int /*КОНЕЦ ВЫЗОВОВ ФУНКЦИЙ*/ cin.get(); } |
При наличии нескольких функций с одинаковыми названиями компилятор С++ может выбирать наиболее совместимую, ориентируясь на уходящие вовнуть функции аргументы. Этот эффект называется перегрузкой функций. Компилятор ориентируется на количество аргументов и на типы каждого уходящего аргумента.
В листинге #1 у нас 3 функции с одинаковым названием sum, а внутри функции main происходит вызов каждой из них. В зависимости от используемых аргументов, срабатывает та функция, которая больше всех подходит.
- Перегрузка функций избавляет вас от необходимости выдумывать разные названия функциям, решающим схожие по смыслу задачи.
Примером возникновения ситуации, когда может понадобиться перегрузка функций, может оказаться пример написания программы, обрабатывающей массивы:
|
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61 62 63 64 65 66 67 68 69 70 71 72 73 74 75 76 77 78 79 80 81 82 83 84 |
//Borland C++ 3.1 Пример полезности перегрузки функций Листинг #2 #include <iostream> using namespace std; /*ФУНКЦИИ, ЧИСТЯЩИЕ ПАМЯТЬ*/ void delete_array(int* &arr, const int N){ delete []arr; } void delete_array(int** &arr, const int ROW, const int COL){ for (int i=0; i<ROW; i++) delete []arr[i]; delete []arr; } /*КОНЕЦ ФУНКЦИЙ, ЧИСТЯЩИХ ПАМЯТЬ*/ //========================================================== /*ФУНКЦИИ, ВЫВОДЯЩИЕ МАССИВЫ НА ЭКРАН*/ void print(int* arr, const int N){ for (unsigned i=0; i<N; i++) cout << arr[i] << ' '; cout << '\n'; } void print(int** arr, const int N, const int M){ for (int i=0; i<N; i++){ for (int j=0; j<M; j++){ cout << arr[i][j] << '\t'; } cout << '\n'; } } /*КОНЕЦ ФУНКЦИЙ, ВЫВОДЯЩИХ МАССИВ НА ЭКРАН*/ //========================================================== //========================================================== /*ФУНКЦИИ, ЗАПОЛНЯЮЩАЯ МАССИВЫ ПЕРВИЧНЫМИ ЗНАЧЕНИЯМИ*/ void fill_array(int* arr, const int N){ for (int i=0; i<N; i++) arr[i] = i+1; } void fill_array(int** arr, const int ROW, const int COL){ unsigned count = 1; for (int i=0; i<ROW; i++){ for (int j=0; j<COL; j++){ arr[i][j] = count++; } } } /*КОНЕЦ ФУНКЦИЙ, ЗАПОЛНЯЮЩИХ МАССИВЫ*/ /*ФУНКЦИИ, ВЫДЕЛЯЮЩИЕ ПАМЯТЬ МАССИВАМ*/ void init(int* &arr, const int N){ arr = new int [N]; } void init(int** &arr, const int ROW, const int COL){ arr = new int* [ROW]; for (int i=0; i<ROW; i++){ arr[i] = new int[COL]; } } /*КОНЕЦ ФУНКЦИЙ, ВЫДЕЛЯЮЩИХ ПАМЯТЬ МАССИВАМ*/ int main(){ const int N = 5; const int ROW = 6, COL = 7; int *arr1; //Указатель на одномерный массив int **arr2; //Указатель на двумерный массив init(arr1,N); //Выделяем массиву память fill_array(arr1,N); //Заполняем массив print(arr1,N); //Печатаем массив на экран delete_array(arr1,N); //Освобождаем память cout << '\n'; init(arr2,ROW,COL); //Выделяем массиву память fill_array(arr2,ROW,COL); //Заполняем массив print(arr2,ROW,COL); //Печатаем массив на экран delete_array(arr2,ROW, COL); //Освобождаем память cin.get(); } |
Мы бы могли использовать 8 названий: 4 для одномерного массива (инициализация, заполнение, вывод, очистка) и 4 для двумерного, но вместо 8 названий мы используем только 4 хорошо говорящих названия.
Благодаря тому, что функциям в С++ можно давать одинаковые имена, нам позволительно использовать одно и то же название для разных функций. В листинге #2 эта возможность активно применяется. Это всё способствует облегчению использования написанных кем-то функций.
Для схожих задач, которые можно именовать одним названием в то время, когда решение этих задач должно быть описано по-разному, — используется перегрузка функций.
Перегрузка функций в С++ срабатывает тогда, когда или количество параметров у перегружаемых функций различно, или когда типы, задаваемые в списке параметров, различаются. В случае одинакового числа параметров типы параметров у перегружаемых функций должны различаться.
Если и количество параметров совпадает, и число этих параметров в двух функциях одинаково, то тогда считается, что это просто дублирование функции. Такой дубль не имеет смысла, и компилятор не даст вам запустить код. Если бы такой код можно было собрать, то компилятор бы просто не знал, какую из функций следовало бы выбрать. Это вам должно быть понятно на интуитивном уровне:
|
1 2 3 4 5 6 7 |
//Переопределение функции, код не скомпилируется void foo(int x){} //Две функции с одинаковым описанием void foo(int y){} int main(){ } |
В этом показанном коде и число параметров функции одинаково: 1 параметр, — и тип этих параметров совпадает (в обоих случаях int). В таком случае перегрузки не произойдёт. Нужно или изменить тип, или добавить параметров, чтобы получить возможность перегрузки.
- Если тип уходящего в функцию аргумента может быть неявно приведён к типу параметра, принимающего аргумент, то тогда типы параметров могут неполностью совпадать с типами аргументов.
|
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 |
#include <iostream> using namespace std; int foo(int x, int y){ return x + y; } double foo(double x, int y){ //Тип y не double! return x + y; } int main(){ double value1 = 100.3; double value2 = 220.3; //100.3 + 220.3 = 320.6 cout << foo(value1, value2); //НО 320.3 cin.get(); } |
Вследствие того, что в С++ имеют место неявные приведения, из типа аргумента, ушедшего вовнутрь функции, легко выводится тип, заявленный в параметре, принимающем входящий в функцию аргумент, этот код срабатывает, но в вычислении происходит арифметическая ошибка. Вам нужно быть внимательными к неявным преобразованиям. Компилятор выбирает наилучшее соответствие, поэтому написание функции с заведомо правильными типами может легко исправить ситуацию:
|
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 |
#include <iostream> using namespace std; int foo(int x, int y){ return x + y; } double foo(double x, int y){ //Тип y не double! return x + y; } double foo(double x, double y){ //Теперь при обоих аргументах с типом double будет работать эта функция return x+y; } int main(){ double value1 = 100.3; double value2 = 220.3; //100.3 + 220.3 = 320.6 cout << foo(value1, value2); //Теперь всё ОК cin.get(); } |
Всё зависит от типов аргументов, отдаваемых функции, и количества этих аргументов. Компилятор не смотрит на порядок написания, а просто ищет наилучшее соответствие аргументов и типов.
Подводим итоги:
- Перегруженными функциями называют функции, имеющие одинаковые названия.
- Механизм работы, позволяющий описывать разные функции и давать этим разным функциям одинаковое название — называется перегрузкой функций.
- Перегрузка работает только в том случае, если в разных функциях или количество параметров разное, или типы параметров разные. Если количество параметров одинаковое, но типы для них заявлены разные, то тогда перегрузка сработает.
- Какая из перегруженных функций сработает — зависит от типов аргументов, отдаваемых в функцию. Компилятор выбирает наиболее подходящую по типам функцию.
- Если компилятор находит наилучший вариант функции, то эта функция и срабатывает.
- Компилятор может найти несколько одновременно подходящих функций, тогда возникает неоднозначность выбора: компилятор не может выбрать из нескольких, происходит ошибка. Код не компилируется. Ошибка неоднозначности (ambiquous all)
- Компилятор может вообще не найти подходящей функции. Код не компилируется. Ошибка соответствия (no match).
Вам нужно понять, что использование перегрузки функций — это ни что иное, как использование одного названия для описания множества функций. И запомнить, что перегрузка возможна, если параметры отличаются или своим количеством, или завленными для них типами. А ещё зарубить себе на носу, что какая из функций будет срабатывать зависит от соответствия уходящих в функцию аргументов и параметров, принимающих эти аргументы.
5 комментариев на «“Функции в C++ для начинающих. Перегрузка функций”»
Добавить комментарий
Случайная книга в электронном формате
Большое спасибо за доступное изложение материала! 😛
Спасибо!
Код не работает — ошибка: error C2668: ‘sum’ : ambiguous call to overloaded function
насколько я понял, константы 5.0 и 6.0 которые передаются в функции, компилятор определяет как double, а поскольку функии принимающей в параметрах double нет, компилятор пытается преобразовать в другой подходящий тип — int или float, да вот не может выбрать в какой лучше. Если задать хоть один аргумент явно int или float, проблем не будет.
Или опечатка или ошибка — там, где впервые суммируются 100.3 и 220.3 получится 320.3 (220.3 приведется к int=220), а во втором 320.6
Спасибо. Исправил.