14.1. Фундаментальные концепции

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

Количество параметров функции перегруженного оператора совпадает с количеством операндов оператора. У унарного оператора — один параметр; у бинарного — два. В бинарном операторе левый операнд передается первому параметру, а правый операнд — второму. За исключением перегруженного оператора вызова функции, operator(), у перегруженного оператора не может быть аргументов по умолчанию (см. раздел 6.5.1).

Если перегруженный оператор является функцией-членом, то первый (левый) операнд связывается с неявным указателем this (см. раздел 7.1.2). Поскольку первый операнд неявно связан с указателем this, функция оператора-члена будет иметь на один явный параметр меньше, чем операндов у оператора.

Функция оператора должна быть либо членом класса, либо иметь по крайней мере один параметр типа класса:

// ошибка: переопределить встроенный оператор для целых чисел

int operator*(int, int);

Это ограничение означает невозможность изменить смысл оператора, относящегося к операндам встроенного типа.

Перегрузить можно многие, но не все операторы. Табл. 14.1 демонстрирует, может ли оператор быть перегружен. Перегрузка операторов new и delete рассматривается в разделе 19.1.1 .

Перегрузить можно только существующие операторы и нельзя изобрести новые символы операторов. Например, нельзя определить оператор operator** для возведения числа в степень.

Таблица 14.1. Операторы

Четыре символа (+, -, * и &) служат и унарными операторами, и бинарными. Перегружен может быть один или оба из этих операторов. Определяемый оператор задает количество параметров:

x == y + z;

Это будет эквивалентно x == (y + z).

Непосредственный вызов функции перегруженного оператора

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

// эквивалент вызова функции оператора, не являющегося членом класса

data1 + data2;           // обычное выражение

operator+(data1, data2); // эквивалентный вызов функции

Эти вызовы эквивалентны: оба они являются вызовом функции не члена класса operator+() с передачей data1 как первого аргумента и data2, так и второго.

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

data1 += data2;          // вызов на базе выражения

data1.operator+=(data2); // эквивалентный вызов функции оператора-члена

Каждый из этих операторов вызывает функцию-член operator+=, где указатель this содержит адрес объекта data1, а объект data2 передан как аргумент.

Некоторые операторы не следует перегружать

Помните, что некоторые операторы гарантируют порядок вычисления операндов. Поскольку использование перегруженного оператора на самом деле является вызовом функции, эти гарантии не распространяются на перегруженные операторы. В частности, гарантии вычисления операндов логических операторов AND и OR (см. раздел 4.3), оператора запятая (см. раздел 4.10) не сохраняются. Кроме того, перегруженные версии операторов && и || не поддерживают вычислений по сокращенной схеме. Оба операнда вычисляются всегда.

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

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

Использование определений, совместимых со встроенным смыслом

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

• Если класс осуществляет операции ввода и вывода, имеет смысл определить операторы сдвига для совместимости с таковыми у встроенных типов.

• Если класс подразумевает проверку на равенство, определите оператор operator==. Если у класса есть оператор operator==, то у него обычно должен быть также оператор operator!=.

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

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

Составные операторы присвоения

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

Внимание! Будьте осторожны при использовании перегруженных операторов

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

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

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

Если класс обладает арифметическим (см. раздел 4.2) или побитовым (см. раздел 4.8) оператором, то его, как правило, имеет смысл снабдить соответствующими составными операторами. Вполне логично было бы также определить и оператор +=. Само собой разумеется, оператор += должен быть определен так, чтобы он вел себя аналогично встроенным операторам, т.е. осуществлял составное присвоение: сначала сумма (+), а затем присвоение (=).

Выбор обычной функции или члена класса

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

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

• Операторы присвоения (=), индексирования ([]), вызова (()) и доступа к члену класса (->) следует определять как функции-члены класса.

• Подобно оператору присвоения, составные операторы присвоения обычно должны быть членами класса. Но в отличие от оператора присвоения, это не обязательно.

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

• Симметричные операторы, такие как арифметические, операторы равенства, операторы сравнения и побитовые операторы, лучше определять как обычные функции, а не члены класса.

Разработчики ожидают возможности использовать симметричные операторы в выражениях со смешанными типами. Например, возможности сложить переменные типа int и double. Сложение симметрично, а потому можно использовать тип как левого, так и правого операнда.

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

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

string s = "world";

string t = s + "!";  // ok: const char* можно добавить к строке

string u = "hi" + s; // возможна ошибка, если + будет членом

                     // класса string

Если бы оператор operator+ был членом класса string, то первый случай сложения был бы эквивалентен s.operator+("!"). Аналогично сложение "hi" + s было бы эквивалентно "hi".operator+(s). Однако литерал "hi" имеет тип const char*, т.е. встроенный тип; у него нет функций-членов.

Поскольку класс string определяет оператор + как обычную функцию, не являющуюся членом класса, сложение "hi" + s эквивалентно вызову operator+("hi", s). Подобно любому вызову функции, каждый из аргументов должен быть преобразуем в тип параметра. Единственное требование — по крайней мере один из операндов должен иметь тип класса, а оба операнда могут быть преобразованы в строку.

Упражнения раздела 14.1

Упражнение 14.1. Чем перегруженный оператор отличается от встроенного? В чем перегруженные операторы совпадают со встроенными?

Упражнение 14.2. Напишите объявления для перегруженных операторов ввода, вывода, сложения и составного присвоения для класса Sales_data.

Упражнение 14.3. Классы string и vector определяют перегруженный оператор ==, применимый для сравнения объектов этих типов. Если векторы svec1 и svec2 содержат строки, объясните, какая из версий оператора == применяется в каждом из следующих выражений:

(a) "cobble" == "stone" (b) svec1[0] == svec2[0]

(c) svec1 == svec2      (d) "svec1[0] == "stone"

Упражнение 14.4. Объясните, должен ли каждый из следующих операторов быть членом класса и почему?

(а) % (b) %= (с) ++ (d) -> (е) << (f) && (g) == (h) ()

Упражнение 14.5. В упражнении 7.40 из раздела 7.5.1 был приведен набросок одного из следующих классов. Какой из перегруженных операторов должен (если должен) предоставить класс.

(a) Book    (b) Date   (с) Employee

(d) Vehicle (e) Object (f) Tree