Язык программирования C Пятое издание

• Название: Язык программирования C Пятое издание
• Дата: 15.07.2019
• Размер: 1.85 Mb.
• Имя файла: 620354-www.libfox.ru.pdf
• Тип: Документы; #84130
• страница: 38 из 54

Упражнение 14.1. Чем перегруженный оператор отличается от встроенного? В чем перегруженные операторы совпадают со встроенными?
Упражнение 14.2. Напишите объявления для перегруженных операторов ввода, вывода,
сложения и составного присвоения для класса Sales_data.
Упражнение 14.3. Классы string и vector определяют перегруженный оператор ==,
применимый для сравнения объектов этих типов. Если векторы svec1 и svec2 содержат строки, объясните, какая из версий оператора == применяется в каждом из следующих выражений:
(a) "cobble" == "stone" (b) svec1[0] == svec2[0]
(c) svec1 == svec2 (d) "svec1[0] == "stone"

Упражнение 14.4. Объясните, должен ли каждый из следующих операторов быть членом класса и почему?
(а) % (b) %= (с) ++ (d) -> (е) << (f) && (g) == (h) ()
Упражнение 14.5. В упражнении 7.40 из раздела 7.5.1 был приведен набросок одного из следующих классов. Какой из перегруженных операторов должен (если должен) предоставить класс.
(a) Book (b) Date (с) Employee
(d) Vehicle (e) Object (f) Tree
14.2. Операторы ввода и вывода
Как уже упоминалось, библиотека IO использует операторы >> и << для ввода и вывода соответственно. Сама библиотека IO определяет версии этих операторов для ввода и вывода данных встроенных типов. Классы, нуждающиеся во вводе и выводе, обычно определяют версии этих операторов для объектов данного класса.
14.2.1. Перегрузка оператора вывода <<
Обычно первый параметр оператора вывода является ссылкой на неконстантный объект класса ostream. Объект класса ostream неконстантен потому, что запись в поток изменяет его состояние. Параметр является ссылкой потому, что нельзя копировать объект класса ostream.
Page 696/1103

Второй параметр обычно должен быть ссылкой на константу типа класса, объект которого необходимо вывести. Параметр должен быть ссылкой во избежание копирования аргумента.
Но он может быть константной ссылкой потому, что вывод объекта обычно не изменяет его.
Для совместимости с другими операторами вывода оператор operator<< обычно возвращает свой параметр типа ostream. Оператор вывода класса Sales_data
Для примера напишем оператор вывода для класса Sales_data: ostream &operator<<(ostream &os, const Sales_data &item) { os << item.isbn() << " " << item.units_sold << " "
<< item.revenue << " " << item.avg_price(); return os;
}
За исключением имени эта функция идентична прежней версии функции print() (см. раздел
7.1.3). Вывод объекта класса Sales_data требует вывода значений всех его трех переменных-членов, а также вычисления средней цены (average price). Каждый элемент отделяется пробелом. После вывода значений оператор возвращает ссылку на использованный для этого объект класса ostream. Операторы вывода обеспечивают минимум форматирования
Операторы вывода встроенных типов форматирования практически не обеспечивают. В
частности, они не выводят символ новой строки. Пользователи ожидают, что операторы вывода класса будут вести себя так же. Если бы оператор выводил новую строку, то пользователь не смог бы вывести содержимое объекта с описывающим его текстом в одной строке. Оператор вывода, обеспечивающий минимум форматирования, позволяет контролировать подробности вывода пользователям.
Обычно операторы вывода должны выводить содержимое объекта с минимальным форматированием. Они не должны выводить новую строку. Операторы ввода-вывода не должны быть функциями-членами класса
Операторы ввода и вывода, соответствующие соглашениям библиотеки iostream, должны быть обычными функциям, а не членами класса. Эти операторы не могут быть членами нашего класса. Если бы это было так, то левый операнд должен был быть объектом типа нашего класса:
Sales_data data; data << cout; // если бы оператор operator<<
// был членом класса Sales_data
Если бы эти операторы были членами некоего класса, то они должны были бы быть членами класса istream или ostream. Но эти классы являются частью стандартной библиотеки, а добавлять члены в библиотечные классы нельзя.
Таким образом, если необходимо определить операторы ввода-вывода для собственного
Page 697/1103

