Void vivod ( ) // выводит данные

{ cout<< "строка: " <<ch <<" , длина строки="<<len;};

~stroka( ) // деструктор

{ delete [ ]ch ; }

friend stroka& operator+(stroka&, stroka&);//функция-операция друг

} ;

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

{ int N = A.len_str ()+ B.len_str();

stroka*ptr=new stroka(N);

// выделяем память на суммарную строку

strcpy( ptr->string() , A.string() ) ;// копируем в новую строку первую строку

strcat(ptr->string() , B.string () ) ; // присоединяем к ней и вторую строку

return *ptr ; //возвращаем оъект , а не указатель на объект ( разыменовали)

}

Void main ( )

{

// прототип операции-функции

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

stroka X ("Миру -"); // объявлена три объекта

stroka Y(" мир!");

stroka Z;

Z=X+Y + " Нет войне!";// эквивалентно Z =operator + (X,Y);

// Z = operator + (Z , " Нет войне!");

Z.vivod( ) ; }

В предпоследней строке происходит автоматическое преобразование типа строки “Нет войне” к типу stroka, то есть создается безвмянный временный объект.

Если бы мы использовали функцию-операцию, представленную как компонентную и строка “Нет войне” стояла бы на первом месте, то компилятор рассматривая ее как объект, для которого вызывается функция операция, вывел бы сообщение об ошибке ( illegal structure operation).

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

Рассмотрим еще несколько важных особенностей механизма перегрузок (расширения действия ) стандартных операций С++:

1) C++ запрещает вводить операции с новым обозначением.

2) Нельзя изменить приоритет стандартной операции, перегрузив ее.

3) Нельзя изменять арность операции.

4) Перегрузка бинарной операции определяется либо как компонентная функция класса с одним параметром, либо как внешняя функция, возможно дружественная, с двумя параметрами:

выражение: X <операция>Y

соответствует вызовам:

X. operator <операция> (Y) // если операция-функция - метод класса

или:

operator <операция> (X, Y) //если операция-функция -внешняя

5) Перегрузка унарной операции определяется либо как компонентная функция без параметра, либо как внешняя функция, возможно дружественная, с одним параметром:

выражение : <операция> X

соответствует вызовам :

X. operator <операция> ( ) // если операция-функция - метод класса

или:

operator <операция> (X ) // если операция-функция –внешняя

Рассмотрим перегрузку унарной операции “–“ для класса “вектор”:

class vector

{

int N // размерность пространства

double*x // указатель на массив координат

friend vector& operotor – (vector&) ;

public:

vector (int n , double * xn) // конструктор

{N=n ; x=xn;}

void vivod()

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

cout<<”\t”<<x[i];}

};

vector& operotor – (vector&v) // определение функции-операции

{for(int i=0; i< v.N; i++)

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

return v; }

void main( )

{double A []= {1.0, 2.0, 3.0}

vector v(3,A);// инициируем объект

v.vivod

v=-v;

v.vivod;}

Рассмотрим перегрузку операций инкремента (++) и декремента (- -), которые могут быть префиксными и постфиксными .

Принято соглашение, что префиксные операции (++) и (- -), ничем не отличаются от обычной перегрузки унарных операций. Т.е. дружественные функции перегрузки содержат один параметр, а компонентные функции перегрузки – не имеют параметров и определяют те же префиксные операции.

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

Операция – функция вызывается с нулевым целым параметром.

Рассмотрим перегрузку префиксных и постфиксных операций для класса “пара чисел”, при этом перегрузку операции инкремента произведем с помощью дружественной функции-операции, а декремента – с помощью компонентной функции- операции.

#include <iostream.h>

class pair {

int N

double X

public:

pair ( int n , double x)

{ N=n; X= x; }

friend pair & operator ++ ( pair &) ; // префиксная

friend pair & operator++ ( pair& , int ) ; // постфиксная

pair& operator- - ( ) // префиксная

{ N= N-1 ; X - = 1.0 ;

return * this ; }

pair& operator- - ( int k ) // постфиксная

{ N= N-1+k ; X - = 1.0 +k;

return * this ;}