Перегрузка бинарных операторов

Итак, операторная функция бинарного оператора может быть объявлена как нестандартная функция-член, и может быть объявлена глобальной т.е. с помощью дружественности.

Когда операторная функция бинарного оператора объявляется как нестандартная функция- член, она должна быть объявлена в виде:

<возв.тип> operator Х (<тип параметра> par);

где: <возв.тип> – тип возвращаемого функцией результата,

Х – перегружаемый оператор,

<тип параметра> и par – тип параметра и сам параметр, который передается в функцию. В этот параметр будет передан тот объект, который в самом выражении (в описании операторной функции) стоит справа от оператора. Объект, стоящий слева от оператора, передается неявно с помощью указателя this.

Рассмотрим пример, в котором в качестве объекта представляется точка с координатами x, y. Надо организовать операторную функцию сложения и вычитания для координат двух точек.

class Coord

{

int x, y;

public:

Coord()

{

x=0;y=0;

}

Coord(int _x, int _y)

{

x=_x; y=_y;

}

void Print()

{

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

}

Coord operator+(Coord& ob);

Coord operator-(Coord& ob);

};

//===============================================

Coord Coord::operator+(Coord& ob)

{

Coord temp_ob;

temp_ob.y=y+ob.y;

temp_ob.x=x+ob.x;

return temp_ob;

}

//===============================================

Coord Coord::operator-(Coord& ob)

{Coord temp_ob;

temp_ob.y=y-ob.y;

temp_ob.x=x-ob.x;

return temp_ob;

}

//================================

void main()

{

Coord a(4,6),b(7,8),c;

c=a+b;

c.Print();

c=a-b;

c.Print();

}

Когда операторная функция бинарного оператора объявляется как глобальная, она должна быть объявлена в виде:

<возв.тип> operator Х (<тип парам_1> par_1, <тип парам_2> par_2);

где: <возв.тип> – тип возвращаемого функцией результата,

Х – перегружаемый оператор,

<тип парам_1> par_1 и <тип парам_2> par_2 – типы параметров и сами параметры, которые передаются в функцию. По крайней мере один из этих параметров должен иметь тип класса, для которого перегружается оператор.

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

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

class Tpoint

{

int x,y;

public:

Tpoint()

{

x=0;

y=0;

printf("работал конструктор без параметров");

}

Tpoint(int xx, int yy)

{

x=xx;

y=yy;

printf(" работал конструктор с параметрами ");}

void pechat();

friend Tpoint operator+(Tpoint& P1, Tpoint& P2);

~Tpoint(){printf("\n работал деструктор");}

};

//===============================================

void Tpoint::pechat()

{

cout<<endl;

cout<< x <<" "<<y<<endl;

}

//===============================================

Tpoint operator+(Tpoint& P1, Tpoint& P2)

{

Tpoint g;

g.x=P1.x+P2.x;

g.y=P1.y+P2.y;

return g;

}

//===============================================

void main()

{

clrscr();

Tpoint a(1,2);

a.pechat();

Tpoint b(10,20);

b.pechat();

Tpoint c;

c=a+b;

c.pechat();

cout<<endl;

getch();

}

Рассмотрим еще один вариант примера, когда передаваемый параметр имеет тип, отличный от типа класса, в данном случае - целый.

class Tpoint

{

int x,y;

public:

Tpoint()

{x=0;

y=0;

printf(" konstryktor bez param");

}

Tpoint(int xx, int yy)

{

x=xx;

y=yy;

printf(" konstryktor c param ");

}

void pechat();

Tpoint operator+(int n);

~Tpoint(){printf("\n destryktor");}

};

//=======================================

void Tpoint::pechat()

{

cout<<endl;

cout<< x <<" "<<y<<endl;

}

//=======================================

Tpoint Tpoint::operator+(int n)

{

Tpoint g;

g.x=x+n;

g.y=y+n;

return g;

}

//=======================================

void main()

{clrscr();

Tpoint a(1,2);

a.pechat();

Tpoint c;

c=a+22;

c.pechat();

cout<<endl;

getch();

}

Дата добавления: 2014-01-03