9 Перегрузка стандартных операций

Привлекательной особенностью С++ является возможность распространения действия стандартных операций на операнды, для которых эти операции первоначально в языке не предназначались. Для появления возможности использовать стандартную для С++ операцию (+ или *) с необычными для нее данными, необходимо специальным образом определить ее поведение. Это возможно, если хотя бы один из операндов является объектом некоторого класса. Для перегрузки операции на новые пользовательские типы данных необходимо определить специальную функцию, называемую “операция-функция”. Формат определения операции-функции:

тип_возвращаемого_значения operotor знак_операции(параметры)

{ операторы тела }

Для объекта класса Т можно ввести следующую функцию:

Т оператор * (Т х, Т y)

{ . . . }

Количество операндов у операции-функции зависит от арности операции и от способа определения функции. Для обеспечения явной связи с классом операция-функция должна быть либо компонентом класса, либо определена как дружественная данному классу, либо у нее должен быть хотя бы один параметр типа класс (или ссылка на класс).

Если для класса Т введена операция-функция с приведенным выше заголовком, то выражение А*В интерпретируется как вызов функции operator *(A, B)

Перегрузим операцию ‘ + ‘ на объекты класса строка.

#include <string.h> //stroka.h

#include <iostream.h>

class stroka

{ char *ch; int len;

public:

stroka (int N=80) : len(0) { ch=new char[N+1]; ch[0]=‘ \ 0’ ; }

stroka (const char *arch) { len=strlen(arch); ch=new char[len+1]; strcpy(ch, arch);}

int& len_str (void) { return len; }

char *string (void) { return ch; }

void display (void) { cout<<“ \n Длина строки: “<<len;

cout<<“\n Содержимое строки: “<<ch;}

~ stroka ( ) { delete [ ] ch; }

};

#include “stroka.h” //Перегрузка ‘ + ‘

stroka operator + (stroka& A, stroka& B);

void main (void)

{ stroka X (“Qui “); stroka Y (“Vevra”); stroka Z (“Verra! “); stroka C;

C=X+Y+Z+” - Поживем - увидим !”; C.display();

}

stroka operator + (stroka& A, stroka& B);

{ int ii=a.len_str()+b.len_str(); stroka *ps;

ps=new stroka(ii);

strcpy(ps ->string(), a.string()); strcpy(ps-> string(), b.string() ); ps->len_str()=ii;

return *ps;

}

Вторую возможность перегрузки бинарной операции представляют компонентные функции классов.

Введем операцию ‘+’ для точек на экране дисплея.

#include <grapics.h>

class point1

{ protected : int x, y;

public :

point1 (int xi=0, int yi=0) { x=xi; y=yi; }

void show (void) { putpixel (x, y, getcolor() ); }

point1 operator + (point1& p);

};

point1 point1 : : operator + (point1& p) { point1 d; d.x=this->x+p.x;

d.y=this->y+p.y; return d; }

#include <conio.h>

Void main ()

{ int dr=DETECT, mod;

point1 A(200, 50); point1 B; point1 D(50, 120);

initgraph(&dr, &mod, “\C:\\BCU\\bgi “);

A.show(); getch(); D.show(); getch(); B=A+D; B.show(); getch();

B=A.operator + (B);

closegraph();

}

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

Выполним перегрузку унарной операции ‘-’, меняющей направление для радиус-вектора N-мерного пространства.

#include <iostream.h>

class vector

{ int N; double *x; //Указатель на массив координат

friend vector& operator — (vector&);

public :

vector (int n, double *xn) { N=n; x=xn;}

void display();

};

void vector : : display() { cout<<“\n Координаты вектора: “;

for (int i=0; i<N; i++) cout<<“\t”<<x[i];}

vector& operator — (vector& v) { for (int i=0; i<v.N; i++)

v.x[i]= — v.x[i];

return v; }

void main (void)

{ double A[ ]={1.0, 2.0, 3.0, 4.0 }; vector v(4, A); v.display(); v= - v;

v.display();

}

При перегрузке не допускается вводить собственные обозначения операций. Не допускают перегрузку следующие операции: ‘.’ , ‘.* ’, ‘::‘, siseof, ‘#’, ‘##‘. Нельзя изменить синтаксис выражений для перегруженных операций (невозможно ввести унарную ‘=‘ или бинарную ‘++’).