типа, их следует определить как функции, не являющиеся членами класса. Конечно,
операторы ввода-вывода обычно должны читать или выводить данные не открытых переменных-членов. Как следствие, операторы ввода-вывода обычно объявляют дружественными (см. раздел 7.2.1). Упражнения раздела 14.2.1
Упражнение 14.6. Определите оператор вывода для класса Sales_data.
Упражнение 14.7. Определите оператор вывода для класса String, написанного для упражнений раздела 13.5.
Упражнение 14.8. Определите оператор вывода для класса, который был выбран в упражнении 7.40 раздела 7.5.1.
14.2.2. Перегрузка оператора ввода >>
Обычно первый параметр оператора ввода является ссылкой на поток, из которого осуществляется чтение, а второй параметр — ссылкой на некий неконстантный объект, в который предстоит прочитать данные. Обычно оператор возвращает ссылку на свой поток.
Второй параметр не должен быть константным потому, что задачей оператора ввода и является собственно запись данных в этот объект. Оператор ввода класса Sales_data
В качестве примера напишем оператор ввода для класса Sales_data: istream &operator>>(istream &is, Sales_data &item) { double price; // инициализировать не нужно; читать в price
// прежде, чем использовать is >> item.bookNo >> item.units_sold >> price; if (is) // проверить успех ввода данных item.revenue = item.units_sold * price; else item = Sales_data(); // ввод неудачен: вернуть объект в
// стандартное состояние return is;
}
Page 698/1103

За исключением оператора if это определение подобно прежней функции read() (см. раздел
7.1.3). Оператор if проверяет, было ли чтение успешно. Если произойдет ошибка ввода-вывода, он вернет объект Sales_data в состояние пустого объекта. Это гарантирует корректность состояния объекта.
Операторы ввода должны учитывать возможность неудачи ввода, а операторы вывода об этом могут не заботиться. Ошибки во время ввода
В операторе ввода возможны следующие ошибки.
• Операция чтения может потерпеть неудачу из-за наличия в потоке данных неподходящего типа. Например, после чтения переменной-члена bookNo оператор ввода подразумевает, что следующие два элемента будут числовыми данными. Если во вводе окажутся не числовые данные, поток будет недопустим и все последующее попытки чтения из него потерпят неудачу.
• Во время любой из операций чтения может встретиться конец файла или произойти другая ошибка потока ввода.
Чтобы не проверять каждую часть прочитанных данных, можно проверить состояние потока в целом и только потом использовать прочитанные данные if (is) // проверить успех ввода данных item.revenue = item.units_sold * price; else item = Sales_data(); // ввод неудачен: вернуть объект в
// стандартное состояние
При сбое любой из операций чтения значение переменной-члена price останется неопределенным. Следовательно, перед ее использованием следует проверить, допустим ли еще поток ввода. Если это так, осуществляется вычисление значения переменной revenue. В
случае ошибки ничего страшного не произойдет, поскольку будет возвращен пустой объект класса Sales_data. Для этого объекту item присваивается новый объект класса Sales_data,
созданный при помощи стандартного конструктора. После этого присвоения переменная-член bookNo объекта item будет содержать пустую строку, а его переменные члены revenue и units_sold — нулевое значение.
Возвращение объекта в допустимое состояние особенно важно, если объект мог быть частично изменен прежде, чем произошла ошибка. Например, в данном операторе ввода ошибка могла бы произойти уже после успешного чтения в переменную-член bookNo. В
результате значения переменных-членов units_sold и revenue останутся неизменными. Таким образом, новое значение bookNo будет связано с данными прежнего объекта.
Оставляя объект в допустимом состоянии, можно в некоторой степени защитить пользователя, который игнорирует возможность ошибки ввода. Объект будет находиться в пригодном для использования состоянии — все его члены окажутся определены. Кроме того,
объект не будет вводить в заблуждение — его данные останутся единообразными.
Page 699/1103

