15.12. Разрешение перегрузки и операторы a

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

SomeClass sc;

int iobj = sc + 3;

Как компилятор решает, что следует сделать: вызвать перегруженный оператор для класса SomeClass или конвертировать операнд sc во встроенный тип, а затем уже воспользоваться встроенным оператором?

Ответ зависит от множества перегруженных операторов и конвертеров, определенных в SomeClass. При выборе оператора для выполнения сложения применяется процесс разрешения перегрузки функции. В данном разделе мы расскажем, как этот процесс позволяет выбрать нужный оператор, когда операндами являются объекты типа класса.

При разрешении перегрузки используется все та же процедура из трех шагов, представленная в разделе 9.2:

1. Отбор функций-кандидатов.

2. Отбор устоявших функций.

3. Выбор наилучшей из устоявших функции.

Рассмотрим эти шаги более детально.

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

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;

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

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

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

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

int main() {

SmallInt si(98);

int iobj = 65;

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

}

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

namespace NS {

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

SmallInt operator+ ( const SmallInt&, double );

}

int main() {

// si имеет тип SmallInt:

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

NS::SmallInt si(15);

// NS::operator+() - функция-кандидат

int res = si + 566;

return 0;

}

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

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

namespace NS {

class SmallInt {

friend SmallInt operator+( const SmallInt&, int )

{ /* ... */ }

};

}

int main() {

NS::SmallInt si(15);

// функция-друг operator+() - кандидат

int res = si + 566;

return 0;

}

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

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

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

class myFloat {

myFloat( 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+() в main();

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

int operator+( int, int );

double operator+( double, double );

T* operator+( T*, I );

T* operator+( I, T* );

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

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

Все множество операторных функций-кандидатов является объединением пяти подмножеств, описанных выше:

namespace NS {

class myFloat {

myFloat( double );

};

class SmallInt {

friend SmallInt operator+( const SmallInt &, int ) { /* ... */ }

public:

SmallInt( int );

operator int();

SmallInt operator+ ( const myFloat & );

// ...

};

SmallInt operator+ ( const SmallInt &, double );

}

int main() {

// тип si - class SmallInt:

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

NS::SmallInt si(15);

int res = si + 5.66; // какой operator+()?

return 0;

}

В эти пять множеств входят семь операторных функций-кандидатов на роль operator+() в main():

• первое множество пусто. В глобальной области видимости, а именно в ней употреблен operator+() в функции main(), нет объявлений перегруженного оператора operator+();

• второе множество содержит операторы, объявленные в пространстве имен NS, где определен класс SmallInt. В этом пространстве имеется один оператор:

NS::SmallInt NS::operator+( const SmallInt &, double );

• третье множество содержит операторы, объявленные друзьями класса SmallInt. Сюда входит

NS::SmallInt NS::operator+( const SmallInt &, int );

• четвертое множество содержит операторы, объявленные членами SmallInt. Такой тоже есть:

NS::SmallInt NS::SmallInt::operator+( const myFloat & );

• пятое множество содержит встроенные бинарные операторы:

int operator+( int, int );

double operator+( double, double );

T* operator+( T*, I );

T* operator+( I, T* );

Да, формирование множества кандидатов для разрешения оператора, использованного с применением операторного синтаксиса, утомительно. Но после того как оно построено, устоявшие функции и наилучшая из них находятся, как и прежде, путем анализа преобразований, применимых к операндам отобранных кандидатов.