Стенли Липпман - Язык программирования C++. Пятое издание

Постфиксные версии должны запоминать текущее состояние объекта прежде, чем изменять объект:

// постфикс: инкремент/декремент объекта, но возвратить следует

// неизмененное значение

StrBlobPtr StrBlobPtr::operator++(int) {

// здесь проверка не нужна, ее выполнит префиксный инкремент

StrBlobPtr ret = *this; // сохранить текущее значение

++*this; // на один элемент вперед, проверку

// осуществляет оператор инкремента

return ret; // возврат сохраненного значения

}

StrBlobPtr StrBlobPtr::operator--(int) {

// здесь проверка не нужна, ее выполнит префиксный декремент

StrBlobPtr ret = *this; // сохранить текущее значение

--*this; // на один элемент назад, проверку

// осуществляет оператор декремента

return ret; // возврат сохраненного значения

}

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

++*this

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

Поскольку параметр типа intне используется, имя ему присваивать не нужно.

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

StrBlobPtr p(a1); // p указывает на вектор в a1

p.operator++(0); // вызов постфиксного оператора operator++

p.operator++(); // вызов префиксного оператора operator++

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

Упражнение 14.27. Добавьте в класс StrBlobPtrоператоры инкремента и декремента.

Упражнение 14.28. Определите для класса StrBlobPtrоператоры сложения и вычитания, чтобы они реализовали арифметические действия с указателями (см. раздел 3.5.3).

Упражнение 14.29. Почему не были определены константные версии операторов инкремента и декремента?

Операторы обращения к значению ( *) и стрелка ( ->) обычно используются в классах, представляющих итераторы, и в классах интеллектуального указателя (см. раздел 12.1). Вполне логично добавить эти операторы в класс StrBlobPtr:

class StrBlobPtr {

public:

std::string& operator*() const {

auto p = check(curr, "dereference past end");

return (*p)[curr]; // (*p) - вектор, на который указывает этот

// объект

}

std::string* operator->() const {

// передать реальную работу оператору обращения к значению

return &this->operator*();

}

// другие члены как прежде

};

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

Оператор стрелка (arrow) должен быть определен как функция-член класса. Оператор обращения к значению (dereference) необязательно должен быть членом класса, но, как правило, его тоже определяют как функцию-член.

Следует заметить, что эти операторы определены как константные члены. В отличие от операторов инкремента и декремента, выборка элемента никак не изменяет состояния объекта класса StrBlobPtr. Обратите также внимание на то, что эти операторы возвращают ссылку или указатель на неконстантную строку. Причина этого в том, что объект класса StrBlobPtr, как известно, может быть связан только с неконстантным объектом класса StrBlob(см. раздел 12.1.6).

Эти операторы можно использовать таким же способом, которым используются соответствующие операторы с указателями и итераторами вектора:

StrBlob a1 = {"hi", "bye", "now"};

StrBlobPtr p(a1); // p указывает на вектор в a1

*p = "okay"; // присвоить первый элемент a1

cout << p->size() << endl; // выводит 4, размер первого элемента в a1

cout << (*p).size() << endl; // эквивалент p->size()

Подобно большинству других операторов (хотя это и плохая идея), оператор operator*можно определить как выполняющий некие действия по своему усмотрению. Таким образом, оператор operator*можно определить как возвращающий, например, фиксированное значение, скажем, 42, или выводящий содержимое объекта, к которому он применен, или что то еще. Но для перегруженного оператора стрелки это не так. Оператор стрелки никогда не изменяет своего фундаментального назначения: доступа к члену класса. При перегрузке оператора стрелки можно изменить объект, из которого стрелка выбирает определенный член, но нельзя изменить тот факт, что она выбирает член класса.

В коде point->memчасть pointдолжна быть указателем на объект класса или объектом класса с перегруженным оператором operator->. В зависимости от типа части pointкод point->memможет быть эквивалентен следующему:

(*point).mem; // point - указатель встроенного типа

point.operator()->mem; // point - объект типа класса

В противном случае код ошибочен. Таким образом, код point->memвыполняется следующим образом.

1. Если point— указатель, то применение встроенного оператора стрелки означает эквивалент выражения (*point).mem. Указатель обращается к значению члена класса и выбирает его из объекта. Если у типа, на объект которого указывает point, нет члена по имени mem, то этот код ошибочен.

2. Если point— объект класса, в котором определен оператор operator->, то результат вызова point.operator->()используется для выбора члена mem. Если результат является указателем, то для него выполняется этап 1. Если результат является объектом, класс которого сам обладает перегруженным оператором operator->(), то с этим объектом повторяется данный этап. Процесс продолжается до тех пор, пока не будет возвращен указатель на объект с означенным членом или некое другое значение, означающее ошибочность кода.