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

 

Перечислим некоторые правила перегрузки операций:

· можно перегружать любые операции С++, за исключением «.», «.*», «?:», «::», sizeof;

· не допускается перегрузка операций для стандартных (определенных в С++) типов данных;

· нельзя изменять синтаксис операций. Например, операция ++ перегружается как унарная (имеющая один операнд), операция + может переружаться как унарная, так и как бинарная;

· функции–операции не могут иметь параметры со значениями по умолчанию;

· при перегрузке бинарной операции перегружаемая функция, как метод класса, должна иметь один параметр. Вторым является неявный параметр – константный указатель this на текущий объект(левый операнд);

· при перегрузке бинарных операций: + - * / % ++ -- в большинстве случаев перегружаемая функция возвращает объект класса;

· чтобы сохранить семантику присваивания, операция = должна перегружаться как функция, принимающая один параметр – ссылку на присваиваемый объект класса, и возвращающая ссылку на объект класса, для которого она вызвана;

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

 

 

Пример 4_2. Класс «Вектор1» с конструкторами и перегрузкой операций

Файл vector 1. h                             // определение класса вектор,

// его данных и методов

#ifndef _VECTOR1_H                   //предотвращение многократного

#define _VECTOR1_H                  //включения заголовочного файла

#include <iostream>

using std::endl;

using std::cout;

class VECTOR1                  // Класс для работы с геометрическими векторами

{

       //Данные

       private:

              int   x, y; // Координаты конца вектора

//Методы

       public:

// Конструктор вызывается при создании нового объекта

// с инициализацией по умолчанию или значениями параметров

VECTOR1 (const int &x1=0, const int &y1=0): x(x1), y(y1){ }

       // можно и так:

       //VECTOR (const int &x1=0, const int &y1=0) { x = x1; y = y1; }

      

       // Конструктор копирования - вызывается при создании

// нового объекта с инициализацией другим объектом,

// при передаче параметра с типом класса по значению и

// при возврате значения объекта с типом класса из

// метода класса по return.

// Подставляемый метод

       VECTOR1 (const VECTOR1 &copy)//copy - источник копирования

{

x = copy.x; y=copy.y;

}

       // Присвоить значения координатам вектора: подставляемый метод.

       void Assign(const int &x1, const int &y1)

       {

                   x = x1; y = y1;

                   return;

       }

       // Перегрузка префиксного унарного оператора "++" с

       // помощью метода класса: прибавляет к вектору

       // единичный вектор и возвращает сам вектор (не ссылку!)

       // Метод не имеет явно передаваемых аргументов, так

       // как при вызове неявно получает адрес объекта (this),

       // для которого он вызван. Подставляемый метод

       VECTOR1 operator++(void)

       {

                   x++; y++;

                   return *this;        // Возвращается сам вектор после увеличения

       }

       // Перегрузка постфиксного унарного оператора "++" с

       // помощью метода класса: возвращает значение

       // вектора до прибавления единичного вектора. В

// методе "operator++(int)" параметр метода

       // игнорируется. Метод является подставляемым

       VECTOR1 operator++(int)

       {

                   VECTOR1 vec_tmp = *this;

                   x++; y++;

                   return vec_tmp;    // Возвращает значение вектора до увеличения

       }

       // Перегрузка бинарного оператора "+" с помощью метода

       // класса: суммирует два вектора и возвращает их

       // сумму (не ссылку!). Модификатор const гарантирует, что данный метод

// не изменит значений членов объекта, для которого он вызван.

// Определение будет дано далее.

       VECTOR1 operator+(const VECTOR1 &) const;

       // Перегрузка бинарной операции "=": подставляемый

// метод (при его наличии можно корректно

// использовать цепочки присваиваний).

// В примере этот метод можно было не записывать, так

// как в примере не используются цепочки присваиваний и

// нет полей указателей на области динамической

// памяти

       VECTOR1&  operator = (const VECTOR1 &v)    // Возвращает ссылку на объект

                                                                                         // this - левый операнд

                                                                                         // v - правый операнд

       {

                   this->x = v.x; this->y = v.y;

// А можно и так: x = v.x; y = v.y;

                   return *this;

       }

      

       // Печать значений координат вектора: объявление метода класса.

       // Определение будет дано далее.

       void print(void) const;

};

void VECTOR1::print(void) const

       {

                   cout<<"\n Coordinates of a vector: x= "

                              <<x<<" y= "<<y<<endl;

                   return;

       }

// Оператор "+" бинарный, поэтому метод "operator+"

// долж e н иметь помимо скрытого (this) еще один явно

// передаваемый параметр

VECTOR1 VECTOR1:: operator+(const VECTOR1  &vec) const

{

       // Создать вектор для получения суммы и в начале

// присвоить ему значение первого слагаемого

       VECTOR1   vec_tmp = *this;

       // Сложить векторы и возвратить результат

       vec_tmp.x += vec.x; vec_tmp.y += vec.y;

       return vec_tmp;  //сначала будет вызван конструктор копирования vec_tmp,

//а затем деструктор для удаления vec_tmp

}

#endif _VECTOR1_H

Файл class _ vector 1. cpp   // Тестирование класса VECTOR1

#include "vector1.h"

const int N = 5;            // Число векторов в массиве

Int main()

{

       //Создаем и инициализируем вектор v1 и массив векторов v_a,

//вызывается конструктор по умолчанию

       VECTOR1   v1, v_a[N];

                  

       //Задаем значения и печатаем массив векторов

for (int i = 0; i < N; i++)

       {

                   v_a[i].Assign(i, i+1);

                   cout<<"\n Vector v_a["<<i<<"]:";

                   v_a[i].print();

       }

      

       // К элементам массива векторов добавляем единичные вектора

       // и печатаем массив

       for(int i = 0; i < N; i++)

       {

                   ++v_a[i];

                   cout<<"\n Vector v_a["<<i<<"]:";

                   v_a[i].print();

       }

       // Вычисляем сумму элементов массива векторов и печатаем ее

       for (int i = 0; i < N; i++)

       {

                   v1 = v1 + v_a[i];

       }

       cout<<"\n Summa - vector v1: "; v1.print();

      

       cout<<endl;

       system("pause");

       return 0;

}

 

 

Результат работы программы:

 

Наследование и полиморфизм

 

Наследование позволяет классам-потомкам при сохранении всех свойств классов-родителей добавлять свои собственные свойства, которые отражают их индивидуальность.

На рисунке 4.1 приведена диаграмма классов Figure (фигура), Circle (окружность), Rectangle (прямоугольник).

Рисунок 4.1 – Диаграмма классов

Класс Figure – базовый класс, Circle и Rectangle – наследуемые классы.

 

Полиморфизм в С++ имеет две формы:

· перегрузка операций, функций, использование шаблонов. В этом случае определение конкретного экземпляра операции, функции или класса выполняется на этапе компиляции и называется статическим связыванием;

· использование виртуальных функций (основная форма полиморфизма). В этом случае определение конкретного экземпляра операции, функции или класса выполняется во время выполнения программы и называется динамическим связыванием.

 

Рассмотрим пример реализации диаграммы классов (рисунок 4.1) с использованием наследования и виртуалных функций. В примере вместо реальных графических методов будем использовать сообщения, выводимые на консоль.

 

Пример 4_3. Иерархия классов «Фигура», «Окружность», «Прямоугольник»

Файл fiures. h                // определение классов «Фигура», «Окружность»,

// «Прямоугольник», их данных и методов

# ifndef _ FIGURES _ H        //предотвращение многократного

#define _FIGURES_H       //включения заголовочного файла

#include <iostream>

using std::endl;

using std::cout;

class Figure                      // Базовый класс

{

// Методы

