1. Программный пример перегрузки функций
// demoOverload.cpp : Defines the entry point for the console application.
//
// Перегрузим функцию трижды.
#include "stdafx.h"
#include <iostream>
using namespace std;
#include <conio.h>
void f(int i); //параметр типа int
void f(int i, int j); //два параметра типа int <
void f(double k) ; //один параметр типа double
int main()
{
f(10) ; // вызов f(int) I
f(10, 20); // вызов f(int, int)
f(12.23); // вызов f(double)
_getch();
return 0;
}
void f (int i)
{
cout << "B f(int) i equal " << i << '\n';
}
void f(int i, int j)
{
cout << "B f(int, int) i equal " << i;
cout << " , j equal " << j << '\n' ;
}
void f (double k)
{
cout << "B f(double) k equal " << k << '\n';
}
Эта программа выведет на экран следующее:
Итак, f( ) перегружена трижды. Первый вариант требует один целочисленный параметр, второй вариант требует два целочисленных параметра, и третий вариант требует один параметр типа double. Из-за того, что списки параметров каждой функции различаются, компилятор имеет возможность выбрать требуемый вариант функции исходя из типа аргументов, указанных при вызове функции.
2. Программный пример перегрузки функций
Для того, чтобы осознать ценность перегрузки функций, рассмотрим функцию, названную neg(), которая возвращает отрицание своего аргумента. Например, при вызове с числом -10 функция возвращает 10. При вызове с числом 9 функция возвращает -9. Не имея средства перегрузки функций, вы должны были бы для данных с типами int, double и long разработать три отдельные функции с различающимися именами, например, ineg( ), fneg( ) и lneg( ). Благодаря перегрузке вы можете для всех функций, возвращающих отрицание своего аргумента, использовать одно имя, например, neg( ). Таким образом, перегрузка поддерживает концепцию полиморфизма "один интерфейс, много методов". Приведенная ниже программа демонстрирует эту концепцию:
// demoOverLoad2.cpp : Defines the entry point for the console application.
//
// Создание различных вариантов функции neg ().
#include "stdafx.h"
#include <iostream>
using namespace std;
#include <conio.h>
int neg(int n); // neg() для int.
double neg(double n) ; // neg () для double,
long neg (long n) ; // neg () для long.
int main () {
cout << "neg(-10): " << neg(-10) << "\n";
cout << "neg(9L): " << neg(9L) << "\n";
cout << "neg(11.23): " << neg(11.23) << "\n";
getch();
return 0;
}
// neg()для int.
int neg(int n) { return -n; }
// neg()для double,
double neg(double n) { return -n; }
// neg()для long.
long neg(long n) { return -n; }
Результат выполнения программы имеет вид:
В программе предусмотрены три схожие, но все же разные функции с именем neg, каждая из которых возвращает обратное значение своего аргумента. Компилятор определяет, какую функцию вызывать в каждой ситуации, по типу аргумента вызова.
Ценность перегрузки заключается в том, что она позволяет обращаться к набору функций с помощью одного имени. В результате имя neg описывает обобщенное действие. Обязанность выбрать конкретный вариант для конкретной ситуации возлагается на компилятор. Вам, программисту, нужно только запомнить имя обобщенного действия. Таким образом, благодаря применению полиморфизма число объектов, о которых надо помнить, сокращается с трех до одного. Хотя приведенный пример крайне прост, вы можете, развив эту концепцию, представить, как перегрузка помогает справляться с возрастающей сложностью.