Перегрузка стандартных операций. Операция-функция — компонент класса

   
На этом шаге мы рассмотрим второй способ перегрузки стандартных операций: описание
операции-функции как компонента класса.

   
Вторую возможность перегрузки бинарной операции представляют компонентные функции классов.
Любая стандартная бинарная операция "@" может быть перегружена с помощью нестатической операции-функции,
входящей в число компонентов класса. В этом случае у нее должен быть только один
параметр и заголовок может выглядеть так:

    Т operator @ (Т х)

(здесь T - определенный пользователем тип, т.е. класс). В этом случае выражение
A @ B с объектами A, В класса T в качестве операндов интерпретируется как
вызов функции

 
   A.operator @ (В), 

причем в теле операции-функции выполняется обработка компонентов объекта-параметра B
и того объекта A, для которого осуществлен вызов. При необходимости принадлежность компонентов
объекту A в теле операции-функции можно сделать явным с помощью указателя this.

   
Проиллюстрируем особенности расширения действия бинарной операции с помощью компонентной функции.
Введем операцию "+" для символов "*" на экране дисплея, определяемых классом point.
Для краткости упростим определение класса point, оставив только самые
необходимые компоненты, но дополнительно введем операцию-функцию, расширяющую действие
бинарной операции "+":

//OOP17_1.СРР  -  компонентная функция для перегрузки
//операции "+".
#include <iostream.h>
#include <conio.h>   //Для функции gotoxy();
class point1 // Символ на экране
{ // Защищенные компоненты (данные) класса:
  protected:
    int x, y; // Координаты символа.
    char s;   //Символ.
  // Общедоступные принадлежащие классу функции:
  public:
   point1 (int xi = 0, int yi = 0, char si='*') // Конструктор.
     { x = xi; y = yi; s = si;}
   // Изобразить символ на экране:
   void show(void) { gotoxy(x,y); cout << s; };
   // Прототип компонентной операции-функции:
   point1 operator + (point1& p);
};
// Внешнее определение компонентной операции-функции:
point1 point1::operator + (point1 &p)
{ point1 d;
  d.x = this->x + p.x;
  d.y = this->y + p.y;
  d.s = '+'; //Изменение символа.
  return d;
}

void main()
{
  point1 A(10,5,'a'); // Создаются еще невидимые символы.
  // Символ создается с умалчиваемыми координатами:
  point1 B;
  point1 D(5,12,'d');
  A.show(); // Показать на экране символ.
  getch();  // Ждать нажатия клавиши.
  B.show(); getch();
  D.show(); getch();
  B = A + D; // Неявное обращение к операции-функции.
  B.show(); getch();
  // Явный вызов операции-функции.
  B = A.operator + (B);
  B.show(); getch();
}

Текст этой программы можно взять здесь.

   
В результате выполнения программы на экран дисплея выводятся последовательно символы:
A(10,5,'a'); B(0,0,'*'); D(5,12,'d'); B(15,17,'+'); B(25,22,'+').

   
Если операция-функция определена как принадлежащая классу, то вызвать ее явно можно
с использованием имени объекта или указателя на объект и операции выбора компонентов
('->', '.'). Другими словами в этом случае вызов операции-функции подобен вызову
обычной компонентной функции класса.

point1 *ptr = &A;        // Указатель "настроен" на
                         //  объект A класса point1.
В = ptr->operator + (D); // Операция '+' выполняется, как
                            //  A + D.

   
В приведенной программе операция-функция для перегрузки операции "+" явно вызвана
для объектов A и B.

   
На следующем шаге мы знакончим знакомиться с перегрузкой операций.



Вы можете оставить комментарий, или Трекбэк с вашего сайта.

Оставить комментарий