class SmallInt { public:

SmallInt( int );

SmallInt operator+ ( const SmallInt &, const SmallInt & );

void func() {

int i1, i2;

int i3 = i1 + i2;

Поскольку операнды i1 и i2 имеют тип int, а не тип класса, то при сложении используется встроенный оператор +. Перегруженный operator+(const SmallInt &, const SmallInt &) игнорируется, хотя операнды можно привести к типу SmallInt с помощью определенного пользователем преобразования в виде конструктора SmallInt(int) . Описанный ниже процесс разрешения перегрузки в таких ситуациях не применяется.

Кроме того, разрешение перегрузки для операторов употребляется только в случае

void func() {

SmallInt si(98); int iobj = 65;

int res = si + iobj; использован операторн синтаксис

использования операторного синтаксиса:

Если вместо этого использовать синтаксис вызова функции:

int res = operator+( si, iobj ); синтаксис вызова функции

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

синтаксис вызова функции-члена

раздел 15.10). Если же использован синтаксис вызова функции-члена:

int res = si.operator+( iobj );

то работает соответствующая процедура для функций-членов (см. раздел 15.11).

15.12.1. Операторные функции-кандидаты

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

SmallInt si(98);

int iobj = 65;

При использовании следующего оператора сложения

int res = si + iobj;

SmallInt operator+ ( const SmallInt &, const SmallInt & );

int main() {

SmallInt si(98); int iobj = 65;

int res = si + iobj; ::operator+() - функция-кандидат

кандидат в случае применения operator+() внутри main() :

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

namespace NS {

class SmallInt { /* ... */ };

SmallInt operator+ ( const SmallInt&, double );

int main() {

si имеет тип SmallInt:

этот класс объявлен в пространстве имен NS

NS::SmallInt si(15);

NS::operator+() - функция-кандидат int res = si + 5 66; return 0;

считаются кандидатами:

Операнд si имеет тип класса SmallInt, объявленного в пространстве имен NS. Поэтому перегруженный operator+(const SmallInt, double) , объявленный в том же пространстве, добавляется к множеству кандидатов;

множество операторов, объявленных друзьями классов, к которым принадлежат операнды. Если операнд принадлежит к типу класса и в определении этого класса есть одноименные применяемому оператору функции-друзья, то они добавляются к множеству кандидатов:

операторной функцией-кандидатом является operator+. Какие объявления operator+ принимаются во внимание?

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

множество операторов, видим1х в точке вызова. Объявления функции operator+() , видимые в точке использования оператора, являются кандидатами. Например, operator+() , объявленный в глобальной области видимости, -

namespace NS { class SmallInt {

friend SmallInt operator+( const SmallInt&, int )

{ /* ... */ }

int main() {

NS::SmallInt si(15);

функция-друг operator+() - кандидат int res = si + 5 66; return 0;

Операнд si имеет тип SmallInt. Операторная функция operator+(const SmallInt&, int) , являющаяся другом этого класса, - член пространства имен NS, хотя непосредственно в этом пространстве она не объявлена. При обычном поиске в NS эта операторная функция не будет найдена. Однако при использовании operator+() с аргументом типа SmallInt функции-друзья, объявленные в области видимости этого класса, включаются в рассмотрение и добавляются к множеству кандидатов.

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

множество операторов-членов, объявленных в классе левого операнда. Если такой операнд оператора operator+() имеет тип класса, то в множество функций-кандидатов включаются объявления operator+() , являющиеся членами этого

class myFloat { myFloat( doub

double );

class SmallInt { public:

SmallInt( int );

SmallInt operator+ ( const myFloat & );

int main() {

SmallInt si(15);

int res = si + 5.66; оператор-член operator+() - кандидат класса:

Оператор-член SmallInt::operator+(const myFloat &) , определенный в SmallInt, включается в множество функций-кандидатов для разрешения вызова operator+() в miain();

множество встроенных операторов. Учитывая типы, которые можно использовать со встроенным operator+() , кандидатами являются также: