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

6:

7: class Counter

8: {

9: public:

10: Counter;

11: Counter(int initialValue);

12: ~Counter{ }

13: int GetItsValconst {return itsVal; }

14: void SetItsVal(int x) {itsVal = x; }

15: Counter Add(const Counter &);

16:

17: private:

18: int itsVal;

19:

20: };

21:

22: Counter::Counter(int initialValue):

23: itsVal(initialValue)

24: { }

25:

26: Counter::Counter;

27: itsVal(0)

28: { }

29:

30: Counter Counter::Add(const Counter & rhs)

31: {

32: return Counter(itsVal+ rhs.GetItsVal);

33: }

34:

35: int main

36: {

37: Counter varOne(2), varTwo(4), varThree;

38: varThree = varOne.Add(varTwo);

39: cout << "var0ne: " << varOne.GetItsVal<< endl;

40: cout << "varTwo: " << varTwo.GetItsVal << endl;

41: cout << "varThree: " << varThree.GetItsVal << endl;

42:

43: return 0;

44: }

Результат:

varOne: 2

varTwo: 4

varThree: 6

Анализ: Функция Add объявляется в строке 15. В функции задана константная ссылка на Counter, представляющая число, которое нужно добавить к текущему объекту. Функция возвращает объект класса Counter, представляющий собой результат суммирования, который присваивается операнду слева от оператора присваивания (=), как показано в строке 38. Здесь переменная varOne является объектом, varTwo — параметр функции Add, а varThree — адресный операнд, которому присваивается результат суммирования.

Чтобы создать объект varThree без исходной инициализации каким-либо значением, используется конструктор, заданный по умолчанию. Он присваивает объекту varThree нулевое значение, как показано в строках 22—24. Иначе эту проблему можно было решить, присвоив нулевое значение конструктору, определенному в строке 11.

Перегрузка оператора суммирования

Тело функции Add показано в строках 30—33. Программа работает, но несколько замысловато. Перегрузка оператора суммирования (+) сделала бы работу класса Counter более гармоничной (листинг 10.14).

Листинг 10.14. Перегрузка оператора суммирования

1: // Листинг 10.14.

2: //Перегрузка оператора суммирования (+)

3:

4: int

5: #include <iostream.h>

6:

7: class Counter

8: {

9: public:

10: Counter;

11: Counter(int initialValue);

12: ~Counter{ }

13: int GetItsValconst { return itsVal; }

14: void SetItsVal(int x) { itsVal = x; }

15: Counter operator+ (const Counter &);

16: private:

17: int itsVal;

18: };

19:

20: Counter::Counter(int initialValue):

21: itsVal(initialValue)

22: { }

23:

24: Counter::Counter:

25: itsVal(0)

26: { }

27:

28: Counter Counter::operator+ (const Counter & rhs)

29: {

30: return Counter(itsVal + rhs.GetItsVal);

31: }

32:

33: int main

34: {

35: Counter varOne(2), varTwo(4), varThree;

36: varThree = varOne + varTwo;

37: cout << "varOne: " << varOne.GetItsVal<< endl;

38: cout << "varTwo: " << varTwo.GetItsVal << endl;

39: cout << "varThree: " << varThree.GetItsVal << endl;

40:

41: return 0;

42: }

Результат:

varOne: 2

varTwo: 4

varThree: 6

Анализ: В строке 15 объявлен оператор суммирования (operator+), функция которого определяется в строках 28—31. Сравните эту функцию с объявлением и определением функции Add в предыдущем листинге. Они почти идентичны. В то же время далее в программе эти функции используются совершенно по разному. Посмотрите, следующая запись с оператором (+) выглядит естественней и понятнее varThree = varOne + varTwo;

чем строка с функцией Add: varThree = varOne.Add(varTwo);

Для компилятора различия не принципиальные, но программа при этом становится более понятной и читабельной, что облегчает работу программиста.

Примечание:Метод, используемый для перегрузки оператора суммирования (operator++), можно применять также с другими операторами, например, оператором вычитания (operator--).

Перегрузка операторов с двумя операндами

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

Пример перегрузки оператора суммирования для класса Ciuinio-:

Counter Counter::operator+ (const Counter & rhs);

Пример перегрузки оператора вычитания для этого же класса:

Counter Counter::operator- (const Counter & rhs);

Основные принципы перегрузки операторов

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

Ряд операторов могут быть исключительно членами класса. Это операторы присваивания (=), индексирования ([]), вызова функции и косвенного обращения к члену класса (->).

Оператор индексирования [ ] будет рассмотрен на следующем занятии, а оператор косвенного обращения к члену класса — на занятии 14 во время изучения дополнительных возможностей указателей.

Ограничения перегрузки операторов

Нельзя перегружать операторы стандартных типов данных (такие как int). Также нельзя изменять установленные приоритеты и ассоциативности операторов. Например, нельзя оператор с одним операндом перегрузить так, чтобы использовать его с двумя операндами. Кроме того, методом перегрузки нельзя создавать новые операторы; например, бинарный оператор умножения (**) не удастся объявить как оператор возведения в квадрат.