       public:

Figure(void)        // Конструктор по умолчанию

{

cout << "The constructor Figure" << endl;

}

virtual ~Figure(void) // Виртуальный деструктор

{

cout << "The destructor Figure" << endl;

}

      

// Нарисовать фигуру - чисто виртуальная функция

       // не имеет реализации в базовом классе

       virtual  void  draw(void) = 0;

};

class Circle: public Figure // Circle наследуется от Figure

{

// Данные

       private:

                   int   x, // x-координата центра

y, // y-координата центра

R; // Радиус окружности

// Методы

       public:

Circle(int CenterX, int CenterY, int Radius) // Конструктор

{

cout << "The constructor Circle" << endl;

x = CenterX; y = CenterY; r = Radius;

}

virtual ~Circle(void)                              // Виртуальный деструктор

{

cout << "The destructor Circle" << endl;

}

      

       // Нарисовать фигуру - виртуальная функция

       virtual void draw (void);

};

// Нарисовать окружность, реализация в классе Circle

void Circle::draw(void)

{

       cout << "The Circle draw" << endl;

}

class Rectangle: public Figure     // Rectangle наследуется от Figure

{

// Данные

       private:

                   int   l, // Левый верхний

T, // угол

R, // Правый нижний угол

b; // прямоугольника

// Методы

       public:

Rectangle(int L, int T, int R, int B) // Конструктор

{

                   cout << "The constructor Rectangle" << endl;

l = L; t = T; r = R; b = B;

}

      

virtual ~Rectangle(void)           // Виртуальный деструктор

{

cout << "The destructor Rectangle" << endl;

}

      

       // Нарисовать фигуру - виртуальная функция

       virtual void draw(void);

};

// Нарисовать прямоугольник, реализация в классе Rectangle

void Rectangle::draw(void)

{

       cout << "The Rectangle draw" << endl;

}

# endif _ FIGURES _ H

 

 

Файл der _ virt 1. cpp           // Тестирование классов «Фигура», «Окружность»,

// «Прямоугольник»

#include "figures.h"

int main()  // Тестирование классов Figure, Circle и Rectangle

{                           

// Создается массив указателей на базовый класс, который

// инициализируется адресами объектов классов Circle и Rectangle

Figure *figures[2];

figures[0] = new Circle(100, 100, 10);

figures [1] = new Rectangle (100, 100, 200, 250);

      

       // Для каждого объекта базового класса вызывается метод «рисования» фигуры

       figures[0]->draw();

       figures[1]->draw();

// Уничтожаются созданные объекты. Если бы деструкторы не были

// виртуальными, то при уничтожении объектов вызывался бы ~Figure() -

// деструктор базового класса, что приводило бы к ошибке

       delete figures[0]; delete figures[1];

      

       cout<<endl;

       system (" pause ");

       return 0;

}

 

Результат работы программы:

 

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

 

Использование виртуальных функций позволяет с помощью указателя на объект базового класса вызывать методы наследуемых классов (в примере draw) – это и есть полиморфизм!

 

Примеры программ

4.4.1 Класс «Одномерный динамический массив»

 

Данный класс содержит одномерный массив целых чисел, память для которых выделяется динамически.

Использование динамической памяти требует «глубинного» (по элементного) копирования в операциях присваивания с объектами данного класса. Поэтому в классе необходимо создать копирующий конструктор и перегрузить операцию присваивания. Для того, чтобы обеспечить повторное присваивание (например, a = b = c) перегружаемая функция должна возвращать ссылку!

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

Для проверки корректности выполнения программы в реализации методов класса используется макрос assert (выражение) из стандартной библиотеки assert. h. Если результат выражения, стоящего в скобках – ложь, то выполнение программы прерывается и выдается дианостическое сообщение.

 

 

Пример 4_4_1. Класс «Одномерный динамический массив»

Файл DinArray 1. h             //определение динамического массива и его операций

 

