Предопределенное назначение оператора нельзя изменить для встроенных типов. Например, не разрешается переопределить встроенный оператор сложения целых чисел

// ошибка: нельзя переопределить встроенный оператор сложения int

так, чтобы он проверял результат на переполнение. int operator+( int, int );

Нельзя также определять дополнительные операторы для встроенных типов данных,

например добавить к множеству встроенных операций operator+ для сложения двух массивов.

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

Предопределенные приоритеты операторов (см. раздел 4.13) изменить нельзя.

Независимо от типа класса и реализации оператора в инструкции x == y + z;

всегда сначала выполняется operator+, а затем operator==; однако помощью скобок порядок можно изменить.

Предопределенная арность операторов также должна быть сохранена. К примеру,

унарный логический оператор НЕ нельзя определить как бинарный оператор для двух объектов класса String. Следующая реализация некорректна и приведет к ошибке

// некорректно: ! - это унарный оператор

bool operator!( const String &s1, const String &s2 )

{

return ( strcmp( s1.c_str(), s2.c_str() ) != 0 );

компиляции:

}

Для встроенных типов четыре предопределенных оператора ("+", "-", "*" и "&") используются либо как унарные, либо как бинарные. В любом из этих качеств они могут быть перегружены.

Для всех перегруженных операторов, за исключением operator(), недопустимы аргументы по умолчанию.

15.1.3. Разработка перегруженных операторов

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

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

После определения открытого интерфейса класса проверьте, есть ли логическое соответствие между операциями и операторами:

∙isEmpty() становится оператором “ЛОГИЧЕСКОЕ НЕ”, operator!().

∙isEqual() становится оператором равенства, operator==().

∙copy() становится оператором присваивания, operator=().

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

Примером неправильного использования перегрузки операторов является определение operator+() как операции вычитания, что бессмысленно: не согласующаяся с интуицией семантика опасна.

Такой оператор одинаково хорошо поддерживает несколько различных интерпретаций. Безупречно четкое и обоснованное объяснение того, что делает operator+(), вряд ли устроит пользователей класса String, полагающих, что он служит для конкатенации строк. Если семантика перегруженного оператора неочевидна, то лучше его не предоставлять.

Эквивалентность семантики составного оператора и соответствующей последовательности простых операторов для встроенных типов (например, эквивалентность оператора +, за которым следует =, и составного оператора +=) должна быть явно поддержана и для класса. Предположим, для String определены как operator+(), так и operator=() для поддержки операций конкатенации и почленного

String s1( "C" );

String s2( "++" );

копирования:

s1 = s1 + s2; // s1 == "C++"

Но этого недостаточно для поддержки составного оператора присваивания

s1 += s2;

Его следует определить явно, так, чтобы он поддерживал ожидаемую семантику.

Упражнение 15.1

Почему при выполнении следующего сравнения не вызывается перегруженный оператор operator==(const String&, const String&):

"cobble" == "stone"

Упражнение 15.2

Напишите перегруженные операторы неравенства, которые могут быть использованы в

String != String

String != С-строка

таких сравнениях:

C-строка != String

Объясните, почему вы решили реализовать один или несколько операторов.

Упражнение 15.3

Выявите те функции-члены класса Screen, реализованного в главе 13 (разделы 13.3, 13.4 и 13.6), которые можно перегружать.

Упражнение 15.4

Объясните, почему перегруженные операторы ввода и вывода, определенные для класса String из раздела 3.15, объявлены как глобальные функции, а не функции-члены.

Упражнение 15.5

Реализуйте перегруженные операторы ввода и вывода для класса Screen из главы 13.

15.2. Друзья

Рассмотрим еще раз перегруженные операторы равенства для класса String, определенные в области видимости пространства имен. Оператор равенства для двух

bool operator==( const String &str1, const String &str2 )

{

if ( str1.size() != str2.size() ) return false;

return strcmp( str1.c_str(), str2.c_str() ) ? false : true;

объектов String выглядит следующим образом:

}

bool String::operator==( const String &rhs ) const

{

if ( _size != rhs._size ) return false;

return strcmp( _string, rhs._string ) ? false : true;

Сравните это определение с определением того же оператора как функции-члена:

}

Нам пришлось модифицировать способ обращения к закрытым членам класса String. Поскольку новый оператор равенства – это глобальная функция, а не функция-член, у него нет доступа к закрытым членам класса String. Для получения размера объекта String и лежащей в его основе C-строки символов используются функции-члены size()

и c_str().

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

Объявление друга (оно начинается с ключевого слова friend) встречается только внутри определения класса. Поскольку друзья не являются членами класса, объявляющего дружественные отношения, то безразлично, в какой из секций – public, private или protected – они объявлены. В примере ниже мы решили поместить все подобные

class String {

friend bool operator==( const String &, const String & ); friend bool operator==( const char *, const String & ); friend bool operator==( const String &, const char * );

public:

// ... остальная часть класса String

объявления сразу после заголовка класса:

};

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

//дружественные операторы напрямую обращаются к закрытым членам

//класса String

bool operator==( const String &str1, const String &str2 )

{

if ( str1._size != str2._size ) return false;

return strcmp( str1._string, str2._string ) ? false : true;

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

inline bool operator==( const String &str, const char *s )

{

return strcmp( str._string, s ) ? false : true;

}

}

// и т.д.

Можно возразить, что в данном случае прямой доступ к членам _size и _string необязателен, так как встроенные функции c_str() и size() столь же эффективны и при этом сохраняют инкапсуляцию, а значит, нет особой нужды объявлять операторы равенства для класса String его друзьями.

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

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

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

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

extern ostream& storeOn( ostream &, Screen & ); extern BitMap& storeOn( BitMap &, Screen & ); // ...

class Screen

{

friend ostream& storeOn( ostream &, Screen & ); friend BitMap& storeOn( BitMap &, Screen & ); // ...

он хочет дать неограниченные права доступа:

};

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

class Window; // это всего лишь объявление class Screen {

friend bool is_equal( Screen &, Window & ); // ...

};

class Window {

friend bool is_equal( Screen &, Window & ); // ...

Объявление функции другом двух классов должно выглядеть так:

};

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