C++. Сборник рецептов

8.0. Введение

Эта глава содержит решения проблем, часто возникающих при работе с классами С++. Рецепты по большей части независимы, но разбиты на две части, каждая из которых занимает примерно по половине главы. Первая половина главы содержит решения проблем, которые могут возникнуть при создании объектов классов, таких как использование функции для создания объекта (которая часто называется шаблоном фабрики) или использование конструкторов и деструкторов для управления ресурсами. Вторая половина содержит решения проблем, возникающих после создания объектов, таких как определение типа объекта во время выполнения, а также некоторые методики реализации наподобие создания интерфейса с помощью абстрактного базового класса.

Конечно, классы — это главная особенность С++, которая обеспечивает возможность объектно-ориентированного программирования, и с ними можно выполнять очень много разных действий. Эта глава не содержит рецептов, объясняющих основы классов: виртуальные функции (полиморфизм), наследование и инкапсуляцию. Я полагаю, что вы уже знакомы с этими основными принципами объектно-ориентированного проектирования независимо от используемого языка программирования. Напротив, целью этой главы является описание принципов некоторых механических сложностей, с которыми можно столкнуться при реализации объектно-ориентированного дизайна на С++.

Объектно-ориентированное проектирование и связанные с ним шаблоны проектирования — это обширный вопрос, и имеется большое количество различной литературы на эту тему. В этой главе я упоминаю названия только некоторых шаблонов проектирования, и это шаблоны, для которых возможности C++ обеспечивают элегантное или, возможно, не совсем очевидное решение. Если вы не знакомы с концепцией шаблонов проектирования, я рекомендую прочесть книгу Design Patterns (Addison Wesley), поскольку это полезная вещь при разработке программного обеспечения. Однако для этой главы знание шаблонов проектирования не требуется.

8.1. Инициализация переменных-членов класса

Требуется инициализировать переменные-члены, которые имеют встроенные типы, являются указателями или ссылками.

Для установки начальных значений переменных членов используйте список инициализации. Пример 8.1 показывает, как это делается для встроенных типов, указателей и ссылок.

Пример 8.1. Инициализация членов класса

#include 

using namespace std;

class Foo {

public:

 Foo() : counter_(0), str_(NULL) {}

 Foo(int c, string* p) : counter_(c), str_(p) {}

private:

 int counter_;

 string* str_;

};

int main() {

 string s = "bar";

 Foo(2, &s);

}

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

Простейшими объектами инициализации являются встроенные типы. Работать с

int

char

class Foo {

public:

 Foo() : counter_(0), str_(NULL) {}

 Foo(int c, string* p) : counter_(c), str_(p) {}

private:

 int counter_;

 string* str_;

};

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

Используя тот же класс

Foo

class Foo {

public:

 Foo() : counter_(0), str_(NULL), cls_(0) {}

 Foo(int с, string* p) :

  counter_(c), str_(p), cls_(0) {}

private:

 int counter_;

 string* str_;

 SomeClass cls_;

};

В конструкторе по умолчанию

Foo

cls_

Foo

cls_

cls_

cls_

try/catch

