Бьерн Страуструп (947334), страница 33

Просмтор этого файла доступен только зарегистрированным пользователям. Но у нас супер быстрая регистрация: достаточно только электронной почты!

Текст из файла (страница 33)

члену производного класса не предоставлено право доступа к частным

членам его базового класса, значит name недоступно в этой функции.

Возможно многим это покажется странным, но давайте рассмотрим

альтернативное решение: функция-член производного класса имеет

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

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

к нему достаточно просто определить производный класс. Теперь уже

будет недостаточно для выяснения, кто использует частные члены класса,

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

просмотреть все исходные файлы программы, найти производные

классы, затем исследовать каждую функцию этих классов. Далее надо

снова искать производные классы от уже найденных и т.д. Это, по крайней

мере, утомительно, а скорее всего нереально. Нужно всюду, где это

возможно, использовать вместо частных членов защищенные (см. $$6.6.1).

Как правило, самое надежное решение для производного класса -

использовать только общие члены своего базового класса:

void manager::print() const

{

employee::print(); // печать данных о служащих

// печать данных об управляющих

}

Отметим, что операция :: необходима, поскольку функция print()

переопределена в классе manager. Такое повторное использование имен

типично для С++. Неосторожный программист написал бы:

void manager::print() const

{

print(); // печать данных о служащих

// печать данных об управляющих

}

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

manager::print().

6.2.2 Конструкторы и деструкторы

Для некоторых производных классов нужны конструкторы. Если конструктор

есть в базовом классе, то именно он и должен вызываться с указанием

параметров, если таковые у него есть:

class employee {

// ...

public:

// ...

employee(char* n, int d);

};

class manager : public employee {

// ...

public:

// ...

manager(char* n, int i, int d);

};

Параметры для конструктора базового класса задаются в определении

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

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

manager::manager(char* n, int l, int d)

: employee(n,d), level(l), group(0)

{

}

Конструктор базового класса employee::employee() может иметь такое

определение:

employee::employee(char* n, int d)

: name(n), department(d)

{

next = list;

list = this;

}

Здесь list должен быть описан как статический член employee.

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

члены и, наконец, сами производные классы. Уничтожаются они в

обратном порядке: сначала сами производные классы, затем члены,

а затем базовые. Члены и базовые создаются в порядке описания их

в классе, а уничтожаются они в обратном порядке.

6.2.3 Иерархия классов

Производный класс сам в свою очередь может быть базовым классом:

class employee { /* ... */ };

class manager : public employee { /* ... */ };

class director : public manager { /* ... */ };

Такое множество связанных между собой классов обычно называют

иерархией классов. Обычно она представляется деревом, но бывают

иерархии с более общей структурой в виде графа:

class temporary { /* ... */ };

class secretary : public employee { /* ... */ };

class tsec

: public temporary, public secretary { /* ... */ };

class consultant

: public temporary, public manager { /* ... */ };

Видим, что классы в С++ могут образовывать направленный ацикличный

граф (подробнее об этом говорится в $$6.5.3). Этот граф для

приведенных классов имеет вид:

6.2.4 Поля типа

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

описания, в реализации языка должен быть решен вопрос: к какому из

производных классов относится объект, на который смотрит указатель base*?

Существует три основных способа ответа:

[1] Обеспечить, чтобы указатель мог ссылаться на объекты только

одного типа ($$6.4.2);

[2] Поместить в базовый класс поле типа, которое смогут проверять

функции;

[3] использовать виртуальные функции ($$6.2.5).

Указатели на базовые классы обыкновенно используются при проектировании

контейнерных классов (множество, вектор, список и т.д.). Тогда в

случае [1] мы получим однородные списки, т.е. списки объектов одного

типа. Способы [2] и [3] позволяют создавать разнородные списки, т.е.

списки объектов нескольких различных типов (на самом деле, списки

указателей на эти объекты). Способ [3] - это специальный надежный в

смысле типа вариант способа [2]. Особенно интересные и мощные варианты

дают комбинации способов [1] и [3]; они обсуждаются в главе 8.

Вначале обсудим простой способ с полем типа, т.е. способ [2].

Пример с классами manager/employee можно переопределить так:

struct employee {

enum empl_type { M, E };

empl_type type;

employee* next;

char* name;

short department;

// ...

};

struct manager : employee {

employee* group;

short level;

// ...

};

Имея эти определения, можно написать функцию, печатающую данные

о произвольном служащем:

void print_employee(const 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 << "level" << p->level << '\n';

// ...

break;

}

}

Напечатать список служащих можно так:

void f(const employee* elist)