Проектируя оператор ввода, очень важно решить, что делать в случае ошибки и как вновь сделать объект доступным. Оповещение об ошибке
Некоторые операторы ввода нуждаются в дополнительной проверке данных. Например,
оператор ввода мог бы проверить соответствие формату данных, читаемых в переменную bookNo. В таких случаях оператору ввода возможно понадобится установить флаг состояния потока так, чтобы он означал отказ (см. раздел 8.1.2), хотя с технической точки зрения чтение было успешно. Обычно оператор ввода устанавливает только флаг failbit. Флаг eofbit подразумевал бы конец файла, а бит badbit — нарушение потока. Установку этих флагов лучше оставить библиотеке IO. Упражнения раздела 14.2.2
Упражнение 14.9. Определите оператор ввода для класса Sales_data.
Упражнение 14.10. Опишите поведение оператора ввода класса Sales_data при следующем вводе:
(а) 0-201-99999-9 10 24.95 (b) 10 24.95 0-210-99999-9
Упражнение 14.11. Что не так со следующим оператором ввода класса Sales_data? Что будет при передаче этому оператору данных предыдущего упражнения? istream& operator>>(istream& in, Sales_data& s) { double price; in >> s.bookNo >> s.units_sold >> price; s.revenue = s.units_sold * price; return in;
}
Упражнение 14.12. Определите оператор ввода для класса, использованного в упражнении
7.40 раздела 7.5.1. Обеспечьте обработку оператором ошибок ввода.
14.3. Арифметические операторы и операторы отношения
Как правило, арифметические операторы и операторы отношения определяют как функции не члены класса, чтобы обеспечить преобразования и для левого, и для правого операнда
(см. раздел 7.1.5). Эти операторы не должны изменять состояние любого из операндов,
поэтому их параметры обычно являются ссылками на константу.
Обычно арифметический оператор создает новое значение, являющееся результатом вычисления двух своих операндов. Это значение отлично от каждого из операндов и вычисляется в локальной переменной. Оператор возвращает как результат копию этого локального значения. Классы, определяющие арифметический оператор, определяют также соответствующий составной оператор присвоения. Когда у класса есть два оператора, как правило, эффективней определять арифметический оператор для составного присвоения:
// подразумевается, что оба объекта относятся к той же книге
Page 700/1103

Sales_data operator+(const Sales_data &lhs, const Sales_data &rhs) {
Sales_data sum = lhs; // копирование переменных-членов из lhs в sum sum += rhs; // добавить rhs к sum return sum;
}
Это определение очень похоже на оригинальную функцию add() (см. раздел 7.1.3). Значение lhs копируется в локальную переменную sum. Затем оператор составного присвоения класса
Sales_data (определенный в разделе 14.4) добавляет значение rhs к sum. Функция завершает работу, возвращая копию значения переменной sum.
Классы, в которых определен арифметический оператор и соответствующий ему составной оператор, обычно реализуют арифметический оператор при помощи составного. Упражнения раздела 14.3
Упражнение 14.13. Какие еще арифметические операторы (см. табл. 4.1), если таковые вообще есть, должны, по-вашему, поддержать класс Sales_data? Определите эти операторы.