Ссылки более сложны: инициализация переменной-ссылки (и

const

Следующая запись в C++ недопустима.

int& x;

Это значит, что невозможно объявить переменную-ссылку без ее инициализации. Вместо этого ее требуется инициализировать каким-либо объектом. Для переменных, не являющихся членами класса, инициализация может выглядеть вот так.

int а;

int& x = a;

Это все замечательно, но приводит к возникновению проблемы при создании классов. Предположим, вам требуется переменная-член класса, являющаяся ссылкой, как здесь.

class HasARef {

public:

 int& ref;

};

Большинство компиляторов примет эту запись, но только до тех пор, пока вы не попытаетесь создать экземпляр этого класса, как здесь.

HasARef me;

В этот момент вы получите ошибку. Вот какую ошибку выдаст gcc.

error: structure 'me' with uninitialized reference members

(ошибка: структура 'me' с неинициализированными членами-ссылками)

Вместо этого следует использовать список инициализации.

class HasARef {

public:

 int &ref;

 HasARef(int &aref) : ref(aref) {}

};

Затем при создании экземпляра класса требуется указать переменную, на которую будет ссылаться переменная

ref

int var;

HasARef me(var);

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

Рецепт 9.2.

8.2. Использование функции для создания объектов (шаблон фабрики)

Вместо создания объекта в куче с помощью new вам требуется функция (член или самостоятельная), выполняющая создание объекта, тип которого определяется динамически. Такое поведение достигается с помощью шаблона проектирования Abstract Factory (абстрактная фабрика).

Здесь есть две возможности. Вы можете:

• создать функцию, которая создает экземпляр объекта в куче и возвращает указатель на этот объект (или обновляет переданный в нее указатель, записывая в него адрес нового объекта);

• создать функцию, которая создает и возвращает временный объект.

Пример 8.2 показывает оба этих способа. Класс

Session

new

SessionFactory

Пример 8.2. Функции, создающие объекты

#include 

class Session {};

class SessionFactory {

public:

 Session Create();

 Session* CreatePtr();

 void Create(Session*& p);

 // ...

};

// Возвращаем копию объекта в стеке

Session SessionFactory::Create() {

 Session s;

 return(s);

}

// Возвращаем указатель на объект в куче

Session* SessionFactory::CreatePtr() {

 return(new Session());

}

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

// нового объекта

void SessionFactory::Create(Session*& p) {

 p = new Session();

}

static SessionFactory f; // Единственный объект фабрики

int main() {

 Session* p1;

 Session* p2 = new Session();

 *p2 = f.Create();  // Просто присваиваем объект, полученный из Create

 p1 = f.CreatePtr(); // или полученный указатель на объект в куче

 f.Create(p1);    // или обновляем указатель новым адресом

}

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

new

Наиболее часто используют возврат адреса нового объекта в куче или обновление адреса указателя, переданного как аргумент. Их реализация показана в примере 8.2, и она тривиальна и не требует дальнейших пояснений. Однако возврат из функции целого объекта используется реже — возможно, потому, что это требует больших накладных расходов.

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

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

Если вы пишете функцию или метод, создающий объекты, то посмотрите также рецепт 8.12. Используя шаблоны, функций можно написать одну функцию, которая будет возвращать новый объект любого типа. Например:

template

T* createObject() {

 return(new T());

}

MyClass* p1 = createObject();

MyOtherClass* p2 = createObject();

// ...

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

Рецепт 8.12.

8.3. Использование конструкторов и деструкторов для управления ресурсами (RAII)

Для класса, представляющего некоторый ресурс, требуется использовать конструктор для получения этого ресурса и деструктор для его освобождения. Эта методика часто называется «получение ресурсов как инициализация» (resource acquisition is initialization — RAII).

Выделите или получите ресурс в конструкторе и освободите этот ресурс в деструкторе. Это снизит объем кода, который пользователь класса должен будет написать для обработки исключений. Простая иллюстрация этой методики показана в примере 8.3.

Пример 8.3. Использование конструкторов и деструкторов

#include 

#include 

using namespace std;

class Socket {

public:

 Socket(const string& hostname) {}

};

class HttpRequest {

public:

 HttpRequest(const string& hostname) :

  sock_(new Socket(hostname)) {}

 void send(string soapMsg) {sock << soapMsg;}

 ~HttpRequest() {delete sock_;}

private:

 Socket* sock_;

};

void sendMyData(string soapMsg, string host) {

 HttpRequest req(host);

 req.send(soapMsg);

 // Здесь делать ничего не требуется, так как когда req выходит

 // за диапазон, все очищается.

}

int main() {

 string s = "xml";

 sendMyData(s, "www.oreilly.com");

}

Гарантии, даваемые конструкторами и деструкторами, представляют собой удобный способ заставить компьютер выполнить всю очистку за вас. Обычно инициализация объекта и выделение используемых ресурсов производится в конструкторе, а очистка — в деструкторе. Это нормально. Но программисты имеют склонность использовать последовательность событий «создание-открытие-использование-закрытие», когда пользователю класса требуется выполнять явные открытия и закрытия ресурсов. Класс файла является хорошим примером.

Примерно так звучит обычный аргумент в пользу RAII. Я легко мог бы создать в примере 8.3 свой класс

HttpRequest

class HttpRequest {

public:

 HttpRequest();

 void open(const std::string& hostname);

 void send(std::string soapMsg);

 void close();

 ~HttpRequest();

private:

 Socket* sock_;

};

При таком подходе соответствующая версия

sendMyData

void sendMyData(std::string soapMsg, std::string host) {

 HttpRequest req;

 try {

  req.open();

  req.send(soapMsg);

  req.close();

 } catch (std::exception& e) {

  req.close(); // Do something useful...

 }

}

Здесь требуется выполнить больше работы без каких бы то ни было преимуществ. Этот дизайн заставляет пользователя писать больше кода и работать с исключениями, очищая ваш класс (при условии, что в деструкторе

close

Подход RAII имеет широкое применение, особенно когда требуется гарантировать, что при выбрасывании исключения будет выполнен «откат» каких-либо действий, позволяя при этом не загромождать код бесконечными

try/catch

void MyWindow : thisTakesALongTime() {

 StatusBarMessage("Copying files...");

 // ...

}

Все, что класс

StatusBarMessage

StatusBarMessage

thisTakesALongTime

RAII не является панацеей, но если вы его еще не использовали, то вы, скорее всего, найдете немало возможностей для его применения. Еще одним хорошим примером является блокировка. При использовании RAII для управления блокировками ресурсов, таких как потоки, объекты пулов, сетевые соединения и т.п., этот подход позволяет создавать более надежный код меньшего размера. На самом деле именно так многопоточная библиотека Boost реализует блокировки, делая программирование пользовательской части более простым. За обсуждением библиотеки Boost Threads обратитесь к главе 12.

8.4. Автоматическое добавление новых экземпляров класса в контейнер

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

Включите в класс статический член, являющийся контейнером, таким как

list

Пример 8.4. Отслеживание объектов

#include 

#include 

#include 

using namespace std;

class MyClass {

protected:

 int value_;

public:

 static list instances_;

 MyClass(int val);

 ~MyClass();

 static void showList();

};

list MyClass::instances_;

MyClass::MyClass(int val) {

 instances_.push_back(this);

 value_ = val;

}

MyClass::~MyClass() {

 list::iterator p =

  find(instances_.begin(), instances_.end(), this);

 if (p != instances_.end()) instances_.erase(p);

}

void MyClass::showList() {

 for (list::iterator p = instances_.begin();

  p != instances_.end(); ++p)

  cout << (*p)->value_ << endl;

}

int main() {

 MyClass a(1);

 MyClass b(10);

 MyClass с(100);

 MyClass::showList();

}

Пример 8.4 создаст следующий вывод.

1

10

100

Подход в примере 8.4 очень прост: используйте для хранения указателей на объекты

static list

list

При использовании любых членов-данных типа

static

static

Вы не обязаны использовать член

static

MyClass

Помните, что совместное использование глобального контейнера, как в примере 8.4, не будет работать, если объекты класса

MyClass

Если требуется отслеживать все экземпляры класса, можно также использовать шаблон фабрики. В целом это будет означать, что для создания нового объекта клиентский код вместо вызова оператора new должен будет вызывать функцию. За подробностями о том, как это делается, обратитесь к рецепту 8.2.

Рецепт 8.2.

8.5. Гарантия единственности копии переменной-члена

Имеется переменная-член, у которой должен быть только один экземпляр независимо от числа создаваемых экземпляров класса. Этот тип переменных-членов обычно называется статическими членами или переменными класса — в противоположность переменным экземпляра, свои копии которых создаются для каждого объекта класса.

Объявите переменную-член с ключевым словом

static

Пример 8.5. Использование статических переменных-членов

// Static.h

class OneStatic {

public:

 int getCount() {return count;}

 OneStatic();

protected:

 static int count;

};

// Static.cpp

#include "Static.h"

int OneStatic::count = 0;

OneStatic::OneStatic() {

 count++;

}

// StaticMain.cpp

#include 

#include "static.h"

using namespace std;

int main() {

 OneStatic a;

 OneStatic b;

 OneStatic c;

 cout << a.getCount() << endl;

 cout << b.getCount() << endl;

 cout << c.getCount() << endl;

}

static

static

static

Во-первых, при объявлении переменной требуется использовать ключевое слово

static

protected:

static int count;

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

int OneStatic::count = 0;

В примере 8.5 я поместил это определение в файл Static.cpp. Именно так вы и должны делать — не помещайте определение в заголовочный файл. Если это сделать, память будет выделена в каждом файле реализации, включающем этот заголовочный файл, и либо возникнут ошибки компиляции, либо, что хуже, в памяти появятся несколько экземпляров этой переменной. Это не то, что требуется при использовании переменной-члена

static

В главном файле StaticMain.cpp вы можете видеть то, что происходит. Создается несколько экземпляров класса

OneStatic

OneStatic

main

3

3

3

Каждый вызов

getCount

8.6. Определение типа объекта во время выполнения

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

Для запроса, на объект какого типа указывает адрес объекта, используйте идентификацию типов во время выполнения (обычно называемую просто RTTI — runtime type identification). Пример 8.6 показывает, как это делается.

Пример 8.6. Использование идентификации типов во время выполнения

#include 

#include 

using namespace std;

class Base {};

class Derived : public Base {};

int main() {

 Base b, bb;

 Derived d;

 // Используем typeid для проверки равенства типов

 if (typeid(b) == typeid(d)) { // No

  cout << "b и d имеют один и тот же тип.\n";

 }

 if (typeid(b) == typeid(bb)) { // Yes

  cout << "b и bb имеют один и тот же тип.\n";

 }

 it (typeid(a) == typeid(Derived)) { // Yes

  cout << "d имеет тип Derived.\n";

 }

}

Пример 8.6 показывает, как использовать оператор

typeid

typeid

type_info

if (typeid(b) == typeid(d)) {

Это выражение возвращает истину, если возвращаемые объекты

type_info

typeid

typeid

if (typeid(d) == typeid(Derived)) {

Это позволяет явно проверять определенный тип.

Вероятно, наиболее часто

typeid

type_info::name

std::cout << typeid(d).name() << std::endl;

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

name

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

Если

obj

X

obj

Y

Это плохой дизайн, потому что клиентский код теперь содержит избыточные зависимости от типов используемых объектов. Это также приводит к большой каше из if/then кода, который то и дело повторяется, если для объектов типов

X

Y

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

Рецепт 8.7.

8.7. Определение, является ли класс объекта подклассом другого класса

Имеется два объекта и требуется узнать, имеют ли их классы отношения на уровне базовый класс/производный класс, или они не связаны друг с другом.

Используйте оператор

dynamic_cast

Пример 8.7. Определение отношений классов

#include 

#include 

using namespace std;

class Base {

public:

 virtual ~Base() {} // Делаем класс полиморфным

};

class Derived : public Base {

public:

 virtual ~Derived() {}

};

int main() {

 Derived d;

 // Запрашиваем тип отношений

 if (dynamic_cast(&d)) {

  cout << "Derived является классом, производным от Base" << endl;

 } else {

  cout << "Derived HE является классом, производным от Base" << endl;

 }

}

Для запроса отношений между двумя типами используйте оператор

dynamic_cast

dynamic_cast

Base*

Derived

dynamic_cast(&d)

Derived

d

Base

Derived

Base

dynamic_cast

NULL

bad_cast

public

if (dynamic_cast(&d)) {

Здесь возвращается нe-

NULL

d

Base

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

#define IS_DERIVED_FROM(BaseClass, x) (dynamic_cast(&(x)))

//...

if (IS_DERIVED_FROM(Base, l)){//...

Но помните, что такая информация о типах не бесплатна, так как

dynamic_cast

Рецепт 8.6.

8.8. Присвоение каждому экземпляру класса уникального идентификатора

Требуется, чтобы каждый объект класса имел уникальный идентификатор.

Для отслеживания следующего доступного для использования идентификатора используйте статическую переменную-член. В конструкторе присвойте текущему объекту очередное доступное значение, а затем инкрементируйте статическую переменную. Чтобы понять, как это работает, посмотрите на пример 8.8.

Пример 8.8. Присвоение уникальных идентификаторов

#include 

class UniqueID {

protected:

 static int nextID;

public:

 int id;

 UniqueID();

 UniqueID(const UniqueID& orig);

 UniqueID& operator=(const UniqueID& orig);

};

int UniqueID::nextID = 0;

UniqueID::UniqueID() {

 id = ++nextID;

}

UniqueID::UniqueID(const UniqueID& orig) {

 id = orig.id;

}

UniqueID& UniqueID::operator=(const UniqueID& orig) {

 id = orig.id;

 return(*this);

}

int main() {

 UniqueID a;

 std::cout << a.id << std::endl;

 UniqueID b;

 std::cout << b.id << std::endl;

 UniqueID c;

 std::cout << c.id << std::endl;

}

Для отслеживания следующего доступного для использования идентификатора используйте статическую переменную. В примере 8.8 используется

static int

В данном случае идентификаторы не используются повторно до тех пор, пока не будет достигнуто максимально возможное для целого числа значение. При удалении объекта его уникальное значение пропадает либо до перезапуска программы, либо до переполнения значения идентификатора. Эта уникальность в программе может иметь несколько интересных преимуществ. Например, при работе с библиотекой управления памятью, которая перемещает блоки памяти и обновляет значения указателей, можно быть уверенным, что для каждого объекта будет сохранено его первоначальное уникальное значение. При использовании уникальных значений в сочетании с рецептом 8.4, но применении

map

list

static map instmap;

Таким образом любой код, который отслеживает идентификаторы объектов, всегда сможет найти его без необходимости хранить ссылку на него.

Но это еще не все. Рассмотрим случай, когда один из этих объектов требуется добавить в стандартный контейнер (

vector

list

set

Это означает, что требуется решить, как должны себя вести уникальные объекты. При создании объекта с уникальным идентификатором и добавлении его в контейнер у вас появятся два объекта с одним и тем же идентификатором при условии, что вы не переопределили оператор присвоения. В операторе присвоения и конструкторе копирования требуется выполнить те действия с уникальным значением, которые имеют смысл для вашего случая. Имеет ли смысл то, что объект в контейнере будет равен оригинальному объекту? Если да, то вполне подойдет стандартный конструктор копирования и оператор присвоения, но вы должны указать это явно, чтобы пользователи вашего класса знали, что вы делаете это намеренно, а не просто забыли, как работают контейнеры. Например, чтобы использовать одно и то же значение идентификатора, конструктор копирования и оператор присвоения должны выглядеть вот так.

UniqueID::UniqueID(const UniqueID& orig) {

 id = orig.id;

}

UniqueID& UniqueID::operator=(const UniqueID& orig) {

 id = orig.id;

 return(*this);

}

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

UniqueID::UniqueID(const UniqueID& orig) {

 id = ++nextID;

}

UniqueID& UniqueID::operator=(const UniqueID& orig) {

 id = ++nextID;

 return(*this);

}

Однако трудности еще не закончились. Если

UniqueID

Рецепт 8.3.

8.9. Создание Singleton-класса

Имеется класс, который должен иметь только один экземпляр, и требуется предоставить способ доступа к этому классу из клиентского кода таким образом, чтобы каждый раз возвращался именно этот единственный объект. Часто это называется шаблоном singleton или singleton-классом.

Создайте статический член, который указывает на текущий класс, ограничьте использование конструкторов для создания класса, сделав их

private

Пример 8.9. Создание singleton-класса

#include 

using namespace std;

class Singleton {

public:

 // С помощью этого клиенты получат доступ к единственному экземпляру

 static Singleton* getInstance();

 void setValue(int val) {value_ = val;}

 int getValue() {return(value_);}

protected:

 int value_;

private:

 static Singleton* inst_;  // Единственный экземпляр

 Singleton() : value_(0) {} // частный конструктор

 Singleton(const Singleton&);

 Singleton& operator=(const Singleton&);

};

// Определяем указатель

static Singleton Singleton* Singleton::inst_ = NULL;

Singleton* Singleton::getInstance() {

 if (inst_ == NULL) {

  inst_ = new Singleton();

 }

 return(inst_);

}

int main() {

 Singleton* p1 = Singleton::getInstance();

 p1->setValue(10);

 Singleton* p2 = Singleton::getInstance();

 cout << "Value = " << p2->getValue() << '\n';

}

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

Singleton

Когда принимается решение, что требуется только один экземпляр чего-либо, то на ум сразу должно приходить ключевое слово

static

static

static

private:

 static Singleton* inst_;

Чтобы клиентский код ничего про нее не знал, сделайте ее

private

NULL

Singleton* Singleton::inst_ = NULL;

Чтобы запретить клиентам создавать экземпляры этого класса, сделайте конструкторы

private

private:

Singleton() {}

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

Теперь, когда статическая переменная для хранения единственного объекта

Singleton

Singleton

Singleton

Singleton* Singleton::getInstance() {

 if (inst_ == NULL) {

  inst_ = new Singleton();

 }

 return(inst_);

}

Посмотрите, как это работает. Если указатель

static Singleton

NULL

Singleton

Singleton* p1 = Singleton::getInstance();

И если вы не хотите, чтобы клиенты работали с указателями, то можно возвращать ссылку.

Singleton& Singleton::getInstance() {

 if (inst_ == NULL) {

  inst_ = new Singleton();

 }

 return(*inst_);

}

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

Singleton

Рецепт 8.3.

8.10. Создание интерфейса с помощью абстрактного базового класса

Требуется определить интерфейс, который будет реализовываться производными классами, но концепция этого интерфейса является абстракцией и не должна наследоваться сама по себе.

Создайте абстрактный класс, который определяет интерфейс, объявляя, по крайней мере, одну из своих функций как чисто виртуальную (

virtual

Пример 8.10. Использование абстрактного базового класса

#include 

#include 

#include 

using namespace std;

class AbstractConfigFile {

public:

 virtual ~AbstractConfigFile() {}

 virtual void getKey(const string& header,

  const string& key, strings val) const = 0;

 virtual void exists(const string& header,

  const string& key, strings val) const = 0;

};

class TXTConfigFile : public AbstractConfigFile {

public:

 TXTConfigFile() : in_(NULL) {}

 TXTConfigFile(istream& in) : in_(&in) {}

 virtual ~TXTConfigFile() {}

 virtual void getKey(const string& header,

  const string& key, strings val) const {}

 virtual void exists(const string& header,

  const strings key, strings val) const {}

protected:

 istream* in_;

};

class MyAppClass {

public:

 MyAppClass() : config_(NULL) {}

 ~MyAppClass() {}

 void setConfigObj(const AbstractConfigFile* p) {config_ = p;}

 void myMethod();

private:

 const AbstractConfigFile* config_;

};

void MyAppClass::myMethod() {

 string val;

 config_->getKey("Foo", "Bar", val);

 // ...

}

int main() {

 ifstream in("foo.txt");

 TXTConfigFile cfg(in);

 MyAppClass m;

 m.setConfigObj(&cfg);

 m.myMethod();

}

Абстрактный базовый класс (часто называемый ABC — abstract base class) — это класс, для которого невозможно создать экземпляры, и, таким образом, он выполняет роль исключительно интерфейса. Класс является абстрактным, если он объявляет, по крайней мере, одну чисто виртуальную функцию или наследует функцию без реализации. Таким образом, если требуется создать экземпляр подкласса ABC, то он должен реализовать все виртуальные функции, что означает, что он будет поддерживать интерфейс, объявленный в ABC.

Подкласс, который наследуется от ABC (и реализует все его чисто виртуальные методы), поддерживает контракт, определенный интерфейсом. Рассмотрим классы

MyAppClass

TXTConfigFile

MyAppClass

AbstractConfigFile

const AbstractConfigFile* config_;

(Я сделал его

const

МуАррСlass

MyAppClass

setConfigObj

Когда приходит время использовать в

MyAppClass

MyAppClass::myMethod

AbstractConfigFile

TXTConfigFile

XMLConfigFile

AbstractConfigFile

Это полиморфное поведение является следствием наследования: если код ссылается на объект базового класса, вызов виртуальных функций для него приведет к их динамической переадресации и вызову правильных версий подкласса этого класса при условии, что реальный объект, на который ссылается код, является объектом этого подкласса. Но это происходит независимо от того, является ли базовый класс ABC или нет. Так в чем же разница?

Здесь имеется два различия. Чисто виртуальный класс (ABC, который не предоставляет никаких реализаций) служит только как контракт, которому должны подчиняться все подклассы, если требуется создавать их объекты. Часто это означает, что проверка на принадлежность подкласса к чисто интерфейсному классу может не сработать (что означает, что нельзя сказать, что объект подкласса является также и объектом базового класса), но что сработает проверка «ведет себя как». Это позволяет различать то, чем объект является, оттого, что он может сделать. Спасибо Супермену. Он человек, но он также и супергерой. Супергерои могут летать как птицы, но сказать, что супергерой — это птица, будет неверно. Иерархия классов для Супермена может выглядеть так, как это показано в примере 8.11.

Пример 8.11. Использование чистого интерфейса

class Person {

public:

 virtual void eat() = 0;

 virtual void sleep() = 0;

 virtual void walk() = 0;

 virtual void jump() = 0;

};

class IAirborne {

public:

 virtual void fly() = 0;

 virtual void up() = 0;

 virtual void down() = 0;

};

class Superhero : public Person, // Супергерой «является» человеком

       public IAirborne { // и летает

public:

 virtual void eat();

 virtual void sleep();

 virtual void walk();

 virtual void jump();

 virtual void fly();

 virtual void up();

 virtual void down();

 virtual ~Superhero();

};

void Superhero::fly() {

 // ...

}

// Все виртуальные методы реализуем в родительских классах супергероя...

int main() {

 Superhero superman;

 superman.walk(); // Супермен может ходить как человек

 superman.fly();  // или летать как птица

}

Однако летать может огромное количество объектов, так что не стоит называть этот интерфейс, например,

IBird

IAirborne

IAirborne

fly

up

down

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

AbstractConfigFile

AbstractConfigFile

Вот краткий перечень правил, касающихся абстрактных классов и чисто виртуальных функций. Класс является абстрактным, если:

• он объявляет, по крайней мере, одну чисто виртуальную функцию;

• он наследует, но не реализует, по крайней мере, одну чисто виртуальную функцию.

Создавать объекты абстрактного класса нельзя. Однако абстрактный класс может:

• содержать данные-члены;

• содержать не-виртуальные методы;

• предоставлять реализации для чисто виртуальных функций;

• делать большую часть из того, что может делать обычный класс.

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

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

Person

class Person {

public:

 virtual void eat() = 0;

 virtual void sleep() = 0;

 virtual void walk() = 0;

 virtual void jump() = 0;

 virtual void setFirstName(const string& s) {firstName_ = s;}

 virtual void setLastName(const string& s) {lastName_ = s;}

 virtual string getFirstName() {return(firstName_);}

 virtual string getLastName() {return(lastName_);}

protected:

 string firstName_;

 string lastName_;

};

Теперь, если подкласс

Superhero

string Superhero::getLastName() {

 return(Person::getLastName() + " (Superhero)");

}

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

=0

class Person {

 // ...

 virtual void setFirstName(const string& s) = 0;

 // ...

 Person::setFirstName(const string& s) {

  firstName_ = s;

 }

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

Наконец, если в базовом классе создать виртуальный деструктор (чистый или нет), то потребуется предоставить тело для него. Это требуется потому, что деструктор подкласса автоматически вызывается деструктором базового класса.

8.11. Написание шаблона класса

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

Для параметризации типов, которые используются при объявлении членов класса (и в других случаях), используйте шаблон класса. Это значит, что требуется написать класс с заполнителями типов, оставив, таким образом, выбор используемых типов на усмотрение пользователя класса. В примере 8.12 показан пример класса узла дерева, который может указывать на любой тип.

Пример 8.12. Написание шаблона класса

#include 

#include 

using namespace std;

template

class TreeNode {

public:

 TreeNode (const T& val) : val_(val), left_(NULL), right_(NULL) {}

 ~TreeNode() {

  delete left_;

  delete right_;

 }

 const T& getVal() const {return(val_);}

 void setVal(const T& val) {val_ = val;}

 void addChild(TreeNode* p) {

 const T& other = p->getVal();

  if (other > val_)

  if (rights)

   right_->addChild(p);

  else

   right_ = p;

  else

  if (left_)

   left_->addChild(p);

  else

   left_ = p;

 }

 const TreeNode* getLeft() {return(left_);}

 const TreeNode* getRight() {return(right_);}

private:

 T val_;

 TreeNode* left_;

 TreeNode* right_;

};

int main() {

 TreeNode node1("frank");

 TreeNode node2("larry");

 TreeNode node3("bill");

 node1.addChild(&node2);

 node1.addChild(&node3);

}

Шаблоны классов предоставляют способ параметризации типов, используемых в классе, так что эти типы могут указываться пользователем класса при создании объектов. Однако шаблоны могут оказаться несколько запутанными, так что позвольте мне перед разбором их работы пояснить приведенный выше пример.

Рассмотрим объявление шаблона класса

TreeNode

template class TreeNode {

//...

Часть

template

T

T

TreeNode

val_

T

T val_;

Здесь просто объявляется член класса с именем

val_

val_

int

float

MyClass

string

#define

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

val_

const T& getVal() const (return(val_);}

void setVal(const T& val) {val_ = val;}

getVal

const

val_

T

setVal

T

val_

getLeft

getRight

Теперь, когда

TreeNode

TreeNode

ТreeNode node1("frank");

TreeNode node2("larry");

TreeNode node3("bill");

Тип между угловыми скобками — это то, что используется вместо

T

TreeNode

T

string

TreeNode

TreeNode

template

T

string

Создание экземпляра шаблона для данного параметра типа аналогично созданию экземпляра объекта любого класса. Ключевое различие состоит в том, что создание экземпляра шаблона происходит в процессе компиляции, в то время как создание объекта класса происходит во время выполнения программы. Это означает, что если вместо

string

int

TreeNode intNode1(7);

TreeNode intNode2(11);

TreeNode intNode3(13);

Как и в случае с версией для

string

TreeNode

int

Некоторое время назад я сказал, что рассмотрю методы

getLeft

getRight

getLeft

getRight

const TreeNode* getLeft() {return(left_);}

const TreeNode* getRight() {return(right_);}

Здесь говорится, что каждый из этих методов возвращает указатель на экземпляр

TreeNode

T

TreeNode

string

getLeft

getRight

const TreeNode* getLeft() {return(left_);}

const TreeNode* getRight() {return(right_);}

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

int

short

template

class TreeNode {

 // ...

 N getNumChildren();

private:

 TreeNode() {}

 T val_;

 N numChildren_;

 // ...

Таким образом, человек, использующий ваш класс, может указать для отслеживания размера поддеревьев каждого узла

int

short

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

template

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

В примере 8.12 определение шаблона дается в том же месте, что и его объявление. Обычно это делается для экономии места, занимаемого примером, не в данном случае есть и еще одна причина. Шаблоны (классов или функций — см. рецепт 8.12) компилируются в двоичную форму только тогда, когда создается их экземпляр. Таким образом, невозможно создать объявление шаблона в заголовочном файле, а его реализацию — в исходном файле (т.е. .cpp) Причина заключается в том, что в нем нечего компилировать! Из этого правила имеются исключения, но обычно при написании шаблона класса его реализация должна помешаться в заголовочном файле или встраиваемом файле, который подключается заголовочным.

В этом случае требуется использовать несколько необычный синтаксис. Методы и другие части класса объявляются как в обычном классе, но при определении методов требуется включить дополнительные лексемы, которые говорят компилятору, что это части шаблона класса. Например,

getVal

template

const T& TreeNode::getVal() const {

 return(val_);

}

Тело функции выглядит точно так же.

Однако с шаблонами следует быть осторожными, так как если написать шаблон, который используется повсеместно, то можно получить раздувание кода, что случается, когда один и тот же шаблон с одними и теми же параметрами (например,

TreeNode

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

TreeNode

// common.cpp

template class TreeNode;

Соберите динамическую библиотеку с этим файлом, и после этого код, использующий

TreeNode

Шаблоны C++ (как классов, так и функций) — это очень обширная тема, и имеется огромное количество методик создания мощных, эффективных проектов на основе шаблонов. Великолепным примером шаблонов классов являются контейнеры из стандартной библиотеки, такие как

vector

list

set

Рецепт 8.12.

8.12. Написание шаблона метода класса

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

Используйте шаблон метода и объявите параметр шаблона для типа объекта. Небольшая иллюстрация приведена в примере 8.13.

Пример 8.13. Использование шаблона метода

class ObjectManager {

public:

 template T* gimmeAnObject();

 template

 void gimmeAnObject(T*& p);

};

template

T* ObjectManager::gimmeAnObject() {

 return(new T);

}

template

void ObjectManager::gimmeAnObject(T*& p) {

 p = new T;

}

class X { /*...*/ };

class Y { /* ... */ };

int main() {

 ObjectManager om;

 X* p1 = om.gimmeAnObject(); // Требуется указать параметр

 Y* p2 = om.gimmeAnObject(); // шаблона

 om.gimmeAnObject(p1); // Однако не здесь, так как компилятор может

 om.gimmeAnObject(p2); // догадаться о типе T по аргументам

}

При обсуждении шаблонов функций или классов слова «параметр» и «аргумент» становятся несколько двусмысленными. Имеется по два вида каждого: шаблона и функции. Параметры шаблона — это параметры в угловых скобках, например

T

Рассмотрим класс

ObjectManager

gimmeAnObject

new

Объявление шаблона метода требует, чтобы было использовано ключевое слово

template

template T* gimmeAnObject();

template void gimmeAnObject(T*& p);

Оба этих метода используют в качестве параметра шаблона

T

template

T* ObjectManager.:gimmeAnObject() {

 return(new T);

}

template

void ObjectManager::gimmeAnObject(T*& p) {

 p = new T;

}

Теперь есть пара способов вызвать эти шаблоны методов. Во-первых, их можно вызвать явно, используя параметры шаблона, как здесь.

X* p1 = om.gimmeAnObject();

X

gimmeAnObject

om.gimmeAnObject(p1);

Это работает благодаря тому, что компилятор может догадаться о

T

p1

X*

Шаблоны методов не имеют большой популярности при разработке на C++, но время от времени они оказываются очень полезны, так что следует знать, как создавать их. Я часто сталкиваюсь с необходимостью сдерживать себя, когда мне хочется использовать метод, который бы работал с типами, которые не связаны друг с другом механизмом наследования. Например, если есть метод

foo

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

Рецепт 8.11.

8.13. Перегрузка операторов инкремента и декремента

Имеется класс, для которого имеют смысл операции инкремента и декремента, и требуется перегрузить

operator++

operator--

Чтобы это сделать, перегрузите префиксную и постфиксную формы

++

--

Пример 8.14. Перегрузка инкремента и декремента

#include 

using namespace std;

class Score {

public:

 Score() : score_(0) {}

 Score(int i) : score_(i) {}

 Score& operator++() {

 // префикс

  ++score_;

  return(*this);

 }

 const Score operator++(int) {

  // постфикс

  Score tmp(*this);

  ++(*this); // Использование префиксного оператора

  return(tmp);

 }

 Score& operator--() {

  --score_;

  return(*this);

 }

 const Score operator--(int x) {

  Score tmp(*this);

  --(*this);

 return(tmp);

 }

 int getScore() const {return(score_);}

private:

 int score_;

};

int main() {

 Score player1(50);

 player1++;

 ++player1; // score = 52

 cout << "Счет = " << player1.getScore() << '\n';

 (--player1)--; // score_ = 50

 cout << "Счет = " << player1.getScore() << '\n';

}

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

Представьте себе инкремент целого числа. С помощью оператора

++

i

i++; // постфиксный

++i; // префиксный

Оба инкрементируют

i

i

i

i

enum

int

Чтобы добиться нужного эффекта, перегрузите

operator++

operator--

Score& operator++() { // префиксный

 ++score_;

 return(*this);

}

const Score operator++(int) { // постфиксный

 Score tmp(*this);

 ++(*this);

 return(tmp);

}

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

int

После этого класс

Score

int

Score player1(50);

player1++;

++player1; // score_ = 52

Вы, вероятно, заметили, что сигнатуры префиксной версии

operator++

void

(--player1)--;

Да, это странно, но она иллюстрирует этот момент. Если бы префиксный

operator--

foo(--player1);

Функция

foo

Score

operator--

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

Рецепт 8.14.

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

Balance& operator=(const Balance& other) {

 val_ = other.val_;

 return(*this);

}

Первое, на что вы должны обратить внимание, если не знакомы с перегрузкой операторов, — это синтаксис

operator=

operator[symbol]

symbol

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

++

--

Реализация всех арифметических операторов и оператора присвоения очень похожа, за исключением оператора присвоения, который не может быть отдельной функцией (т.е. он должен быть методом).

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

int i = 0;

i += 5;

После выполнения второй строки

int i

Balance checking(500.00), savings(23.91);

checking += 50;

Это означает, что следует ожидать, что после использования оператора

+=

checking

+=

Balance& operator+=(double other) {

 val_ += other;

 return(*this);

}

Для оператора присвоения список параметров — это то, что будет указано в операторе в его правой части. В данном случае используется целое число. Тело этой функции тривиально: все, что здесь делается, — это добавление аргумента к частной переменной-члену. Когда эта работа сделана, возвращается

*this

*this

void operator+=(double other) { // Не делайте так

 val += other;

}

Затем кто-то захочет использовать этот оператор для экземпляра класса и передать результат в другую функцию.

Balance moneyMarket(1000.00);

// ...

updateGeneralLeager(moneyMarket += deposit); // He скомпилируется

Это приведет к проблеме, так как

Balance::operator+=

void

updateGeneralLedger

[]

*this

Здесь обеспечивается работа операторов присвоения, выполняющих какие-то вычисления, но как насчет вычислений без присвоения? Еще один способ использовать арифметические операторы выглядит так.

int i = 0, j = 2;

i = j + 5;

В этом случае к значению

j

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

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

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

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

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

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

<<

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

Если вы решите перегрузить

<<

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

Рецепт 8.13.

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

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

p->method()

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

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

#include 

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