x.operator=(y); // То же самое, что и x = y, но уродливее
Работа моей реализации оператора присвоения проста. Он обновляет член val_ текущего объекта, записывая в него значение аргумента other, а затем возвращает ссылку на текущий объект. Операторы присвоения возвращают текущий объект как ссылку, так что вызывающий код может использовать присвоение в выражениях:
Balance x, y, z;
// ...
x = (y = z);
Таким образом, возвращаемое из (y = z) значение — это измененный объект y, который затем передается в оператор присвоения объекта x. Такая запись для присвоения используется не так часто, как для арифметических операторов, но чтобы придерживаться общего соглашения, всегда следует возвращать ссылку на текущий объект (то, как это связано с арифметическими операторами, я рассказываю дальше).
Однако простое присвоение — это только начало. Скорее всего, вам потребуется использовать другие арифметические операторы, определяющие более интересное поведение. В табл. 8.1 показан перечень арифметических операторов и операторов присвоения.
Табл. 8.1. Арифметические операторы и присвоение
Оператор Поведение = Присвоение (должен быть функцией-членом) + Сложение - -= Вычитание * *= Умножение и разыменование / /= Деление % %= Остаток от деления ++ Инкремент -- Декремент ^ ^= Битовое исключающее ИЛИ ~ Битовое дополнение & &= Битовое И | |= Битовое ИЛИ << <<= Сдвиг влево >> >>= Сдвиг вправо
Для большинства операторов из табл. 8.1 существует две лексемы: первая — это версия оператора, используемая обычным образом, т.е. 1+2, а вторая версия — это версия, которая также присваивает результат операции переменной, т. е. x+=5. Заметьте, что операторы инкремента и декремент ++ и -- описываются в рецепте 8.13.
Реализация всех арифметических операторов и оператора присвоения очень похожа, за исключением оператора присвоения, который не может быть отдельной функцией (т.е. он должен быть методом).
Наиболее популярным при перегрузке является оператор сложения — благодаря тому что он может использоваться в отличных от математических контекстах, таких как объединение двух строк, так что давайте вначале рассмотрим именно его. Он складывает правый аргумент с левым и присваивает результирующее значение левому аргументу, как в выражении.
int i = 0;
i += 5;
После выполнения второй строки int i изменяется и содержит значение 5. Аналогично, если посмотреть на пример 8.15, следует ожидать такого же поведения от этих строк.
Balance checking(500.00), savings(23.91);
checking += 50;
Это означает, что следует ожидать, что после использования оператора += значение checking будет увеличено на 50. Именно это происходит при использовании реализации из примера 8.15. Посмотрите на определение функции для оператора +=.
Balance& operator+=(double other) {
val_ += other;
return(*this);
}
Для оператора присвоения список параметров — это то, что будет указано в операторе в его правой части. В данном случае используется целое число. Тело этой функции тривиально: все, что здесь делается, — это добавление аргумента к частной переменной-члену. Когда эта работа сделана, возвращается *this. Возвращаемым значением из арифметических операторов и операторов присвоения должно быть *this, что позволяет использовать их в выражениях, когда их результаты будут входом для чего-то еще. Например, представьте, что operator+= объявлен вот так.
void operator+=(double other) { // Не делайте так
val += other;
}
Затем кто-то захочет использовать этот оператор для экземпляра класса и передать результат в другую функцию.
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 остается без изменения. Если требуется, чтобы класс вел себя точно так же, то перегрузите оператор сложения как самостоятельную функцию. Например, имеется возможность сделать так, чтобы можно было записать следующее.
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.
