Страница:
7.1 Введение
Представим себе процесс написания некоторого универсалного средства (например, тип связанный список, таблица имен или планировщик для системы моделирования), которое преднаначается для использования многими разными людьми в различных обстоятельствах. Очевидно, что в кандидатах на роль таких средств недостатка нет, и выгоды от их стандартизации огроны. Кажется, любой опытный программист написал (и отладил) дюжину вариантов типов множества, таблицы имен, сортирующей функции и т.п., но оказывается, что каждый программист и кадая программа используют свою версию этих понятий, из-за чего программы слишком трудно читать, тяжело отлаживать и сложно модифицировать. Более того, в большой программе вполне может быть несколько копий идентичных (почти) частей кода для рабты с такими фундаментальными понятиями.
Причина этого хаоса частично состоит в том, что предствить такие общие понятия в языке программирования сложно с концептуальной точки зрения, а частично в том, что средства, обладающие достаточной общностью, налагают дополнительные расходы по памяти и/или по времени, что делает их неудобными для самых простых и наиболее напряженно используемых средств (связанные списки, вектора и т.п.), где они были бы наиболее полезны. Понятие производного класса в С++, описываемое в #7.2, не обеспечивают общего решения всех этих проблем, но оно дает способ справляться с довольно небольшим числом ваных случаев. Будет, например, показано, как определить эффетивный класс обобщенного связанного списка таким образом, чтобы все его версии разделяли код.
Написание общецелевых средств – задача непростая, и чато основной акцент в их разработке другой, чем при разработке программ специального назначения. Конечно, нет четкой границы между средствами общего и специального назначения, и к метдам и языковым средствам, которые описываются в этой главе, можно относиться так, что они становятся все более полезны с ростом объема и сложности создаваемых программ.
Причина этого хаоса частично состоит в том, что предствить такие общие понятия в языке программирования сложно с концептуальной точки зрения, а частично в том, что средства, обладающие достаточной общностью, налагают дополнительные расходы по памяти и/или по времени, что делает их неудобными для самых простых и наиболее напряженно используемых средств (связанные списки, вектора и т.п.), где они были бы наиболее полезны. Понятие производного класса в С++, описываемое в #7.2, не обеспечивают общего решения всех этих проблем, но оно дает способ справляться с довольно небольшим числом ваных случаев. Будет, например, показано, как определить эффетивный класс обобщенного связанного списка таким образом, чтобы все его версии разделяли код.
Написание общецелевых средств – задача непростая, и чато основной акцент в их разработке другой, чем при разработке программ специального назначения. Конечно, нет четкой границы между средствами общего и специального назначения, и к метдам и языковым средствам, которые описываются в этой главе, можно относиться так, что они становятся все более полезны с ростом объема и сложности создаваемых программ.
7.2 Производные Классы
Чтобы разделить задачи понимания аппарата языка и метдов его применения, знакомство с понятием производных классов делается в три этапа. Вначале с помощью небольших примеров, которые не надо воспринимать как реалистичные, будут описаны
сами средства языка (запись и семантика). После этого демонтрируются некоторые неочевидные применения производных класов, и, наконец, приводится законченная программа.
сами средства языка (запись и семантика). После этого демонтрируются некоторые неочевидные применения производных класов, и, наконец, приводится законченная программа.
7.2.1 Построение Производного Класса
Рассмотрим построение программы, которая имеет дело с людьми, служащими в некоторой фирме. Структура данных в этой программе может быть например такой:
struct employee (* // служащий char* name; // имя short age; // возраст short department; // подразделение int salary; // жалование employee* next; // ... *);
Список аналогичных служащих будет связываться через поле next. Теперь давайте определим менеджера:
struct manager (* // менеджер employee emp; // запись о менеджере как о служащем employee* group; // подчиненные люди // ... *);
Менеджер также является служащим; относящиеся к служащму employee данные хранятся в члене emp объекта manager. Для читающего это человека это, может быть, очевидно, но нет нчего выделяющего член emp для компилятора. Указатель на мнеджера (manager*) не является указателем на служащего (employee*), поэтому просто использовать один там, где требется другой, нельзя. В частности, нельзя поместить менеджера в список служащих, не написав для этого специальный код. Моно либо применить к manager* явное преобразование типа, либо поместить в список служащих адрес члена emp, но и то и другое мало элегантно и довольно неясно. Корректный подход состоит в том, чтобы установить, что менеджер является служащим с некторой добавочной информацией:
struct manager : employee (* employee* group; // ... *);
manager является производным от employee и, обратно, employee есть базовый класс для manager. Класс manager допонительно к члену group имеет члены класса employee (name, age и т.д.).
Имея определения employee и manager мы можем теперь содать список служащих, некоторые из которых являются менеджрами. Например:
void f() (* manager m1, m2; employee e1, e2; employee* elist; elist = amp;m1; // поместить m1, e1, m2 и e2 в elist m1.next = amp;e1; e1.next = amp;m2; m2.next = amp;e2; e2.next = 0; *)
Поскольку менеджер является служащим, manager* может ипользоваться как employee*. Однако служащий необязательно является менеджером, поэтому использовать employee* как manager* нельзя.
struct employee (* // служащий char* name; // имя short age; // возраст short department; // подразделение int salary; // жалование employee* next; // ... *);
Список аналогичных служащих будет связываться через поле next. Теперь давайте определим менеджера:
struct manager (* // менеджер employee emp; // запись о менеджере как о служащем employee* group; // подчиненные люди // ... *);
Менеджер также является служащим; относящиеся к служащму employee данные хранятся в члене emp объекта manager. Для читающего это человека это, может быть, очевидно, но нет нчего выделяющего член emp для компилятора. Указатель на мнеджера (manager*) не является указателем на служащего (employee*), поэтому просто использовать один там, где требется другой, нельзя. В частности, нельзя поместить менеджера в список служащих, не написав для этого специальный код. Моно либо применить к manager* явное преобразование типа, либо поместить в список служащих адрес члена emp, но и то и другое мало элегантно и довольно неясно. Корректный подход состоит в том, чтобы установить, что менеджер является служащим с некторой добавочной информацией:
struct manager : employee (* employee* group; // ... *);
manager является производным от employee и, обратно, employee есть базовый класс для manager. Класс manager допонительно к члену group имеет члены класса employee (name, age и т.д.).
Имея определения employee и manager мы можем теперь содать список служащих, некоторые из которых являются менеджрами. Например:
void f() (* manager m1, m2; employee e1, e2; employee* elist; elist = amp;m1; // поместить m1, e1, m2 и e2 в elist m1.next = amp;e1; e1.next = amp;m2; m2.next = amp;e2; e2.next = 0; *)
Поскольку менеджер является служащим, manager* может ипользоваться как employee*. Однако служащий необязательно является менеджером, поэтому использовать employee* как manager* нельзя.
7.2.2 Функции Члены
Просто структуры данных вроде employee и manager на смом деле не столь интересны и часто не особенно полезны, потому рассмотрим, как добавить в них функции. Например:
class employee (* char* name; // ... public: employee* next; void print(); // ... *);
class manager : public employee (* // ... public: void print(); // ... *);
Надо ответить на некоторые вопросы. Как может функция член производного класса manager использовать члены его базвого класса employee? Как члены базового класса employee мгут использовать функции члены производного класса manager? Какие члены базового класса employee может использовать фунция не член на объекте типа manager? Каким образом програмист может повлиять на ответы на эти вопросы, чтобы удовлеворить требованиям приложения?
Рассмотрим:
void manager::print() (* cout «„ " имя " «« name «« «\n“; // ... *)
Член производного класса может использовать открытое имя из своего базового класса так же, как это могут делать другие члены последнего, то есть без указания объекта. Предполагаеся, что на объект указывает this, поэтому (корректной) ссыкой на имя name является this-»name. Однако функция manager:: print компилироваться не будет, член производного класса не имеет никакого особого права доступа к закрытым членам его базового класса, поэтому для нее name недоступно.
Это многим покажется удивительным, но представьте себе другой вариант: что функция член могла бы обращаться к закртым членам своего базового класса. Возможность, позволяющая программисту получать доступ к закрытой части класса просто с помощью вывода из него другого класса, лишила бы понятие зарытого члена всякого смысла. Более того, нельзя было бы унать все использования закрытого имени, посмотрев на функции, описанные как члены и друзья этого класса. Пришлось бы проврять каждый исходный файл во всей программе на наличие в нем производных классов, потом исследовать каждую функцию этих классов, потом искать все классы, производные от этих класов, и т.д. Это по меньшей мере утомительно и скорее всего нереально.
С другой стороны, можно ведь использовать механизм friend, чтобы предоставить такой доступ или отдельным функцям, или всем функциям отдельного класса (как описывается в #5.3). Например:
class employee (* friend void manager::print(); // ... *);
решило бы проблему с manager::print(), и
class employee (* friend class manager; // ... *);
сделало бы доступным каждый член employee для всех фунций класса manager. В частности, это сделает name доступным для manager::print().
Другое, иногда более прозрачное решение для производного класса – использовать только открытые члены его базового класса. Например:
void manager::print() (* employee::print(); // печатает информацию о служащем // ... // печатает информацию о менеджере *)
Заметьте, что надо использовать ::, потому что print() была переопределена в manager. Такое повторное использование имен типично. Неосторожный мог бы написать так:
void manager::print() (* print(); // печатает информацию о служащем // ... // печатает информацию о менеджере *)
и обнаружить, что программа после вызова manager::print() неожиданно попадает в последовательность ркурсивных вызовов.
class employee (* char* name; // ... public: employee* next; void print(); // ... *);
class manager : public employee (* // ... public: void print(); // ... *);
Надо ответить на некоторые вопросы. Как может функция член производного класса manager использовать члены его базвого класса employee? Как члены базового класса employee мгут использовать функции члены производного класса manager? Какие члены базового класса employee может использовать фунция не член на объекте типа manager? Каким образом програмист может повлиять на ответы на эти вопросы, чтобы удовлеворить требованиям приложения?
Рассмотрим:
void manager::print() (* cout «„ " имя " «« name «« «\n“; // ... *)
Член производного класса может использовать открытое имя из своего базового класса так же, как это могут делать другие члены последнего, то есть без указания объекта. Предполагаеся, что на объект указывает this, поэтому (корректной) ссыкой на имя name является this-»name. Однако функция manager:: print компилироваться не будет, член производного класса не имеет никакого особого права доступа к закрытым членам его базового класса, поэтому для нее name недоступно.
Это многим покажется удивительным, но представьте себе другой вариант: что функция член могла бы обращаться к закртым членам своего базового класса. Возможность, позволяющая программисту получать доступ к закрытой части класса просто с помощью вывода из него другого класса, лишила бы понятие зарытого члена всякого смысла. Более того, нельзя было бы унать все использования закрытого имени, посмотрев на функции, описанные как члены и друзья этого класса. Пришлось бы проврять каждый исходный файл во всей программе на наличие в нем производных классов, потом исследовать каждую функцию этих классов, потом искать все классы, производные от этих класов, и т.д. Это по меньшей мере утомительно и скорее всего нереально.
С другой стороны, можно ведь использовать механизм friend, чтобы предоставить такой доступ или отдельным функцям, или всем функциям отдельного класса (как описывается в #5.3). Например:
class employee (* friend void manager::print(); // ... *);
решило бы проблему с manager::print(), и
class employee (* friend class manager; // ... *);
сделало бы доступным каждый член employee для всех фунций класса manager. В частности, это сделает name доступным для manager::print().
Другое, иногда более прозрачное решение для производного класса – использовать только открытые члены его базового класса. Например:
void manager::print() (* employee::print(); // печатает информацию о служащем // ... // печатает информацию о менеджере *)
Заметьте, что надо использовать ::, потому что print() была переопределена в manager. Такое повторное использование имен типично. Неосторожный мог бы написать так:
void manager::print() (* print(); // печатает информацию о служащем // ... // печатает информацию о менеджере *)
и обнаружить, что программа после вызова manager::print() неожиданно попадает в последовательность ркурсивных вызовов.
7.2.3 Видимость
Класс employee стал открытым (public) базовым классом класса manager в результате описания:
class manager : public employee (* // ... *);
Это означает, что открытый член класса employee является также и открытым членом класса manager. Например:
void clear(manager* p) (* p-»next = 0; *)
будет компилироваться, так как next – открытый член и employee и manager'а. Альтернатива – можно определить закртый (private) класс, просто опустив в описании класса слово public:
class manager : employee (* // ... *);
Это означает, что открытый член класса employee является закрытым членом класса manager. То есть, функции члены класса manager могут как и раньше использовать открытые члены класса employee, но для пользователей класса manager эти члены ндоступны. В частности, при таком описании класса manager функция clear() компилироваться не будет. Друзья производного класса имеют к членам базового класса такой же доступ, как и функции члены.
Поскольку, как оказывается, описание открытых базовых классов встречается чаще описания закрытых, жалко, что описние открытого базового класса длиннее описания закрытого. Это, кроме того, служит источником запутывающих ошибок у нчинающих.
Когда описывается производная struct, ее базовый класс по умолчанию является public базовым классом. То есть,
struct D : B (* ...
означает
class D : public B (* public: ...
Отсюда следует, что если вы не сочли полезным то сокртие данных, которое дают class, public и friend, вы можете просто не использовать эти ключевые слова и придерживаться struct. Такие средства языка, как функции члены, конструкторы и перегрузка операций, не зависят от механизма сокрытия даных.
Можно также объявить некоторые, но не все, открытые члны базового класса открытыми членами производного класса. Например:
class manager : employee (* // ... public: // ... employee::name; employee::department; *);
Запись
имя_класса :: имя_члена ;
не вводит новый член, а просто делает открытый член бзового класса открытым для производного класса. Теперь name и department могут использоваться для manager'а, а salary и age – нет. Естественно, сделать закрытый член базового класса окрытым членом производного класса невозможно. Невозможно с помощью этой записи также сделать открытыми перегруженные имена.
Подытоживая, можно сказать, что вместе с предоставлением средств дополнительно к имеющимся в базовом классе, произвоный класс можно использовать для того, чтобы сделать средства (имена) недоступными для пользователя. Другими словами, с пмощью производного класса можно обеспечивать прозрачный, плупрозрачный и непрозрачный доступ к его базовому классу.
class manager : public employee (* // ... *);
Это означает, что открытый член класса employee является также и открытым членом класса manager. Например:
void clear(manager* p) (* p-»next = 0; *)
будет компилироваться, так как next – открытый член и employee и manager'а. Альтернатива – можно определить закртый (private) класс, просто опустив в описании класса слово public:
class manager : employee (* // ... *);
Это означает, что открытый член класса employee является закрытым членом класса manager. То есть, функции члены класса manager могут как и раньше использовать открытые члены класса employee, но для пользователей класса manager эти члены ндоступны. В частности, при таком описании класса manager функция clear() компилироваться не будет. Друзья производного класса имеют к членам базового класса такой же доступ, как и функции члены.
Поскольку, как оказывается, описание открытых базовых классов встречается чаще описания закрытых, жалко, что описние открытого базового класса длиннее описания закрытого. Это, кроме того, служит источником запутывающих ошибок у нчинающих.
Когда описывается производная struct, ее базовый класс по умолчанию является public базовым классом. То есть,
struct D : B (* ...
означает
class D : public B (* public: ...
Отсюда следует, что если вы не сочли полезным то сокртие данных, которое дают class, public и friend, вы можете просто не использовать эти ключевые слова и придерживаться struct. Такие средства языка, как функции члены, конструкторы и перегрузка операций, не зависят от механизма сокрытия даных.
Можно также объявить некоторые, но не все, открытые члны базового класса открытыми членами производного класса. Например:
class manager : employee (* // ... public: // ... employee::name; employee::department; *);
Запись
имя_класса :: имя_члена ;
не вводит новый член, а просто делает открытый член бзового класса открытым для производного класса. Теперь name и department могут использоваться для manager'а, а salary и age – нет. Естественно, сделать закрытый член базового класса окрытым членом производного класса невозможно. Невозможно с помощью этой записи также сделать открытыми перегруженные имена.
Подытоживая, можно сказать, что вместе с предоставлением средств дополнительно к имеющимся в базовом классе, произвоный класс можно использовать для того, чтобы сделать средства (имена) недоступными для пользователя. Другими словами, с пмощью производного класса можно обеспечивать прозрачный, плупрозрачный и непрозрачный доступ к его базовому классу.
7.2.4 Указатели
Если производный класс derived имеет открытый базовый класс base, то указатель на derived можно присваивать перменной типа указатель на base не используя явное преобразовние типа. Обратное преобразование, указателя на base в указтель на derived, должно быть явным. Например:
class base (* /* ... */ *); class derived : public base (* /* ... */ *);
derived m; base* pb = amp;m; // неявное преобразование derived* pd = pb; // ошибка: base* не является derived* pd = (derived*)pb; // явное преобразование
Иначе говоря, объект производного класса при работе с ним через указатель и можно рассматривать как объект его бзового класса. Обратное неверно.
Будь base закрытым базовым классом класса derived, неяное преобразование derived* в base* не делалось бы. Неявное преобразование не может в этом случае быть выполнено, потому что к открытому члену класса base можно обращаться через укзатель на base, но нельзя через указатель на derived:
class base (* int m1; public: int m2; // m2 – открытый член base *);
class derived : base (* // m2 – НЕ открытый член derived *);
derived d; d.m2 = 2; // ошибка: m2 из закрытой части класса base* pb = amp;d; // ошибка: (закрытый base) pb-»m2 = 2; // ok pb = (base*) amp;d; // ok: явное преобразование pb-»m2 = 2; // ok
Помимо всего прочего, этот пример показывает, что ипользуя явное приведение к типу можно сломать правила защиты. Ясно, делать это не рекомендуется, и это приносит программиту заслуженную «награду». К несчастью , недисциплинированное использование явного преобразования может создать адские уловия для невинных жертв, эксплуатирующих программу, в котрой это делается. Но, к счастью, нет способа воспользоваться приведением для получения доступа к закрытому имени m1. Зарытый член класса может использоваться только членами и друзьями этого класса.
class base (* /* ... */ *); class derived : public base (* /* ... */ *);
derived m; base* pb = amp;m; // неявное преобразование derived* pd = pb; // ошибка: base* не является derived* pd = (derived*)pb; // явное преобразование
Иначе говоря, объект производного класса при работе с ним через указатель и можно рассматривать как объект его бзового класса. Обратное неверно.
Будь base закрытым базовым классом класса derived, неяное преобразование derived* в base* не делалось бы. Неявное преобразование не может в этом случае быть выполнено, потому что к открытому члену класса base можно обращаться через укзатель на base, но нельзя через указатель на derived:
class base (* int m1; public: int m2; // m2 – открытый член base *);
class derived : base (* // m2 – НЕ открытый член derived *);
derived d; d.m2 = 2; // ошибка: m2 из закрытой части класса base* pb = amp;d; // ошибка: (закрытый base) pb-»m2 = 2; // ok pb = (base*) amp;d; // ok: явное преобразование pb-»m2 = 2; // ok
Помимо всего прочего, этот пример показывает, что ипользуя явное приведение к типу можно сломать правила защиты. Ясно, делать это не рекомендуется, и это приносит программиту заслуженную «награду». К несчастью , недисциплинированное использование явного преобразования может создать адские уловия для невинных жертв, эксплуатирующих программу, в котрой это делается. Но, к счастью, нет способа воспользоваться приведением для получения доступа к закрытому имени m1. Зарытый член класса может использоваться только членами и друзьями этого класса.
7.2.5 Иерархия Типов
Производный класс сам может быть базовым классом. Например:
class employee (* ... *); class secretary : employee (* ... *); class manager : employee (* ... *); class temporary : employee (* ... *); class consultant : temporary (* ... *); class director : manager (* ... *); class vice_president : manager (* ... *); class president : vice_president (* ... *);
Такое множество родственных классов принято называть ирархией классов. Поскольку можно выводить класс только из оного базового класса, такая иерархия является деревом и не может быть графом более общей структуры. Например:
class temporary (* ... *); class employee { ... *); class secretary : employee (* ... *);
// не С++: class temporary_secretary : temporary : secretary(* ... *); class consultant : temporary : employee (* ... *);
И этот факт вызывает сожаление, потому что направленный ациклический граф производных классов был бы очень полезен. Такие структуры описать нельзя, но можно смоделировать с пмощью членов соответствующих типов. Например:
class temporary (* ... *); class employee (* ... *); class secretary : employee (* ... *);
// Альтернатива: class temporary_secretary : secretary (* temporary temp; ... *); class consultant : employee (* temporary temp; ... *);
Это выглядит неэлегантно и страдает как раз от тех пролем, для преодоления которых были изобретены производные классы. Например, поскольку consultant не является произвоным от temporary, consultant'а нельзя помещать с список врменных служащих (temporary employee), не написав специальный код. Однако во многих полезных программах этот метод успешно используется.
class employee (* ... *); class secretary : employee (* ... *); class manager : employee (* ... *); class temporary : employee (* ... *); class consultant : temporary (* ... *); class director : manager (* ... *); class vice_president : manager (* ... *); class president : vice_president (* ... *);
Такое множество родственных классов принято называть ирархией классов. Поскольку можно выводить класс только из оного базового класса, такая иерархия является деревом и не может быть графом более общей структуры. Например:
class temporary (* ... *); class employee { ... *); class secretary : employee (* ... *);
// не С++: class temporary_secretary : temporary : secretary(* ... *); class consultant : temporary : employee (* ... *);
И этот факт вызывает сожаление, потому что направленный ациклический граф производных классов был бы очень полезен. Такие структуры описать нельзя, но можно смоделировать с пмощью членов соответствующих типов. Например:
class temporary (* ... *); class employee (* ... *); class secretary : employee (* ... *);
// Альтернатива: class temporary_secretary : secretary (* temporary temp; ... *); class consultant : employee (* temporary temp; ... *);
Это выглядит неэлегантно и страдает как раз от тех пролем, для преодоления которых были изобретены производные классы. Например, поскольку consultant не является произвоным от temporary, consultant'а нельзя помещать с список врменных служащих (temporary employee), не написав специальный код. Однако во многих полезных программах этот метод успешно используется.
7.2.6 Конструкторы и Деструкторы
Для некоторых производных классов нужны конструкторы. Если у базового класса есть конструктор, он должен вызыватся, и если для этого конструктора нужны параметры, их надо предоставить. Например:
class base (* // ... public: base(char* n, short t); ~base(); *);
class derived : public base (* base m; public: derived(char* n); ~derived(); *);
Параметры конструктора базового класса специфицируются в определении конструктора производного класса. В этом смысле базовый класс работает точно также, как неименованный член производного класса (см. #5.5.4). Например:
derived::derived(char* n) : (n,10), m(«member»,123) (* // ... *)
Объекты класса конструируются снизу вверх: сначала базвый, потом члены, а потом сам производный класс. Уничтожаются они в обратном порядке: сначала сам производный класс, потом члены а потом базовый.
class base (* // ... public: base(char* n, short t); ~base(); *);
class derived : public base (* base m; public: derived(char* n); ~derived(); *);
Параметры конструктора базового класса специфицируются в определении конструктора производного класса. В этом смысле базовый класс работает точно также, как неименованный член производного класса (см. #5.5.4). Например:
derived::derived(char* n) : (n,10), m(«member»,123) (* // ... *)
Объекты класса конструируются снизу вверх: сначала базвый, потом члены, а потом сам производный класс. Уничтожаются они в обратном порядке: сначала сам производный класс, потом члены а потом базовый.
7.2.7 Поля Типа
Чтобы использовать производные классы не просто как удобную сокращенную запись в описаниях, надо разрешить следющую проблему: Если задан указатель типа base*, какому проиводному типу в действительности принадлежит указываемый обект? Есть три основных способа решения этой проблемы:
1. Обеспечить, чтобы всегда указывались только объекты одного типа (#7.3.3),
2. Поместить в базовый класс поле типа, которое смогут просматривать функции и
3. Использовать виртуальные функции (#7.2.8).
Обыкновенно указатели на базовые классы используются при разработке контейнерных (или вмещающих) классов: множество, вектор, список и т.п. В этом случае решение 1 дает однородные списки, то есть списки объектов одного типа. Решения 2 и 3 можно использовать для построения неоднородных списков, то есть списков объектов (указателей на объекты) нескольких раличных типов. Решение 3 – это специальный вариант решения 2 с гарантией типа.
Давайте сначала исследуем простое решение с помощью поля типа, то есть решение 2. Пример со служащими и менеджерами можно было бы переопределить так:
enum empl_type (* M, E *);
struct employee (* empl_type type; employee* next; char* name; short department; // ... *);
struct manager : employee (* employee* group; short level; // уровень *);
Имея это, мы можем теперь написать функцию, которая пчатает информацию о каждом служащем:
void print_employee(employee* e) (* switch (e-»type) (* case E: cout «„ e-“name „„ „\t“ „„ e-“department „„ „\n“; // ... break; case M: cout „« e-“name «« «\t“ «« e-“department «« «\n“; // ... manager* p = (manager*)e; cout «« " уровень " «« p-“level «« «\n“; // ... break;
*) *)
и воспользоваться ею для того, чтобы напечатать список служащих:
void f() (* for (; ll; ll=ll-»next) print_employee(ll); *)
Это прекрасно работает,особенно в небольшой программе, написанной одним человеком, но имеет тот коренной недостаток, что неконтролируемым компилятором образом зависит от того, как программист работает с типами. В больших программах это обычно приводит к ошибкам двух видов. Первый – это невыполнние проверки поля типа, второй – когда не все случаи case пмещаются в переключатель switch, как в предыдущем примере. Оба избежать достаточно легко , когда программу сначала пишут на бумаге, но при модификации нетривиальной программы, осбенно написанной другим человеком, очень трудно избежать как того, так и другого. Часто от этих сложностей становится труднее уберечься из-за того, что функции вроде print() часто бывают организованы так, чтобы пользоваться общностью класов, с которыми они работают. Например:
void print_employee(employee* e) (* cout «„ e-“name „„ „\t“ „„ e-“department „« «\n“; // ... if (e-“type == M) (* manager* p = (manager*)e; cout «« " уровень " «« p-“level «« «\n“; // ... *) *)
Отыскание всех таких операторов if, скрытых внутри болшой функции, которая работает с большим числом производных классов, может оказаться сложной задачей, и даже когда все они найдены, бывает нелегко понять, что же в них делается.
1. Обеспечить, чтобы всегда указывались только объекты одного типа (#7.3.3),
2. Поместить в базовый класс поле типа, которое смогут просматривать функции и
3. Использовать виртуальные функции (#7.2.8).
Обыкновенно указатели на базовые классы используются при разработке контейнерных (или вмещающих) классов: множество, вектор, список и т.п. В этом случае решение 1 дает однородные списки, то есть списки объектов одного типа. Решения 2 и 3 можно использовать для построения неоднородных списков, то есть списков объектов (указателей на объекты) нескольких раличных типов. Решение 3 – это специальный вариант решения 2 с гарантией типа.
Давайте сначала исследуем простое решение с помощью поля типа, то есть решение 2. Пример со служащими и менеджерами можно было бы переопределить так:
enum empl_type (* M, E *);
struct employee (* empl_type type; employee* next; char* name; short department; // ... *);
struct manager : employee (* employee* group; short level; // уровень *);
Имея это, мы можем теперь написать функцию, которая пчатает информацию о каждом служащем:
void print_employee(employee* e) (* switch (e-»type) (* case E: cout «„ e-“name „„ „\t“ „„ e-“department „„ „\n“; // ... break; case M: cout „« e-“name «« «\t“ «« e-“department «« «\n“; // ... manager* p = (manager*)e; cout «« " уровень " «« p-“level «« «\n“; // ... break;
*) *)
и воспользоваться ею для того, чтобы напечатать список служащих:
void f() (* for (; ll; ll=ll-»next) print_employee(ll); *)
Это прекрасно работает,особенно в небольшой программе, написанной одним человеком, но имеет тот коренной недостаток, что неконтролируемым компилятором образом зависит от того, как программист работает с типами. В больших программах это обычно приводит к ошибкам двух видов. Первый – это невыполнние проверки поля типа, второй – когда не все случаи case пмещаются в переключатель switch, как в предыдущем примере. Оба избежать достаточно легко , когда программу сначала пишут на бумаге, но при модификации нетривиальной программы, осбенно написанной другим человеком, очень трудно избежать как того, так и другого. Часто от этих сложностей становится труднее уберечься из-за того, что функции вроде print() часто бывают организованы так, чтобы пользоваться общностью класов, с которыми они работают. Например:
void print_employee(employee* e) (* cout «„ e-“name „„ „\t“ „„ e-“department „« «\n“; // ... if (e-“type == M) (* manager* p = (manager*)e; cout «« " уровень " «« p-“level «« «\n“; // ... *) *)
Отыскание всех таких операторов if, скрытых внутри болшой функции, которая работает с большим числом производных классов, может оказаться сложной задачей, и даже когда все они найдены, бывает нелегко понять, что же в них делается.
7.2.8 Виртуальные Функции
Виртуальные функции преодолевают сложности решения с пмощью полей типа, позволяя программисту описывать в базовом классе функции, которые можно переопределять в любом проиводном классе. Компилятор и загрузчик обеспечивают правильное соответствие между объектами и применяемыми к ним функциями. Например:
struct employee (* employee* next; char* name; short department; // ... virtual void print(); *);
Ключевое слово virtual указывает, что могут быть разлиные варианты функции print() для разных производных классов, и что поиск среди них подходящей для каждого вызова print() является задачей компилятора. Тип функции описывается в базвом классе и не может переописываться в производном классе. Виртуальная функция должна быть определена для класса, в ктором она описана впервые. Например:
void employee::print() (* cout «„ e-“name „„ „\t“ «« e-“department «« «\n“; // ... *)
Виртуальная функция может, таким образом, использоваться даже в том случае, когда нет производных классов от ее класа, и в производном классе, в котором не нужен специальный вариант виртуальной функции, ее задавать не обязательно. Просто при выводе класса соответствующая функция задается в том случае, если она нужна. Например:
struct manager : employee (* employee* group; short level; // ... void print(); *);
void manager::print() (* employee::print(); cout «„ „\tуровень“ «« level «« «\n“; // ... *)
Функция print_employee() теперь не нужна, поскольку ее место заняли функции члены print(), и теперь со списком слжащих можно работать так:
void f(employee* ll) (* for (; ll; ll=ll-»next) ll-»print(); *)
Каждый служащий будет печататься в соответствии с его типом. Например:
main() (* employee e; e.name = «Дж.Браун»; e.department = 1234; e.next = 0; manager m; m.name = «Дж.Смит»; e.department = 1234; m.level = 2; m.next = amp;e; f( amp;m); *)
выдаст
Дж.Смит 1234 уровень 2 Дж.Браун 1234
Заметьте, что это будет работать даже в том случае, если f() была написана и откомпилирована еще до того, как проиводный класс manager был задуман! Очевидно, при реализации этого в каждом объекте класса employee сохраняется некоторая информация о типе. Занимаемого для этого пространства (в ткущей реализации) как раз хватает для хранения указателя. Это пространство занимается только в объектах классов с виртуалными функциями, а не во всех объектах классов и даже не во
всех объектах производных классов. Вы платите эту пошлину только за те классы, для которых описали виртуальные функции.
Вызов функции с помощью операции разрешения области вдимости ::, как это делается в manager::print(), гарантирует, что механизм виртуальных функций применяться не будет. Иначе manager::print() подвергалось бы бесконечной рекурсии. Примнение уточненного имени имеет еще один эффект, который может оказаться полезным: если описанная как virtual функция описна еще и как inline (в чем ничего необычного нет), то там, где в вызове применяется ::, может применяться inline-подстновка. Это дает программисту эффективный способ справляться с теми важными специальными случаями, когда одна виртуальная функция вызывает другую для того же объекта. Поскольку тип объекта был определен при вызове первой виртуальной функции, обычно его не надо снова динамически определять другом вызове для того же объекта.
struct employee (* employee* next; char* name; short department; // ... virtual void print(); *);
Ключевое слово virtual указывает, что могут быть разлиные варианты функции print() для разных производных классов, и что поиск среди них подходящей для каждого вызова print() является задачей компилятора. Тип функции описывается в базвом классе и не может переописываться в производном классе. Виртуальная функция должна быть определена для класса, в ктором она описана впервые. Например:
void employee::print() (* cout «„ e-“name „„ „\t“ «« e-“department «« «\n“; // ... *)
Виртуальная функция может, таким образом, использоваться даже в том случае, когда нет производных классов от ее класа, и в производном классе, в котором не нужен специальный вариант виртуальной функции, ее задавать не обязательно. Просто при выводе класса соответствующая функция задается в том случае, если она нужна. Например:
struct manager : employee (* employee* group; short level; // ... void print(); *);
void manager::print() (* employee::print(); cout «„ „\tуровень“ «« level «« «\n“; // ... *)
Функция print_employee() теперь не нужна, поскольку ее место заняли функции члены print(), и теперь со списком слжащих можно работать так:
void f(employee* ll) (* for (; ll; ll=ll-»next) ll-»print(); *)
Каждый служащий будет печататься в соответствии с его типом. Например:
main() (* employee e; e.name = «Дж.Браун»; e.department = 1234; e.next = 0; manager m; m.name = «Дж.Смит»; e.department = 1234; m.level = 2; m.next = amp;e; f( amp;m); *)
выдаст
Дж.Смит 1234 уровень 2 Дж.Браун 1234
Заметьте, что это будет работать даже в том случае, если f() была написана и откомпилирована еще до того, как проиводный класс manager был задуман! Очевидно, при реализации этого в каждом объекте класса employee сохраняется некоторая информация о типе. Занимаемого для этого пространства (в ткущей реализации) как раз хватает для хранения указателя. Это пространство занимается только в объектах классов с виртуалными функциями, а не во всех объектах классов и даже не во
всех объектах производных классов. Вы платите эту пошлину только за те классы, для которых описали виртуальные функции.
Вызов функции с помощью операции разрешения области вдимости ::, как это делается в manager::print(), гарантирует, что механизм виртуальных функций применяться не будет. Иначе manager::print() подвергалось бы бесконечной рекурсии. Примнение уточненного имени имеет еще один эффект, который может оказаться полезным: если описанная как virtual функция описна еще и как inline (в чем ничего необычного нет), то там, где в вызове применяется ::, может применяться inline-подстновка. Это дает программисту эффективный способ справляться с теми важными специальными случаями, когда одна виртуальная функция вызывает другую для того же объекта. Поскольку тип объекта был определен при вызове первой виртуальной функции, обычно его не надо снова динамически определять другом вызове для того же объекта.
7.3 Альтернативные Интерфейсы
После того, как описаны средства языка, которые относяся к производным классам, обсуждение снова может вернуться к стоящим задачам. В классах, которые описываются в этом раздле, основополагающая идея состоит в том, что они однажды нписаны, а потом их используют программисты, которые не могут изменить их определение. Физически классы состоят из одного или более заголовочных файлов, определяющих интерфейс, и оного или более файлов, определяющих реализацию. Заголовочные файлы будут помещены куда-то туда, откуда пользователь может взять их копии с помощью директивы #include. Файлы, определющие реализацию, обычно компилируют и помещают в библиотеку.
7.3.1 Интерфейс
Рассмотрим такое написание класса slist для однократно связанного списка, с помощью которого можно создавать как онородные, так и неоднородные списки объектов тех типов, котрые еще должны быть определены. Сначала мы определим тип ent:
typedef void* ent;
Точная сущность типа ent несущественна, но нужно, чтобы в нем мог храниться указатель. Тогда мы определим тип slink:
class slink (* friend class slist; friend class slist_iterator; slink* next; ent e; slink(ent a, slink* p) (* e=a; next=p;*) *);
В одном звене может храниться один ent, и с помощью него реализуется класс slist:
class slist (* friend class slist_iterator; slink* last; // last-»next – голова списка public: int insert(ent a); // добавить в голову списка int append(ent a); // добавить в хвост списка ent get(); // вернуться и убрать голову списка void clear(); // убрать все звенья
slist() (* last=0; *) slist(ent a) (* last=new slink(a,0); last-»next=last; *) ~slist() (* clear(); *)
*);
Хотя список очевидным образом реализуется как связанный список, реализацию можно изменить так, чтобы использовался вектор из ent'ов, не повлияв при этом на пользователей. То есть, применение slink'ов никак не видно в описаниях открытых функций slist'ов, а видно только в закрытой части и определниях функций.
typedef void* ent;
Точная сущность типа ent несущественна, но нужно, чтобы в нем мог храниться указатель. Тогда мы определим тип slink:
class slink (* friend class slist; friend class slist_iterator; slink* next; ent e; slink(ent a, slink* p) (* e=a; next=p;*) *);
В одном звене может храниться один ent, и с помощью него реализуется класс slist:
class slist (* friend class slist_iterator; slink* last; // last-»next – голова списка public: int insert(ent a); // добавить в голову списка int append(ent a); // добавить в хвост списка ent get(); // вернуться и убрать голову списка void clear(); // убрать все звенья
slist() (* last=0; *) slist(ent a) (* last=new slink(a,0); last-»next=last; *) ~slist() (* clear(); *)
*);
Хотя список очевидным образом реализуется как связанный список, реализацию можно изменить так, чтобы использовался вектор из ent'ов, не повлияв при этом на пользователей. То есть, применение slink'ов никак не видно в описаниях открытых функций slist'ов, а видно только в закрытой части и определниях функций.
7.3.2 Реализация
Реализующие slist функции в основном просты. Единственая настоящая сложность – что делать в случае ошибки, если, например, пользователь попытается get() что-нибудь из пустого списка. Мы обсудим это в #7.3.4. Здесь приводятся определения членов slist. Обратите внимание, как хранение указателя на последний элемент кругового списка дает возможность просто реализовать оба действия append() и insert():
int slist::insert(ent a) (* if (last) last-»next = new slink(a,last-»next); else (* last = new slink(a,0); last-»next = last; *) return 0; *)
int slist::append(ent a) (* if (last) last = last-»next = new slink(a,last-»next); else (* last = new slink(a,0); last-»next = last; *) return 0; *)
ent slist::get() (* if (last == 0) slist_handler(«get fromempty list»); // взять из пустого списка slink* f = last-»next; ent r f-»e; if (f == last) last = 0; else last-»next = f-»next; delete f; return f; *)
Обратите внимание, как вызывается slist_handler (его описание можно найти в #7.3.4). Этот указатель на имя функции используется точно так же, как если бы он был именем функции. Это является краткой формой более явной записи вызова:
(*slist_handler)(«get fromempty list»);
И slist::clear(), наконец, удаляет из списка все элементы:
void slist::clear() (* slink* l = last;
if (l == 0) return; do (* slink* ll = l; l = l-»next; delete ll; *) while (l!=last); *)
Класс slist не обеспечивает способа заглянуть в список, но только средства для вставления и удаления элементов. Однко оба класса, и slist, и slink, описывают класс slist_iterator как друга, поэтому мы можем описать подходящий итератор. Вот один, написанный в духе #6.8:
class slist_iterator (* slink* ce; slist* cs; public: slist_iterator(slist amp; s) (* cs = amp;s; ce = cs-»last; *)
ent operator()() (* // для индикации конца итерации возвращает 0 // для всех типов не идеален, хорош для указателей ent ret = ce ? (ce=ce-»next)-»e : 0; if (ce == cs-»last) ce= 0; return ret; *) *);
int slist::insert(ent a) (* if (last) last-»next = new slink(a,last-»next); else (* last = new slink(a,0); last-»next = last; *) return 0; *)
int slist::append(ent a) (* if (last) last = last-»next = new slink(a,last-»next); else (* last = new slink(a,0); last-»next = last; *) return 0; *)
ent slist::get() (* if (last == 0) slist_handler(«get fromempty list»); // взять из пустого списка slink* f = last-»next; ent r f-»e; if (f == last) last = 0; else last-»next = f-»next; delete f; return f; *)
Обратите внимание, как вызывается slist_handler (его описание можно найти в #7.3.4). Этот указатель на имя функции используется точно так же, как если бы он был именем функции. Это является краткой формой более явной записи вызова:
(*slist_handler)(«get fromempty list»);
И slist::clear(), наконец, удаляет из списка все элементы:
void slist::clear() (* slink* l = last;
if (l == 0) return; do (* slink* ll = l; l = l-»next; delete ll; *) while (l!=last); *)
Класс slist не обеспечивает способа заглянуть в список, но только средства для вставления и удаления элементов. Однко оба класса, и slist, и slink, описывают класс slist_iterator как друга, поэтому мы можем описать подходящий итератор. Вот один, написанный в духе #6.8:
class slist_iterator (* slink* ce; slist* cs; public: slist_iterator(slist amp; s) (* cs = amp;s; ce = cs-»last; *)
ent operator()() (* // для индикации конца итерации возвращает 0 // для всех типов не идеален, хорош для указателей ent ret = ce ? (ce=ce-»next)-»e : 0; if (ce == cs-»last) ce= 0; return ret; *) *);
7.3.3 Как Этим Пользоваться
Фактически класс slist в написанном виде бесполезен. В конечном счете, зачем можно использовать список указателей void*? Штука в том, чтобы вывести класс из slist и получить список тех объектов, которые представляют интерес в конкреной программе. Представим компилятор языка вроде С++. В нем широко будут использоваться списки имен; имя name – это нечто вроде
struct name (* char* string; // ... *);
В список будут помещаться указатели на имена, а не сами объекты имена. Это позволяет использовать небольшое информционное поле e slist'а, и дает возможность имени находиться одновременно более чем в одном списке. Вот определение класса nlist, который очень просто выводится из класса slist:
#include «slist.h» #include «name.h»
struct nlist : slist (* void insert(name* a) (* slist::insert(a); *) void append(name* a) (* slist::append(a); *) name* get() (**) nlist(name* a) : (a) (**) *);
Функции нового класса или наследуются от slist непоредственно, или ничего не делают кроме преобразования типа. Класс nlist – это ничто иное, как альтернативный интерфейс класса slist. Так как на самом деле тип ent есть void*, нет необходимости явно преобразовывать указатели name*, которые используются в качестве фактических параметров (#2.3.4).
struct name (* char* string; // ... *);
В список будут помещаться указатели на имена, а не сами объекты имена. Это позволяет использовать небольшое информционное поле e slist'а, и дает возможность имени находиться одновременно более чем в одном списке. Вот определение класса nlist, который очень просто выводится из класса slist:
#include «slist.h» #include «name.h»
struct nlist : slist (* void insert(name* a) (* slist::insert(a); *) void append(name* a) (* slist::append(a); *) name* get() (**) nlist(name* a) : (a) (**) *);
Функции нового класса или наследуются от slist непоредственно, или ничего не делают кроме преобразования типа. Класс nlist – это ничто иное, как альтернативный интерфейс класса slist. Так как на самом деле тип ent есть void*, нет необходимости явно преобразовывать указатели name*, которые используются в качестве фактических параметров (#2.3.4).