Освой самостоятельно С++ за 21 день.

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

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

В языке C++ предусмотрена возможность создания нескольких функций с одинаковым именем. Это называется перегрузкой функций. Перегруженные функции должны отличаться друг от друга списками параметров: либо типом одного или нескольких параметров, либо различным количеством параметров, либо и тем и другим одновременно. Рассмотрим следующий пример:

int myFunction (int, int); int myFunction (long, long); int myFunction (long);

Функция myFunction перегружена с тремя разными списками параметров. Первая и вторая версии отличаются типами параметров, а третья — их количеством.

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

Перегрузка функций также называется полиморфизмом функций. Поли (гр. poly) означает много, морфе (гр. morphe) — форма, т.е. полиморфическая функция — это функция, отличающаяся многообразием форм.

Под полиморфизмом функции понимают существование в программе нескольких перегруженных версий функции, имеющих разные назначения. Изменяя количество или тип параметров, можно присвоить двум или нескольким функциям одно и то же имя. При этом никакой путаницы при вызове функций не будет, поскольку нужная функция определяется по совпадению используемых параметров. Это позволяет создать функцию, которая сможет, например, усреднять целочисленные значения, значения типа double или значения других типов без необходимости создавать отдельные имена для каждой функции — AverageInts, AverageDoubles и т.д.

Предположим, вы пишете функцию, которая удваивает любое передаваемое ей значение. При этом вы бы хотели иметь возможность передавать ей значения типа int, long, float или double. Без перегрузки функций вам бы пришлось создавать четыре разные функции:

int DoubleInt(int); long DoubleLong(long); float DoubleFloat(float); double DoubleDouble(double);

С помощью перегрузки функций можно использовать следующие объявления:

int Double(int); long Double(long); float Double(float); double Double(double);

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

Листинг 5.8. Полиморфизм функций

1: // Листинг 5.8. Пример

2: // полиморфизма функций

3:

4: #include

5:

6:  int Double(int);

7:  long Double(long);

8:  float Double(float);

9:  double Double(double);

10:

11: int main

12: {

13:    int myInt = 6500;

14:    long myLong = 65000;

15:    float myFloat = 6.5F;

16:    double myDouble = 6.5e20;

17:

18:    int doubledInt;

19:    long doubledLong;

20:    float doubledFloat;

21:    double doubledDouble;

22:

23:    cout  << "myInt: "  << myInt  << "\n";

24:    cout  << "myLong: "  << myLong  << "\n";

25:    cout  << "myFloat: "  << myFloat  << "\n";

26:    cout  << "myDouble: "  << myDouble  << "\n";

27:

28:    doubledInt = Double(myInt);

29:    doubledLong = Double(myLong);

30:    doubledFloat = Double(myFloat);

31:    doubledDouble = Double(myDouble);

32:

33:    cout  << "doubledInt: "  << doubledInt  << "\n";

34:    cout << "doubledLong: " << doubledLong << "\n";

35:    cout  << "doubledFloat: "  << doubledFloat  << "\n";

36:    cout  << "doubledDouble: "  << doubledDouble  << "\n";

37:

38:    return 0;

39: }

40:

41: int Double(int original)

42: {

43:    cout  << "In Double(int)\n";

44:    return 2 * original;

45: }

46:

47: long Double(long original)

48: {

49:    cout  << "In Double(long)\n";

50:    return 2 * original;

51: }

52:

53: float Double(float original)

54: {

55:    cout  << "In Double(float)\n";

56:    return 2 * original;

57: }

58:

59: double Double(double original)

60: {

61:    cout  << "In Double(double)\n";

62:    return 2 * original;

63: }

Результат:

myInt: 6500

myLong: 65000

myFloat: 6.5

myDouble: 6.5e+20

In Double(int)

In Double(long)

In Double(float)

In Double(double)

DoubledInt: 13000

DoubledLong 130000

DoubledFLoat: 13