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

Небезопасные типы в открытых базовых классах

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

Небезопасные типы в закрытых базовых классах

Вот это уже больше похоже на истину. Самый простой способ обеспечить безопасность типов - сделать ненадежный класс закрытым базовым классом безопасного шаблона.

class UnsafeNode { ListNode из предыдущего примера

private:

UnsafeNode* next;

void* data; public:

UnsafeNode(void* d, UnsafeNode* n); virtual ~UnsafeNode();

UnsafeNode* Next(); void* Data();

template <c1ass Type>

class SafeNode : private UnsafeNode {

public:

SafeNode(Type* d, SafeNode* n) : UnsafeNode(d, n) {} virtual ~SafeNode() { delete (Type*)Data(); }

SafeNode* Next() { return (SafeNode*)UnsafeNode::Next(); } Type* Data() { return (Type*)UnsafeNode::Data(); }

Мы добились чего хотели - базовый класс недоступен для клиентов производного шаблона. Приведенный пример демонстрирует еще один прием, связанный с пространствами имен C++. Нет необходимости создавать в производном классе новые имена для функций Next() и Data() только потому, что они отличаются типом возвращаемого значения; поскольку ни одна из этих функций не является виртуальной, производная версия скрывает базовую от клиентов. Некоторые компиляторы при попытке скрытия членов базовых классов укоризненно грозят пальцем, но для закрытого наследования это предупреждение абсолютно безобидно. После всех огорчений, доставляемых вам компилятором, бывает приятно отплатить ему той же монетой.

Один из недостатков закрытого наследования - необходимость дублирования всех функций базового класса, которые могут безопасно использоваться клиентами. Впрочем, это происходит не так уж часто и в любом случае не является слишком высокой ценой за дополнительную безопасность. Примером может послужить наша реализация функций Next() и Data() , за исключением того, что интерфейс идентичен интерфейсу закрытого базового класса.

Небезопасные типы в переменных класса

Следующим способом объединения двух классов является делегирование: вы создаете экземпляр небезопасного класса в качестве переменной параметризованного класса и поручаете ему всю

необходимую работу. Для обеспечения безопасности типов эта переменная класса делается невидимой для пользователя. Иногда эта задача не решается так просто; семантика оболочки нередко отличается от семантики переменной.

Рассмотрим знакомый пример со связанным списком UnsafeNode. Вместо закрытого наследования SafeNode от этого класса можно сделать UnsafeNode переменной класса SafeNode. Однако по имеющемуся SafeNode вам не удастся получить следующий SafeNode в списке! Попробуйте сами. Каждый UnsafeNode ссылается на другой UnsafeNode, а не на SafeNode. Возможное решение - использовать разную семантику для оболочки и содержимого.

В SafeList.h

class UnsafeNode; Предварительное объявление

template <c1ass Type>

class SafeList { Безопасная оболочка для UnsafeNode

private:

UnsafeNode* head; public:

SafeList() : head(NULL) {}

~SafeList();

UnsafeNode* Cursor(); Для итераций

Type* Next(UnsafeNode*&); Переход к следующему элементу

void De1eteAt(UnsafeNode*&); Удаление элемента в позиции курсора

void InsertFirst(Type*); Вставка в начало списка

void InsertBefore(UnsafeNode*&); Вставка перед позицией курсора

void InsertAfter(UnsafeNode*&); Вставка после позиции курсора

В SafeList.cpp

class UnsafeNode { ListNode из предыдущего примера

private:

UnsafeNode* next;

void* data; public:

UnsafeNode(void* d, UnsafeNode* n); virtual ~UnsafeNode();

UnsafeNode* Next(); void* Data();

Объект SafeList представляет весь список, а не отдельный элемент. Большинство операций (такие как InsertFirst) относятся к списку в целом, а не к отдельному элементу. Для операций, выполняемых с одним элементом, нам потребуется новая парадигма - курсор (маркер позиции). Чтобы перемещаться по списку, вы запрашиваете у него позицию курсора. Чтобы перейти к следующему элементу, вы передаете ссылку на указатель на курсор, которая обновляется объектом SafeList. Чтобы выполнить операцию с определенной позицией списка, вы передаете курсор, определяющий эту позицию. Обратите внимание: клиенту не нужно знать об UnsafeNode ничего, кроме самого факта его существования - предварительного объявления оказывается вполне достаточно. Концепция курсора будет подробно рассмотрена в следующих главах. А пока вы должны понять, что безопасная оболочка не сводится к нескольким параметрам и символам <>, разбросанным по программе, - мы переопределяем семантику структуры данных. Такая ситуация типична для ненадежных, рекурсивных структур данных и часто встречается в других контекстах.