Д. Стефенс - C++. Сборник рецептов

(--player1)--;

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

foo(--player1);

Функция fooожидает аргумент типа Score, и для корректной компиляции именно это должно возвращаться из префиксного operator--.

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

Рецепт 8.14.

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

Balance checking(50.0);

savings(100.0);

checking += 12.0;

Balance total = checking + savings;

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

Пример 8.15. Перегрузка унарных и бинарных операторов

#include

using namespace std;

class Balance {

// These have to see private data

friend const Balance operator+(const Balance& lhs, const Balance& rhs);

friend const Balance operator+(double lhs, const Balance& rhs);

friend const Balance operator+(const Balance& lhs, double rhs);

public:

Balance() : val_(0.0) {}

Balance(double val) : val_(val) {}

~Balance() {}

// Унарные операторы

Balance& operator+=(const Balance& other) {

val_ += other.val_;

return(*this);

}

Balance& operator+=(double other) {

val_ += other;

return(*this);

}

double getVal() const {return(val_);}

private:

double val_;

};

// Бинарные операторы

const Balance operator+(const Balance& lhs, const Balance& rhs) {

Balance tmp(lhs.val_ + rhs.val_);

return(tmp);

}

const Balance operator+(double lhs, const Balance& rhs) {

Balance tmp(lhs + rhs.val_);

return(tmp);

}

const Balance operator+(const Balance& lhs, double rhs) {

Balance tmp(lhs.val_ + rhs);

return(tmp);

}

int main() {

Balance checking(500.00);

savings(23.91);

checking += 50;

Balance total = checking + savings;

cout << "Платежный баланс: " << checking.getVal() << '\n';

cout << "Общий баланс: " << total.getVal() << '\n';

}

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

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

Balance x(0), у(32);

x = y;

Вторая строка — это краткая запись вызова Balance::operator=(y). Оператор присвоения отличается от большинства других операторов тем, что если вы не создаете собственной его версии, то компилятором создается версия по умолчанию. Версия по умолчанию просто копирует в текущий объект каждый член целевого объекта, что, конечно, не всегда приемлемо, так что его можно перегрузить и обеспечить другое поведение или перегрузить и предоставить возможность присвоения объектов типов, отличных от текущего

Для класса Balanceиз примера 8.15 оператор присвоения можно определить вот так.

Balance& operator=(const Balance& other) {

val_ = other.val_;