Арифметические операции над последовательностями

С++. Основы ООП.

Переопределение операторов (перегрузка операций)

В С++ понятие оператора (операции) трактуется очень широко:

операторы арифметические, логические, ввода/вывода, присваивания, индексирования [],
() – скобки – тоже вид оператора, new, delete…

Операции над объектами нового класса желательно записывать в привычной форме, с использованием знаков операций.

Например, присваивание или сравнение для объекта типа TStudent хотелось бы записать так:

TStudent P1, P2; // Объявление двух переменных

P2=P1; // Присваивание

//...

if(P2==P1){ // Сравнение

// здесь действие ...;

}

В С++ есть механизм переопределения операций.

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

Для перегрузки операции задается функция операции:

<возвращ.знач> <имя класса>::operator#(<список аргументов>)
{ // где # - знак операции

// здесь реализация операции

}

Приведем пример переопределения операций = и + для класс Сoord

Class Coord{ // Координаты на плоскости

private:

int x,y;

public:

//...

Coord operator= (Coord ob2); // Переопредение operator=, прототип

Coord operator+ (Coord ob2); // Переопредение operator+, прототип

}

Переопределим operator= для Coord как член класса, вот реализация:

Coord Coord::operator=(Coord ob2){

x=ob2.x;

y=ob2.y;

return this; // возвращение объекта, которому присвоено значение

}

Coord P1, P2, P3;

// Следующие записи эквивалентны:
P1.operator=(P2); // Это вызов operator=() как метод класса

P1=P2; // Это вызов operator=() через знак переопределенной операции

Переопределим operator+ для Coord как член класса, вот реализация:

Coord Coord:: operator+ (Coord ob2){

Coord temp;

temp.x=x+ob2.x;

temp.y=y+ob2.y;

return temp; //

}

// Следующие записи эквивалентны:
P3= P1+P2; // Это вызов operator+() через знак переопределенной операции

P3= P1.operator+(P2); // Это вызов operator+() как метод класса

Переопределим operator+ для Coord как дружественную функцию класса

Class Coord{ // Координаты на плоскости

// Объявление прототипа дружественной функции в описании класса:

friend Coord operator+ (Coord ob1, Coord ob2);

private:

//...

}

// Реализация дружественной функции

Coord operator+ (Coord ob1, Coord ob2){

Coord temp;

temp.x=ob1.x+ob2.x;

temp.y=ob1.y+ob2.y;

return temp; //

}

Переопределение операторов ввода/вывода

Терминология:
Вывод/вставка в поток/inserting

Ввод/извлечение из потока/extracting

Следующие классы реализуют потоки, объявлены в заголовочном файле <iostream.h>:
ostream – поток для вывода

istream – поток для ввода

iostream - поток для ввода/вывода

Вспоминаем:

cin, cout – имена стандартных потоков

int i=10;

cout<<"i="<<i<<";"; // несколько операторов вывода в одной конструкции

cout<<"Input int:";

cin>>i;

Перегрузка операторов ввода << и вывода >> для создаваемого класса может заменить методы ввода/вывода и упростить использование класса.

Форма записи:

ostream &operator<<(ostream &stream, имя_класса ob){

// реализация вывода;

}

istream &operator>>(istream &stream, имя_класса ob){

// реализация ввода;

}

Оператор ввода/вывода должен возвращать ссылку на поток для корректной работы такой конструкции:
cout<<ob1<<ob2<<ob3<<…<<obN;

выполняется вывод ob1- возврашается ссылка на поток,
затем выполняется вывод ob2- возврашается ссылка на поток, и т.д.
Слева от оператора ввода/вывода всегда должна стоять ссылка на поток.

Перегрузка операций ввода/вывода не может быть реализована как метод класса, т.к. метод вызывается объектом класса(Object.Method()), и методу при этом передается неявный указатель на объект this.
Форма записи оператора ввода/вывода предполагает слева имя потока, а не объекта класса:

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

Пример:

class Coord{

friend istream &operator>>(istream &In, Coord &Ob2);

friend ostream& operator<<(ostream &Out, Coord Ob2);

private:
int x,y;

public:

// Constuctors:

Coord(){ x=0; y=0;};

//...

};

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

// Переопределение оператора вывода, дружественная функция, реализация:

ostream &operator<<(ostream &Out, Coord Ob2){

Out<<"x="<<Ob2.x<<"; ";

Out<<"y="<<Ob2.y<<"; ";

return Out;

}

cout<<C1<<C2<<C3;

Итог:

Перегрузка операций – это проявление полиморфизма ООП.

Перегружаемая операция всегда связана с классом: является членом класса или дружественна классу.

Замечание: Невозможно изменить приоритет выполнения операций.

Проработать эту тему подробно по литературе (например, Березин. С и С++. стр 249)

Пример перегрузки операций сложения, присваивания, ввода/вывода

(файл Coord.cpp)

// A. Zhuravlev.

// OOP. Themes: OOP->Inheritance, OOP->Polymorphism

#include <iostream.h>

// Base class Coord

class Coord{

// Redefine input/output

//friend istream &operator>>(istream &In, Coord &Ob2);

friend ostream& operator<<(ostream &Out, Coord Ob2);

privateЖ:

int x,y;

public:

// Constuctors:

Coord(){ x=0; y=0;}

Coord(int X, int Y){ x=X; y=Y;}

// Implementation:

void Set_Coord(int X, int Y){ x=X; y=Y;}

int GetX(){return x;}

int GetY(){return y;}

// Redefine operators:

Coord operator+(Coord Ob2);

Coord operator=(Coord Ob2);

};

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

// Redefine operations:

Coord Coord::operator+(Coord Ob2){

Coord temp;

temp.x=x+Ob2.x;

temp.y=y+Ob2.y;

return temp;

}

Coord Coord::operator=(Coord Ob2){

x=Ob2.x;

y=Ob2.y;

return *this;

}

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

// Redefine input/output

ostream &operator<<(ostream &Out, Coord Ob2){

Out<<"x="<<Ob2.x<<"; ";

Out<<"y="<<Ob2.y<<"; ";

return Out;

}

istream &operator>>(istream &In, Coord Ob2){

//...

} */

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

// Testing:

void main(){

Coord C1(10,20);

Coord C2;

//Coord* C3=new Coord(-1,-1);

C2=C1;

C1.Set_Coord(9999,7777);

//C2=C1+C3; //???

cout<<"Coord C1:"<<endl<<C1;

cout<<"Coord C2: "<<C2;

//cout<<"(C1+C3)="<<(C1+ *C3);

//cout<<C3; //???

return;

}

Арифметические операции над последовательностями

Похожие курсовые работы