{

for (; elist; elist=elist->next) print_employee(elist);

}

Это вполне хорошее решение, особенно для небольших программ,

написанных одним человеком, но оно имеет существенный недостаток:

транслятор не может проверить, насколько правильно программист

обращается с типами. В больших программах это приводит к ошибкам

двух видов. Первый - когда программист забывает проверить поле

типа. Второй - когда в переключателе указываются не все возможные

значения поля типа. Этих ошибок достаточно легко избежать в

процессе написания программы, но совсем нелегко избежать их при

внесении изменений в нетривиальную программу, а особенно,

если это большая программа, написанная кем-то другим. Еще

труднее избежать таких ошибок потому, что функции типа print() часто

пишутся так, чтобы можно было воспользоваться общностью классов:

void print(const employee* e)

{

cout << e->name << '\t' << e->department << '\n';

// ...

if (e->type == M) {

manager* p = (manager*) e;

cout << "level" << p->level << '\n';

// ...

}

}

Операторы if, подобные приведенным в примере, сложно найти в большой

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

найдены, нелегко понять, что происходит на самом деле. Кроме того, при

всяком добавлении нового вида служащих требуются изменения во всех

важных функциях программы, т.е. функциях, проверяющих поле типа. В

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

самым время на отладку этих частей.

Иными словами, использование поля типа чревато ошибками и

трудностями при сопровождении программы. Трудности резко возрастают

по мере роста программы, ведь использование поля типа противоречит

принципам модульности и упрятывания данных. Каждая функция,

работающая с полем типа, должна знать представление и специфику

реализации всякого класса, являющегося производным для класса,

содержащего поле типа.

6.2.5 Виртуальные функции

С помощью виртуальных функций можно преодолеть трудности, возникающие

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

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

и загрузчик обеспечат правильное соответствие между объектами и

применяемыми к ним функциями:

class employee {

char* name;

short department;

// ...

employee* next;

static employee* list;

public:

employee(char* n, int d);

// ...

static void print_list();

virtual void print() const;

};

Служебное слово virtual (виртуальная) показывает, что функция print()

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

версии при вызове print() - это задача транслятора.

Тип функции указывается в базовом классе и не может быть

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

должно даваться для того класса, в котором она была впервые

описана (если только она не является чисто виртуальной функцией,

см. $$6.3). Например:

void employee::print() const

{

cout << name << '\t' << department << '\n';

// ...

}

Мы видим, что виртуальную функцию можно использовать, даже если

нет производных классов от ее класса. В производном же классе

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

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

только те функции, которые в нем действительно нужны:

class manager : public employee {

employee* group;

short level;

// ...

public:

manager(char* n, int d);

// ...

void print() const;

};

Место функции print_employee() заняли функции-члены print(), и она

стала не нужна. Список служащих строит конструктор employee ($$6.2.2).

Напечатать его можно так:

void employee::print_list()

{

for ( employee* p = list; p; p=p->next) p->print();

}

Данные о каждом служащем будут печататься в соответствии с типом

записи о нем. Поэтому программа

int main()

{

employee e("J.Brown",1234);

manager m("J.Smith",2,1234);

employee::print_list();

}

напечатает

J.Smith 1234

level 2

J.Brown 1234

Обратите внимание, что функция печати будет работать даже в том случае,

если функция employee_list() была написана и оттранслирована еще до того,

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

правильной работы виртуальной функции нужно в каждом объекте класса

employee хранить некоторую служебную информацию о типе. Как правило,

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

Этот указатель хранится только для объектов класса с виртуальными

функциями, но не для объектов всех классов, и даже для не для всех

объектов производных классов. Дополнительная память отводится только

для классов, в которых описаны виртуальные функции. Заметим, что

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

память.

Если в вызове функции явно указана операция разрешения

области видимости ::, например, в вызове manager::print(),

то механизм вызова виртуальной функции не действует. Иначе подобный

вызов привел бы к бесконечной рекурсии. Уточнение имени функции

дает еще один положительный эффект: если виртуальная функция

является подстановкой (в этом нет ничего необычного), то в вызове

с операцией :: происходит подстановка тела функции. Это

эффективный способ вызова, который можно применять

в важных случаях, когда одна виртуальная функция

обращается к другой с одним и тем же объектом. Пример такого

случая - вызов функции manager::print(). Поскольку тип объекта

явно задается в самом вызове manager::print(), нет нужды определять

его в динамике для функции employee::print(), которая и будет

вызываться.

6.3 Абстрактные классы

Многие классы сходны с классом employee тем, что в них можно дать

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

Характеристики

Список файлов книги