Полиморфизм. Перегрузка операции

Полиморфизм

Виды:

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

2. Перегрузка операции

3. Динамический полиморфизм (при наследовании)

4. Параметрический полиморфизм

Перегрузка операции

Statement – оператор

Operator – операция

Основная цель – Уровнять в правах создаваемый нами класс со встроенными типами данных.

Операция перегруженная для некоторого класса со встроенными типами работает обычным образом

Способы перегрузки операции

Нельзя перегружать

1. ?:

2. ::

3. .

4. Sizeof

5. Циклы

6. Условные операции

Остальные можем перегружать.

Перегрузка операции выполняется с помощью специальных функции.

Отношение функции к классу:

1. Метод класса (можно использовать для перегрузки) | =-> [] ()

2. Дружественная функция (можно использовать для перегрузки)| > > < < ЧИСЛО + ОБЬЕКТ

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

Перегрузка с помощью метода класса

В общем виде:

Тип_возвр_значoperatorзнак_оперции (список_параметров)

ПРИМЕР 1.

classTVect {

float x, y;

public:

TVect(floatxx = 1, floatyy = 2);

voidin();

voidout();

TVectoperator+ (TVect& V);

TVect& operator= (TVect& V);

TVect& operator++();

intoperator==(TVect& V);

//friend TVect operator+(TVect& V1, TVect& V2); вместоTVect operator+ (TVect& V);

};

//Реализация

//К-р, in, out - смотреть ранее.

TVectTVect:: operator+(TVect& V) {

TVecttmp; //векторсумма

tmp. x = x + V. x;

tmp. y = y + V. y;

returntmp;

}

//-------------------------------------

TVect& TVect:: operator=(TVect& V) {

x = V. x; y = V. y;

return *this; // this-При создании объекта класса в него явно передается указатель на самого себя

}

//--------------------------------------

TVect& TVect:: operator++() {

x++; y++;

return *this;

}

//--------------------------------------

intTVect:: operator==(TVect& V) {

int f = 0;

if (x == V. x& & y == V. y) f = 1;

return f;

}

//проверить все поля на соотвествие

//----------------------------------------

//C помощью friend

/*TVect operator+(TVect& V1, TVect& V2) {

TVecttmp;

tmp. x = V1. x + V2. x;

tmp. y = V1. y + V2. y;

return tmp;

}*/

voidmain()

{

TVect a, b(3, 4), c(9, 7);

a. out(); b. out(); c. out();

a = c;

a. out(); b. out(); c. out();

//-------------------------------

// а и с одинаковые, а и b - различные

if (a == c) cout< < " ДА"; elsecout< < " НЕТ"; // ДА

if (a == b) cout< < " ДА"; elsecout< < " НЕТ"; // НЕТ

//--------------------------------------------

(a + c). out(); //18 14

a. out(); c. out(); // 9 7 | 9 7

c = a + b;

a. out(); b. out(); c. out(); // 9 7 | 3 4 | 12 11

//--------------------------------------------------

a++;

a. out(); // 10 8

}

//(приоритет, кол-во операндов)

//+

//обьект + обьект; вектор + вектор -> вектор (все они одного типа)

// (его передовать (его передовать

// в метод класса нужно)

// не надо)

//вектор1 = вектор2 (3-й вектор не появляется, меняется вектор1)

//++

//Объект++ -> измененный объект

//==

//объект == объект -> (1 или 0; trueorfalse)

ПРИМЕР 2.

classTArr {

float *a;

int n;

public:

TArr(intnn = 3, floataa = 0);

~TArr();

void in();

void out();

TArr& operator=(TArr& mas);

TArroperator+(TArr& mas);

};

//-----------------------------------

//К-р, д-р, in, out - смотри ранее

TArr& TArr:: operator=(TArr& mas) {

delete[]a;

n = mas. n;

a = newfloat[n];

for (int i = 0; i < n; i++)a[i] = mas. a[i];

return *this;

}

// obj: 1 7 2 4

// mas: 3 0 9 6 29 80

// obj+mas

// способ1: Сцепление - 1 7 2 4 3 0 9 6 29 80

// способ2: По элементное слодение - 4 7 11 10 29 80