#ifndef _DIN_ARRAY1_Н //предотвращение многократного

#define _DIN_ARRAY1_Н //включения заголовочного файла

#include "assert.h"

#include <iostream>

using std::endl;

using std::cout;

class Array1D                   //динамический одномерный массив

{

       //Данные

       private:

       int *p;                //указатель на первый элемент массива целых чисел

                   int size;      //размерность массива

//Методы

       public:

       Array1D(int n=3); //конструктор по умолчанию(размерность массива = 3)

       Array1D(const Array1D&  a); //копирующий конструктор

       ~Array1D() {delete []  p;}   //деструктор освобождает память, выделенную

//для массива

       void print()const;             //вывод значений элементов массива

                   // перегружаемые операции:

       int& operator [](int i)const;                                // индексирование

       Array1D& operator =(const Array1D& a);         // присваивание

       Array1D operator +(const Array1D& a)const;  // сложение (бинарная операция)

};

//реализация методов класса Array 1 D

Array 1 D:: Array 1 D (int n): size (n) //конструктор по умолчанию

{

       assert (n >0);         //размерность массива должна быть положительной

       p = new int [ n ];       //выделяем память для элементов массива

       assert (p!=0);        //если память не выделена, то аварийное завершение

};

Array1D::Array1D(const Array1D& a): size(a.size)     // копирующий конструктор

{

       p = new int [ size ];   //выделяем память для элементов массива

       assert (p!=0);                    //если память не выделена, то аварийное завершение

       for (int i=0; i<size; ++i)

                   p [ i ] = a. p [ i ]; //присваиваем значения элементам массива

}

void Array1D::print() const

{

       for(int i=0; i<size; ++i)

                   cout<<p[i]<<endl;

       cout<<endl;

}

int & Array1D::operator [](int i) const

{

       assert (i >=0 && i < size); //если индекс за границами, то аварийное завершение

       return p [ i ];                   //возвращаем ссылку на i – й элемент массива

}

Array1D& Array1D::operator =(const Array1D& a)

{

       if (this!= &a){ //если присваивание самому себе, то ничего делать не надо

                   assert (size == a. size); //если размеры массивов не равны, то аварийное

// завершение

                   for(int i=0; i<size; ++i)

                   p[i] = a.p[i];

       }

       return *this;                      // возвращаем ссылку на объект Array1D

}

Array1D Array1D::operator +(const Array1D& a) const

{

       assert (size == a. size);       //если размеры массивов не равны, то аварийное

//завершение

       Array 1 D sum (size);        //создаем массив sum размерности size

       for (int i=0; i<size; ++i)

                   sum.p[i] = p[i] + a.p[i]; // или sum.p[i]=this->p[i] +a.p[i];

       return sum;                       //сначала вызывается конструктор копирования,

//потом деструктор массива sum e

}

# endif _ DIN _ ARRAY 1_Н

 

Файл DinArray 1. cpp                    // Тестирование класса Array1D

 

#include "DinArray1.h"

Int main()

{

       Array1D a, b, c;                //Размерность массивов по умолчанию = 3

      

for (int i=0; i<3; ++i) a[i]=i+1;           // Инициализируем массив а

       cout<<"Array1D a: "<<endl;             //и выводим его значения

A.print();

      

b = a;                                                        //Присваиваем элементам массива b

//значения элементов массива  a

       cout<<"Array1D b: "<<endl;                 //и выводим значения массива b

B.print();   

a = a + b + (c = a + b);                          //Сначала определяем значения с,

//затем увеличиваем значения а

       cout<<"Array1D c: "<<endl;             //Выводим значения массива с

       c.print();

cout <<" Array 1 D a: " << endl;             //Выводим значения массива  а

A.print();

       system("pause");

       return 0;

}

 

Результат работы программы:

 

 

4.4.2 Класс «Динамически размещаемая срока»

 

Данный класс содержит строку произвольной длины, символы которой размещаются в памяти динамически.