Упражнение 14.14. Почему оператор operator+ эффективней определять как вызывающий оператор operator+=, а не наоборот?
Упражнение 14.15. Должен ли класс, выбранный в упражнении 7.40 раздела 7.5.1, определять какие-либо арифметические операторы? Если да, то реализуйте их. В противном случае объясните, почему нет.
14.3.1. Операторы равенства
Классы языка С++ используют оператор равенства для проверки эквивалентности объектов.
Он сравнивает каждую переменную-член обоих объектов и признает их равными, если все значения одинаковы. В соответствии с этой концепцией оператор равенства класса
Sales_data должен сравнить переменные bookNo двух объектов, а также значения их остальных переменных. bool operator==(const Sales_data &lhs, const Sales_data &rhs) { return lhs.isbn() == rhs.isbn() && lhs.units_sold == rhs.units_sold && lhs.revenue == rhs.revenue;
} bool operator!=(const Sales_data &lhs, const Sales_data &rhs) {
Page 701/1103

return !(lhs == rhs);
}
Определение этих функций тривиально. Однако важнее всего принципы, которые здесь используются.
• Если в классе определен оператор, позволяющий выяснить равенство двух объектов данного класса, его функция должна иметь имя operator==. Не стоит изобретать для нее другое имя, поскольку пользователи ожидают, что для сравнения объектов можно использовать именно оператор ==. Кроме того, это гораздо проще, чем каждый раз запоминать новые имена.
• Если в классе определен оператор ==, то два объекта могут содержать одинаковые данные.
• Обычно оператор равенства должен быть транзитивным, т.е. если оба выражения, а == b и b == с, являются истинными, то а == с тоже должно быть истиной.
• Если в классе определен оператор operator==, следует также определить и оператор operator!=. Пользователи вполне резонно будут полагать, что если применимо равенство, то применимо и неравенство.
• Определяя операторы равенства и неравенства, почти всегда имеет смысл использовать один из них для создания другого. Один оператор должен фактически сравнивать объекты, а второй — использовать его в своих целях.
Классы, в которых определен оператор operator==, гораздо проще использовать со стандартной библиотекой. Если оператор == определен в классе, то такие алгоритмы к нему можно применять без всякой дополнительной подготовки. Упражнения раздела 14.3.1
Упражнение 14.16. Определите операторы равенства и неравенства для классов StrBlob (см.
раздел 12.1.1), StrBlobPtr (см. раздел 12.1.6), StrVec (см. раздел 13.5) и String (см. раздел
13.5).
Упражнение 14.17. Должен ли класс, выбранный в упражнении 7.40 раздела 7.5.1, определять операторы равенства? Если да, то реализуйте их. В противном случае объясните, почему нет.
14.3.2. Операторы отношения
Классы, для которых определен оператор равенства, зачастую (но не всегда) обладают операторами отношения. В частности, это связано с тем, что ассоциативные контейнеры и некоторые из алгоритмов используют оператор меньше (operator<).
Обычно операторы отношения должны определять следующее.
1. Порядок отношений, совместимый с требованиями для ключей ассоциативных контейнеров
(см. раздел 11.2.2);
2. Отношение, совместимое с равенством, если у класса есть оба оператора. В частности,
если два объекта не равны, то один объект должен быть меньше другого.
Вполне резонно предположить, что класс Sales_data должен поддерживать операторы
Page 702/1103

отношения, хотя это и не обязательно. Причины не столь очевидны, поэтому рассмотрим их подробнее.
Можно подумать, что оператор < будет определен так же, как функция compareIsbn() (см.
раздел 11.2.2). Эта функция сравнивала объекты класса Sales_data за счет сравнения их
ISBN. Хотя функция compareIsbn() обеспечивает порядок отношений, что соответствует первому требованию, она возвращает результат, противоречащий определению равенства. В
результате она не удовлетворяет второму требованию.
Оператор == класса Sales_data считает две транзакции с одинаковым ISBN неравными, если у них отличаются значения переменных-членов revenue или units_sold. Если бы оператор <
был определен как сравнивающий только значения ISBN, то два объекта с одинаковым ISBN,
но разными units_sold или revenue считались бы неравными, но ни один из объектов не был бы меньше другого. Как правило, если имеются два объекта, ни один из которых не меньше другого, то вполне логично ожидать, что эти объекты равны.
Создается впечатление, что имеет смысл определить оператор operator< для сравнения каждой переменной-члена по очереди. Его можно было бы определить так, чтобы при равных isbn объекты сравнивались по переменной-члену units_sold, а затем revenue.
Однако никаких оснований для упорядочивания здесь нет. В зависимости от того, как планируется использовать класс, определить порядок можно сначала на основании переменных revenue и units_sold. Можно было бы установить, что объекты с меньшим значением переменной units_sold были "меньше", чем таковые с большим. Либо можно было бы установить, что объекты с меньшим значением переменной-члена revenue "меньше", чем таковые с большим значением.
Для класса Sales_data нет единого логического определения значения "меньше". Таким образом, для этого класса лучше вообще не определять оператор operator<.
Если есть однозначное логическое определение значения "меньше", то классы обычно должны определять оператор operator<. Но если у класса есть также оператор operator==,
то определяйте оператор operator<, только если определения смысла понятий "меньше" и "равно" не противоречат друг другу. Упражнения раздела 14.3.2
Упражнение 14.18. Определите операторы отношения для классов StrBlob, StrBlobPtr, StrVec и String.
Упражнение 14.19. Определяет ли класс, выбранный в упражнении 7.40 раздел 7.5.1,
операторы отношения? Если да, то реализуйте их. В противном случае объясните, почему нет.
14.4. Операторы присвоения
Кроме операторов присвоения копии и присваивания при перемещении, которые присваивают один объект типа класса другому объекту того же класса (см. раздел 13.1.2 и раздел 13.6.2), в классе можно определить дополнительные операторы присвоения,
позволяющие использовать в качестве правого операнда другие типы.
Например, библиотечный класс vector, кроме операторов присвоения копии и присваивания при перемещении, определяет третий оператор присвоения, получающий заключенный в фигурные скобки список элементов (см. раздел 9.2.5). Этот оператор можно использовать
Page 703/1103

