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

 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<Balance> будет создан миллион таких временных объектов? Лучше всего заранее узнать, как будет использоваться класс, и в случае сомнений провести измерительные тесты.

В этот момент уместно спросить, почему для этих операторов мы должны создавать отдельные функции и не можем использовать методы, как это делается для присвоения? На самом деле вы можете объявить эти операторы как методы класса, но это не позволит создавать коммутативные операторы. Чтобы сделать оператор коммутативным, его потребуется объявить как метод в обоих классах, которые будут участвовать в операции, и это сработает (хотя и только для классов, знающих о внутренних членах друг друга), но если нет доступных конструкторов, это не сработает для операторов, использующих встроенные типы, и даже если конструкторы есть, придется платить за создание временных объектов.

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

Большая часть стандартных операторов имеет несколько значений, и в общем случае вы должны следовать общепринятым соглашениям. Например, оператор << означает битовый сдвиг влево или, при работе с потоками, помещение чего-либо в поток, как здесь.

cout << "Это записывается в поток стандартного вывода.n.";

Если вы решите перегрузить << для одного из своих классов, он должен делать одно из этих действий или, по крайней мере, аналогичное им. Перегрузка оператора — это одно, а придание им другого семантического смысла — это совсем другое. Если вы не вводите новое соглашение, повсеместно используемое в вашем приложении или библиотеке (что все равно является плохой идеей), и оно не является интуитивно понятным кому-либо еще, кроме вас, следует строго придерживаться стандартных значений.

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

Рецепт 8.13.

8.15. Вызов виртуальной функции родительского класса

Требуется вызвать функцию родительского класса, но она переопределена в производном классе, так что обычный синтаксис p->method() не дает нужного результата.

Укажите полное имя вызываемого метода, включая имя родительского или базового класса (если есть только два класса, например). (См. пример 8.16.)

Пример 8.16. Вызов определенной версии виртуальной функции

#include <iostream>

using namespace std;

class Base {

public:

 virtual void foo() {cout << "Base::foo()" << endl;}

};

class Derived : public Base {

public:

 virtual void foo() {cout << "Derived::foo()" << endl;}

};

int main() {

 Derived* p = new Derived();

 p->foo();       // Вызов версии производного класса

 p->Base::foo(); // Вызов версии базового класса

}

Регулярное использование переопределения полиморфных возможностей C++ является плохой идеей, но иногда это требуется сделать. Как и в случае с большинством других методик С++, это по большей части вопрос синтаксиса. Когда требуется вызвать определенную версию виртуальной функции базового класса, просто укажите ее имя после имени этого класса, как это сделано в примере 8.16.

p->Base::foo();

Здесь будет вызвана версия foo, определенная в Base, а не та, которая определена в каком-то из подклассов Base, на который указывает p.

Глава 9

Исключения и безопасность

9.0. Введение

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

Первый рецепт описывает семантику C++ по выбрасыванию (throwing) и перехвату (catching) исключений и затем показывает, как создавать класс для представления исключений. Это является хорошей отправной точкой, если у вас мало или совсем нет опыта работы с исключениями. Здесь описываются также стандартные классы исключений, определенные в заголовочных файлах <stdexcept> и <exception>.

Остальные рецепты иллюстрируют методы оптимального использования исключений и попутно вводят несколько важных терминов. Программное обеспечение не станет хорошим, если вы будете просто выбрасывать исключение, когда происходит что-нибудь неожиданное, или перехватывать исключение только для того, чтобы напечатать сообщение об ошибке и завершить программу аварийно. Для эффективного использования средств C++ по обработке исключений вам придется создавать программный код, который предотвращает утечку ресурсов и обеспечивает четкий режим работы при выбрасывании исключения. Эти условия известны как базовые и строгие гарантии безопасности исключений. Я описываю методы, которые позволят вам обеспечить эти гарантии для конструкторов и различных функций-членов.

9.1. Создание класса исключения

Требуется создать свой собственный класс исключения, предназначенный для выбрасывания и перехвата исключений.

Вы можете выбрасывать (throw) или перехватывать (catch) любые типы С++, которые удовлетворяют некоторым простым требованиям, а именно имеют конструктор копирования и деструктор. Однако исключения являются сложными объектами, поэтому при проектировании класса, который представляет исключительные ситуации, необходимо рассмотреть ряд вопросов. Пример 9.1 показывает, каким может быть простой класс исключения.

Пример 9.1. Простой класс исключения

#include <iostream>

#include <string>

using namespace std;

class Exception {

public:

 Exception(const string& msg) : msg_(msg) {}

 ~Exception() {}

 string getMessage() const {return(msg_);}

private:

 string msg_;

};

void f() {

 throw(Exception("Mr. Sulu"));

}

int main() {

 try {

  f();

 } catch(Exception& e) {

  cout << "You threw an exception: " << e.getMessage() << endl;

 }

}

В языке C++ поддержка исключений обеспечивается при помощи трех ключевых слов: try, catch и throw. Они имеют следующий синтаксис.

try {

 // Что-нибудь, что может вызвать функцию "throw", например:

 throw(Exception("Uh-oh"));

} catch(Exception& e) {

 // Какие-нибудь полезные действия с объектом исключения е