Затем кто-то захочет использовать этот оператор для экземпляра класса и передать результат в другую функцию.
Balance moneyMarket(1000.00);
// ...
updateGeneralLeager(moneyMarket += deposit); // He скомпилируется
Это приведет к проблеме, так как
Balance::operator+=
возвращает
void
, а функция типа
updateGeneralLedger
ожидает получить объект типа Balance. Если из арифметических операторов и оператора присвоения возвращать текущий
объект, то этой проблемы не возникнет. Однако это верно не для всех операторов. Другие операторы, типа оператора элемента массива
[]
или оператора отношения возвращают объекты, отличные от
*this
, так что это правило верно только для арифметических операторов и операторов присвоения.
Здесь обеспечивается работа операторов присвоения, выполняющих какие-то вычисления, но как насчет вычислений без присвоения? Еще один способ использовать арифметические операторы выглядит так.
int i = 0, j = 2;
i = j + 5;
В этом случае к значению
j
прибавляется 5, а затем результат присваивается
i
(при этом, если бы
i
был объектом класса, а не встроенного типа, использовался бы оператор присвоения этого класса), а значение
j
остается без изменения. Если требуется, чтобы класс вел себя точно так же, то перегрузите оператор сложения как самостоятельную функцию. Например, имеется возможность сделать так, чтобы можно было записать следующее.
, складывает их частные члены, создает временный объект и возвращает его. Обратите внимание, что в отличие от оператора присвоения здесь возвращается объект, а не ссылка на него. Это сделано потому, что возвращаемый объект является временным, и возврат ссылки на него будет означать, что вызывающий код получит ссылку на удаленную из памяти переменную. Однако само по себе это работать не будет, так как здесь требуется доступ к закрытым (частным) членам аргументов оператора (если, конечно, вы не сделали данные класса открытыми). Чтобы обеспечить такой доступ, класс
, получает доступ ко всем членам класса, так что этот фокус сработает. Только не забудьте объявить параметры как
const
, чтобы случайно не изменить их содержимое.Это почти все, что от вас требуется, но есть еще кое-что, что требуется сделать. Пользователи класса могут создать выражение, аналогичное такому.
total = savings + 500.00;
Для кода из примера 8.15 это выражение будет работать, так как компилятор увидит, что класс
Balance
содержит конструктор, который принимает число с плавающей точкой, и создаст временный объект
Balance
, используя в конструкторе число 500.00. Однако здесь есть две проблемы: накладные расходы на создание временного объекта и отсутствие в классе
Balance
конструктора для всех возможных аргументов, которые могут использоваться в операторе сложения. Скажем, имеется класс с именем
Transaction
,
который представляет сумму кредита или дебета. Пользователь
Balance
может сделать что-то подобное этому.
Transaction tx(-20.00);
total = savings + tx;
Этот код не скомпилируется, так как не существует оператора, который бы складывал объекты
Однако необходимо сделать еще кое-что. Этот оператор также требуется объявить как
friend
в классе
Transaction
, а кроме того, нужно создать идентичную версию этого оператора, которая бы принимала аргументы в обратном порядке, что позволит использовать аргументы сложения в любом порядке и сделает эту операцию коммутативной, т.е.
По той же причине и чтобы избежать создания дополнительного временного объекта при автоматическом вызове конструктора, создайте собственные версии операторов для работы с любыми другими типами переменных.
И снова требуется создать по две версии каждого, чтобы позволить запись, как здесь.
total = 500.00 + checking;
В этом случае создание временного объекта относительно недорого. Но временный объект — это временный объект, и в простых выражениях он не создаст заметных накладных расходов, но такие незначительные оптимизации всегда следует рассматривать в более широком контексте — что, если в результате инкремента каждого элемента
vector<Balance>
будет создан миллион таких временных объектов? Лучше всего заранее узнать, как будет использоваться класс, и в случае сомнений провести измерительные тесты.
В этот момент уместно спросить, почему для этих операторов мы должны создавать отдельные функции и не можем использовать методы, как это делается для присвоения? На самом деле вы можете объявить эти операторы как методы класса, но это не позволит создавать коммутативные операторы. Чтобы сделать оператор коммутативным, его потребуется объявить как метод в обоих классах, которые будут участвовать в операции, и это сработает (хотя и только для классов, знающих о внутренних членах друг друга), но если нет доступных конструкторов, это не сработает для операторов, использующих встроенные типы, и даже если конструкторы есть, придется платить за создание временных объектов.
Перегрузка операторов — это мощная возможность С++, и аналогично множественному наследованию имеются как ее сторонники, так и противники. На самом деле большая часть популярных языков не поддерживает ее совсем. Однако при осторожном использовании она дает возможность писать качественный и компактный код, использующий классы.
Большая часть стандартных операторов имеет несколько значений, и в общем случае вы должны следовать общепринятым соглашениям. Например, оператор
<<
означает битовый сдвиг влево или, при работе с потоками, помещение чего-либо в поток, как здесь.