C++. Сборник рецептов - [124]
>*this, так что это правило верно только для арифметических операторов и операторов присвоения.Здесь обеспечивается работа операторов присвоения, выполняющих какие-то вычисления, но как насчет вычислений без присвоения? Еще один способ использовать арифметические операторы выглядит так.
>int i = 0, j = 2;
>i = j + 5;
В этом случае к значению >j прибавляется 5, а затем результат присваивается >i (при этом, если бы >i был объектом класса, а не встроенного типа, использовался бы оператор присвоения этого класса), а значение >j остается без изменения. Если требуется, чтобы класс вел себя точно так же, то перегрузите оператор сложения как самостоятельную функцию. Например, имеется возможность сделать так, чтобы можно было записать следующее.
>Balance checking(500.00), savings(100.00), total(0);
>total = checking + savings;
Это делается в два этапа. Первый шаг — это создание функции, которая перегружает оператор >+.
>Balance operator+(const Balance& lhs, const Balance& rhs) {
> Balance tmp(lhs.val_ + rhs.val_);
> return(tmp);
>}
Она принимает два объекта типа >const Balance, складывает их частные члены, создает временный объект и возвращает его. Обратите внимание, что в отличие от оператора присвоения здесь возвращается объект, а не ссылка на него. Это сделано потому, что возвращаемый объект является временным, и возврат ссылки на него будет означать, что вызывающий код получит ссылку на удаленную из памяти переменную. Однако само по себе это работать не будет, так как здесь требуется доступ к закрытым (частным) членам аргументов оператора (если, конечно, вы не сделали данные класса открытыми). Чтобы обеспечить такой доступ, класс >Balance должен объявить эту функцию как >friend.
>class Balance {
> // Здесь требуется видеть частные данные
> friend Balance operator+(const Balance& lhs, const Balance& rhs);
> // ...
Все что объявляется, как >friend, получает доступ ко всем членам класса, так что этот фокус сработает. Только не забудьте объявить параметры как >const, чтобы случайно не изменить их содержимое.Это почти все, что от вас требуется, но есть еще кое-что, что требуется сделать. Пользователи класса могут создать выражение, аналогичное такому.
>total = savings + 500.00;
Для кода из примера 8.15 это выражение будет работать, так как компилятор увидит, что класс >Balance содержит конструктор, который принимает число с плавающей точкой, и создаст временный объект >Balance, используя в конструкторе число 500.00. Однако здесь есть две проблемы: накладные расходы на создание временного объекта и отсутствие в классе >Balance конструктора для всех возможных аргументов, которые могут использоваться в операторе сложения. Скажем, имеется класс с именем >Transaction, который представляет сумму кредита или дебета. Пользователь >Balance может сделать что-то подобное этому.
>Transaction tx(-20.00);
>total = savings + tx;
Этот код не скомпилируется, так как не существует оператора, который бы складывал объекты >Ваlance и >Transaction. Так что создайте такой.
>Balance operator+(const Balance& lhs, const Transaction& rhs) {
> Balance tmp(lhs.val_ + Transaction.amount_);
> return(tmp);
>}
Однако необходимо сделать еще кое-что. Этот оператор также требуется объявить как >friend в классе >Transaction, а кроме того, нужно создать идентичную версию этого оператора, которая бы принимала аргументы в обратном порядке, что позволит использовать аргументы сложения в любом порядке и сделает эту операцию коммутативной, т.е. >x+y == y+x.
>Balance operator+(const Transaction& lhs, const Balance& rhs) {
> Balance tmp(lhs.amount_ + rhs.val_);
> return(tmp);
>}
По той же причине и чтобы избежать создания дополнительного временного объекта при автоматическом вызове конструктора, создайте собственные версии операторов для работы с любыми другими типами переменных.
>Balance operator+(double lhs, const Balance& rhs) {
> Balance tmp(lhs + rhs.val_);
> return(tmp);
>}
>Balance operator+(const Balance& lhs, double rhs) {
> Balance tmp(lhs.val_ + rhs);
> return(tmp);
>}
И снова требуется создать по две версии каждого, чтобы позволить запись, как здесь.
>total = 500.00 + checking;
В этом случае создание временного объекта относительно недорого. Но временный объект — это временный объект, и в простых выражениях он не создаст заметных накладных расходов, но такие незначительные оптимизации всегда следует рассматривать в более широком контексте — что, если в результате инкремента каждого элемента >vector будет создан миллион таких временных объектов? Лучше всего заранее узнать, как будет использоваться класс, и в случае сомнений провести измерительные тесты.
В этот момент уместно спросить, почему для этих операторов мы должны создавать отдельные функции и не можем использовать методы, как это делается для присвоения? На самом деле вы можете объявить эти операторы как методы класса, но это не позволит создавать коммутативные операторы. Чтобы сделать оператор коммутативным, его потребуется объявить как метод в обоих классах, которые будут участвовать в операции, и это сработает (хотя и только для классов, знающих о внутренних членах друг друга), но если нет доступных конструкторов, это не сработает для операторов, использующих встроенные типы, и даже если конструкторы есть, придется платить за создание временных объектов.