следующим образом: vector<string> v; v = {"a", "an", "the"};
Такой оператор можно также добавить в класс StrVec (см. раздел 13.5): class StrVec { public:
StrVec &operator=(std::initializer_list<std::string>);
// другие члены, как в разделе 13.5
}
Чтобы не отличаться от операторов присвоения для встроенных типов (и уже определенных операторов присвоения копии и присваивания при перемещении), новый оператор присвоения будет возвращать ссылку на левый операнд:
StrVec &StrVec::operator=(initializer_list<string> il) {
// alloc_n_copy() резервирует пространство и копирует элементы
// из заданного диапазона auto data = alloc_n_copy(il.begin(), il.end()); free(); // удалить элементы в этом объекте и освободить пространство elements = data.first; // обновить переменные-члены, чтобы указывать
// на новое пространство first_free = cap = data.second; return *this;
}
Подобно операторам присвоения копии и присваивания при перемещении, другие перегруженные операторы присвоения должны освобождать существующие элементы и создавать новые. В отличие от операторов копирования и присваивания при перемещении,
этот оператор не должен проверять случай присвоения себя себе. Параметр имеет тип initializer_list<string> (см. раздел 6.2.6), а это означает, что объект il не может быть тем же
Page 704/1103

объектом, на который указывает указатель this.
Операторы присвоения могут быть перегружены. Независимо от типа параметра, операторы присвоения следует определять как функции-члены. Составные операторы присвоения
Составные операторы присвоения не обязаны быть функциями-членами. Однако все операторы присвоения, включая составные, предпочтительно определять в классе. Для согласованности со встроенными составными операторами присвоения эти операторы должны возвращать ссылку на левый операнд. Например, ниже приведено определение составного оператора присвоения для класса Sales_data.
// бинарный оператор-член:
// левый операнд связан с неявным указателем this
// подразумевается, что оба объекта относятся к той же книге
Sales_data& Sales_data::operator+=(const Sales_data &rhs) { units_sold += rhs.units_sold; revenue += rhs.revenue; return *this;
}
Обычно операторы присвоения и составные операторы присвоения должны быть определены как функции-члены и возвращать ссылку на левый операнд. Упражнения раздела 14.4
Упражнение 14.20. Определите оператор суммы и составной оператор присвоения для класса
Sales_data.
Упражнение 14.21. Напишите операторы класса Sales_data так, чтобы + осуществлял сложение, а оператор += вызывал оператор +. Обсудите недостатки этого подхода по сравнению со способом, которым эти операторы были определены в разделах 14.3 и 14.4.
Упражнение 14.22. Определите версию оператора присвоения, способного присвоить строку,
представляющую ISBN, объекту класса Sales_data.
Упражнение 14.23. Определите в версии класса StrVec оператор присвоения для типа initializer_list.
Упражнение 14.24. Примите решение, нуждается ли класс из упражнения 7.40 раздела 7.5.1 в операторах копирования и присваивания при перемещении. Если да, то определите эти операторы.
Упражнение 14.25. Реализуйте все остальные операторы присвоения, которые должен определить класс. Объясните, какие типы должны использоваться как операнды и почему.
Page 705/1103