В реализации методов класса используются функции из стандартной библиотеки < cstring >:

· strcpy _ s (s, len, str) – копирование не более len символов из строки str в строку s

· strcat _ s (s, len, str)  – добавление не более len символов из строки str в строку s

· strlen (str)           – длина строки str. Функция возвращает значение типа size _ t

Функции strcpy _ s, strcat _ s безопасные (контролируют число пересылаеых символов) по сравнению с функциями strcpy, strcat, прииспользовании котрыхкомпилятор выдает предупреждение:

«This function or variable may be unsafe. Consider using strcpy_s instead.»

 

Для проверки корректности выполнения программы в реализации методов класса используется макрос assert (выражение) из стандартной библиотеки assert. h.

 

Пример 4_4_2. Класс «Динамически размешаемая строка»

Файл DinString. h               //определение динамической строки и операций

#ifndef _DIN_STRING_Н //предотвращение многократного

#define _DIN_STRING_Н //включения заголовочного файла

#include <iostream>

using std::endl;

using std::cout;

#include <cstring>

#include "assert.h"

class DinString                  // динамически размещаемая срока

{

// Данные

       private:

       char *s;             //указатель на строку

       int len; //длина строки

//Методы

       public:

       DinString(): len(0){ // конструктор по умолчанию

                   s=new char[1]; assert(s!=0); s[0]=0;

       }

       DinString(const DinString& str); // копирующий конструктор

       DinString(const char* str);      // преобразующий конструктор -

                                                                  // преобразует тип char* к типу DinString

       ~DinString() {delete [] s;}         // деструктор освобождает память,

                                                                  // выделенную для строки

       void print()const { cout<<s<<endl;}// вывод строки

// перегружаемые операции

       DinString& operator =(const DinString& str);      // присваивание

       DinString operator + (const DinString& str) const; // конкатенация

};

// реализация методов класса DinString

DinString::DinString(const char* str) // преобразующий конструктор

{

       len = static_cast<int>(strlen(str));// преобразуем возвращаемое значение

// функции strlen типа size _ t в

// значение типа int

       s=new char[len+1];        //выделяем память для строки

       assert(s!=0);                    //если память не выделена, то аварийное завершение

       strcpy_s(s, len+1, str);

};

DinString::DinString(const DinString& str): len(str.len) // копирующий конструктор

{

       s=new char[len+1]; //выделяем память для строки

       assert(s!=0);        //если память не выделена, то аварийное завершение

       strcpy_s(s, len+1, str.s);

}

DinString& DinString::operator =(const DinString& str)

{

       if (this!= &str){ //если присваивание самому себе, то ничего делать не надо

                   delete [] s;                        //удаляем "старую" строку

                   len = str.len;                     //формируем длину новой строки

                   s=new char[len+1];        //выделяем память для строки

                   assert(s!=0);        //если память не выделена, то аварийное завершение

                   strcpy_s(s, len+1, str.s);

       }

       return *this;                             //возвращаем ссылку на объект

}

DinString DinString::operator + (const DinString& str) const

{

       DinString tmp;

       tmp.s =new char[len + str.len +1];

       tmp.len=len + str.len;

       strcpy_s(tmp.s, tmp.len+1, s);

       strcat_s(tmp.s, tmp.len+1, str.s);

       return tmp;                       //сначала вызывается конструктор копирования,

                                                      //потом деструктор tmp

}

#endif _DIN_STRING_Н

 

 

Файл DinSring. cpp                    // Тестирование класса DinString

 

#include "DinString.h"

Int main()

{

       DinString s1("123"), s2("456"), s3(s1), s4;

       s4=s3 + s2;

       cout<<"s1: "; s1.print(); cout<<"s2: "; s2.print();

cout<<"s3: "; s3.print(); cout<<"s4: "; s4.print();

       cout<<endl;

       system("pause");

       return 0;

}

 

 

Результат работы программы: