Джесс Либерти - Освой самостоятельно С++ за 21 день.

• Название: Освой самостоятельно С++ за 21 день.
• Автор: Джесс Либерти
• Жанр: Программирование

В книге широко представлены возможности новейшей версии программного продукта Microsoft Visual C++. Подробно описаны средства и подходы программирования современных профессиональных приложений. Материалы книги дополнены многочисленными демонстрационными программами, в процессе разработки которых максимально используются возможности программных инструментов Microsoft Visual Studio. Особое внимание уделено новинкам версии 6.0 и новейшим технологиям объектно-ориентированного программирования, включая использование библиотеки MFC и шаблонов классов, а также создание связанных списков. Отдельное занятие посвящено вопросам объектно-ориентированного анализа и проектирования приложений. Подробно рассмотрены все средства и подходы конструирования собственных пользовательских классов.

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

---

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

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

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

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

Оператор суммирования

Операторы приращения, рассмотренные выше, оперируют только с одним операндом. Оператор суммирования (+) — это представитель операторов с двумя операндами. Он выполняет операции с двумя объектами. Как выполнить перегрузку оператора суммирования для класса Counter?

Цель состоит в том, чтобы объявить две переменные класса Counter, после чего сложить их, как в следующем примере:

Counter переменная_один, переменная_два, переменная_три; переменная_три= переменная_один + переменная_два;

Начнем работу с записи функции Add(), в которой объект Counter будет выступать аргументом. Эта функция должна сложить два значения, после чего возвратить Counter с полученным результатом. Данный подход показан в листинге 10.13.

Листинг 10.13. Функция Add()

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

2: // Функция Add

3:

4: int

5: #include <iostream.h>

6:

7: class Counter

8: {

9:    public:

10:      Counter();

11:      Counter(int initialValue);

12:      ~Counter(){ }

13:      int GetItsVal()const {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 GetItsVal()const { 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). Также нельзя изменять установленные приоритеты и ассоциативности операторов. Например, нельзя оператор с одним операндом перегрузить так, чтобы использовать его с двумя операндами. Кроме того, методом перегрузки нельзя создавать новые операторы; например, бинарный оператор умножения (**) не удастся объявить как оператор возведения в квадрат.

Количество операндов, которыми может манипулировать оператор, — важная характеристика каждого оператора. Различают операторы, используемые с одним операндом (например, оператор инкремента: myValue++), и операторы, для работы которых необходимо указать два операнда (например, оператор суммирования: a+b). Сразу тремя операндами управляет только условный оператор ?, синтаксис использования которого показан в следующем примере: (а > b ? x : у).

Что можно перегружать

Возможность перегрузки операторов — это то новое средство программирования, предоставляемое C++, которое наиболее широко используют (а часто и злоупотребляют им) начинающие программисты. Новичков захватывает азарт присвоения новых интересных функций самым обычным и заурядным операторам. В результате код программы может оказаться непонятным и нечитабельным даже для создателя, а не то что для другого программиста.

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