14.5. Оператор индексирования
Классы, представляющие контейнеры, способные возвращать элементы по позиции,
зачастую определяют оператор индексирования operator[].
Оператор индексирования должен быть определен как функция-член класса.
Согласно общепринятому смыслу индексирования, оператор индексирования обычно возвращает ссылку на выбранный элемент. Возвращающий ссылку оператор индексирования применим с обеих сторон оператора присвоения. Следовательно, имеет смысл определить и константную, и неконстантную версии этого оператора. При применении к константному объекту оператор индексирования должен возвращать ссылку на константу, чтобы предотвратить присвоение возвращенному объекту.
Если у класса есть оператор индексирования, он обычно должен быть определен в двух версиях: возвращающей простую ссылку и являющуюся константной функцией-членом, а следовательно, возвращающую ссылку на константу.
В качестве примера определим оператор индексирования для класса StrVec (см. раздел
13.5): class StrVec { public: std::string& operator[](std::size_t n)
{ return elements[n]; } const std::string& operator[](std::size_t n) const
{ return elements[n]; }
// другие члены, как в разделе 13.5 private: std::string *elements; // указатель на первый элемент массива
};
Эти операторы можно использовать таким же образом, как и индексирование вектора или массива. Поскольку оператор индексирования возвращает ссылку на элемент, если объект класса StrVec не константен, то этому элементу можно присвоить значение; если индексируется константный объект, присвоение невозможно:
// svec - объект класса StrVec const StrVec cvec = svec; //
Page 706/1103

копировать элементы из svec в cvec
// если у svec есть элементы, выполнить функцию empty() класса string
// для первого if (svec.size() && svec[0].empty()) { svec[0] = "zero"; // ok: индексирование возвращает ссылку на строку cvec[0] = "Zip"; // ошибка: индексация cvec возвращает ссылку на
// константу
} Упражнения раздела 14.5
Упражнение 14.26. Определите операторы индексирования для классов StrVec, String, StrBlob и StrBlobPtr.
14.6. Операторы инкремента и декремента
Операторы инкремента (++) и декремента (--) обычно реализуют для классов итераторов. Эти операторы позволяют перемещать итератор с элемента на элемент последовательности.
Язык никак не требует, чтобы эти операторы были членами класса. Но поскольку они изменяют состояние объекта, с которым работают, лучше сделать их членами класса.
Для встроенных типов есть префиксные и постфиксные версии операторов инкремента и декремента. Ничего удивительного, что для собственных классов также можно определить префиксные и постфиксные версии этих операторов. Давайте сначала рассмотрим префиксные версии, а затем реализуем постфиксные.
Классы, определяющие операторы инкремента или декремента, должны определять как префиксные, так и постфиксные их версии. Обычно эти операторы определяют как функции-члены. Определение префиксных версий операторов инкремента и декремента
Для иллюстрации операторов инкремента и декремента определим их для класса StrBlobPtr
(см. раздел 12.1.6): class StrBlobPtr { public:
// инкремент и декремент
Page 707/1103

StrBlobPtr& operator++(); // префиксные операторы
StrBlobPtr& operator--();
// другие члены как прежде
};
Чтобы соответствовать встроенным типам, префиксные операторы должны возвращать ссылку на объект после инкремента или декремента.
Операторы инкремента и декремента работают подобным образом — они вызывают функцию check() для проверки допустимости объекта класса StrBlobPtr. Если это так, то функция check() проверяет также допустимость данного индекса. Если функция check() не передает исключения, эти операторы возвращают ссылку на свой объект.
В случае инкремента функции check() передается текущее значение curr. Пока это значение меньше размера основного вектора, функция check() завершается нормально. Если значение curr находится за концом вектора, функция check() передает исключение:
// префикс: возвращает ссылку на объект после инкремента
// или декремента
StrBlobPtr& StrBlobPtr::operator++() {
// если curr уже указывает после конца контейнера, инкремент
// невозможен check(curr, "increment past end of StrBlobPtr");
++curr; // переместить текущую позицию вперед return *this;
}
StrBlobPtr& StrBlobPtr::operator--() {
// если curr равен нулю, то декремент возвратит недопустимый индекс
--curr; // переместить текущую позицию назад
Page 708/1103

check(-1, "decrement past begin of StrBlobPtr"); return *this;
}
Оператор декремента уменьшает значение curr прежде, чем вызвать функцию check(). Таким образом, если значение curr (беззнаковое) уже является нулем, передаваемое функции check() значение будет наибольшим позитивным значением, представляющим недопустимый индекс (см. раздел 2.1.2). Дифференциация префиксных и постфиксных операторов
При определении префиксных и постфиксных операторов возникает одна проблема: каждый из них имеет одинаковое имя и получает одинаковое количество параметров того же типа.
При обычной перегрузке невозможно отличить префиксную и постфиксную версии оператора.
Для решения этой проблемы постфиксные версии получают дополнительный
(неиспользуемый) параметр типа int. При использовании постфиксного оператора компилятор присваивает этому параметру аргумент 0. Хотя постфиксная функция вполне может использовать этот дополнительный параметр, как правило, так не поступают. Этот параметр не нужен для работы, обычно выполняемой постфиксным оператором. Его основная задача заключается в том, чтобы отличить определение постфиксной версии функции от префиксной.
Теперь в класс CheckedPtr можно добавить постфиксные операторы: class StrBlobPtr { public:
// инкремент и декремент
StrBlobPtr operator++(int); // постфиксные операторы
StrBlobPtr operator--(int);
// другие члены как прежде
};
Для совместимости со встроенными операторами постфиксные операторы должны возвращать прежнее значение (существовавшее до декремента или инкремента). Оно должно быть возвращено как значение, а не как ссылка.
Постфиксные версии должны запоминать текущее состояние объекта прежде, чем изменять объект:
// постфикс: инкремент/декремент объекта, но возвратить следует
//
Page 709/1103

