Правила опеределения операторных функций

Перегрузка операторов

Для того, чтобы перемножить две переменные типа double и сложить с третьей типа double, мы можем написать:

x+y*z

Для переменных cx, cy, cz определенного нами ранее типа complex аналогичные действия мы выполняем так:

complex cx,cy,cz;

cy.mul(cz);

cx.add(cy);

Если же мы запишем

cx+cy*cz

то компилятор выдаст ошибку, т.к. встроенные операции «+» и «*» применимы только ко встроенным типам.

Однако C++ позволяет определить смысл многих операций (в том числе сложения и умножения) для определяемых пользователем типов, например:

class complex{

public:

...

complex operator+(complex);

complex operator*(complex);

private:

double re,im;

};

complex complex::operator +(complex a)

{

return complex(re+a.re,im+a.im);

}

complex complex::operator *(complex a)

{

return complex(re*a.re-im*a.im, re*a.im+im*a.re);

}

Если cy и cz имеют тип complex, то cy+cz означает cy.operator+(cz).

Теперь мы можем записывать действия над комплексными числами в форме, близкой к общепринятой:

complex c1(r1,i1),c2(r2,i2);

c2=с2+c1*complex(2,3);

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

Выполняются обычные правила приоритета операций, поэтому в приведенной операции сначала выполняется умножение, затем сложение.

Операторные функции. Можно объявить функции, определяющие смысл следующих операторов:

+ - * / % = < > += -= *= ++ --, -> [] () new delete

и других (всего 42).

Следующие операторы не могут быть определены пользователем:

:: (разрешение области видимости)

. (выбор члена класса или структуры)

.* (выбор через указатель на член класса)

?: (тернарный оператор)

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

Бинарные и унарные операторы.

Операторы – функциональные компоненты выражения. Аргументами операторов являются операнды. В зависимости от количества операндов операторы бывают бинарными (два операнда):

Например: a+b, a*=b, a<b, a[b], a&b, a&&b

и унарными (один операнд)

Например: -a, --a, &a, a++

Унарные операторы, в свою очередь, делятся на префиксные (-a, ++a) и постфиксные (a++).

Есть также один тернарный оператор, a?b:c, но переопределять его действие нельзя.

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

a*b+c>d à (((a*b)+c)>d)

Порядок, в котором выполняются операторы, определяется их приоритетом. Например, приоритет оператора * выше, чем оператора +.

Кроме того, некоторые операторы изменяют (или могут изменять) свои операнды

++a, a++, a*=b, a=b

а некоторые – не изменяют

a+b, a-b, -a.

Для любого бинарного оператора @ выражение aa@bb интерпретируется либо как

а) нестатическая функция-член с одним аргументом

aa.operator@(bb)

либо как

б) функция-не-член с двумя аргументами

operator@(aa,bb)

Если определены обе функции, то для выяснения того, какую из них использовать, применяется механизм разрешения перегрузки (см. перегрузка функций). Например:

class X{

public:

void operator+(int);

X(int);

};

void operator+(X,X);

void operator+(X,double);

void f(X a)

{

a+1; //a.operator+(1)

1+a; //::operator+(X(1),a)

a+1.0;//::operator+(a,1.0)

}

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