неизмененное значение
StrBlobPtr StrBlobPtr::operator++(int) {
// здесь проверка не нужна, ее выполнит префиксный инкремент
StrBlobPtr ret = *this; // сохранить текущее значение
++*this; // на один элемент вперед, проверку
// осуществляет оператор инкремента return ret; // возврат сохраненного значения
}
StrBlobPtr StrBlobPtr::operator--(int) {
// здесь проверка не нужна, ее выполнит префиксный декремент
StrBlobPtr ret = *this; // сохранить текущее значение
--*this; // на один элемент назад, проверку
// осуществляет оператор декремента return ret; // возврат сохраненного значения
}
Для выполнения фактического действия каждый из этих операторов вызывает собственную префиксную версию. Например, постфиксный оператор инкремента использует такой вызов префиксного оператора инкремента:
++*this
Этот оператор проверяет безопасность приращения и либо передает исключение, либо осуществляет приращение значения curr. Если функция check() не передает исключения,
постфиксные функции завершают работу, возвращая сохраненные ранее копии значений.
Page 710/1103

Таким образом, после выхода сам объект будет изменен, но возвращено будет первоначальное, не измененное значение.
Поскольку параметр типа int не используется, имя ему присваивать не нужно. Явный вызов постфиксных операторов
Как упоминалось в разделе 14.1, в качестве альтернативы использованию перегруженного оператора в выражении можно вызвать его явно. Если постфиксная версия задействуется при помощи вызова функции, то следует передать значение и для целочисленного аргумента:
StrBlobPtr p(a1); // p указывает на вектор в a1 p.operator++(0); // вызов постфиксного оператора operator++ p.operator++(); // вызов префиксного оператора operator++
Переданное значение обычно игнорируется, но оно позволяет предупредить компилятор о том, что требуется именно постфиксная версия оператора. Упражнения раздела 14.6
Упражнение 14.27. Добавьте в класс StrBlobPtr операторы инкремента и декремента.
Упражнение 14.28. Определите для класса StrBlobPtr операторы сложения и вычитания,
чтобы они реализовали арифметические действия с указателями (см. раздел 3.5.3).