Читать онлайн «Язык программирования C++. Пятое издание». Страница 269

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

namespace NS {

 class Quote { /* ... */ };

 void display(const Quote&) { /* ... */ }

}

// Базовый класс Bulk_item объявлен в пространстве имен NS

class Bulk_item : public NS::Quote { /* ... */ };

int main() {

 Bulk_item book1;

 display(book1);

 return 0;

}

Аргумент book1 функции display() имеет тип класса Bulk_item. Функциями-кандидатами для этого вызова функции display() будут не только функции с объявлениями, видимыми на момент вызова, но и те, которые объявлены в пространстве имен класса Bulk_item и его базового класса Quote. Таким образом, функция display(const Quote&), объявленная в пространстве имен NS, будет добавлена в набор функций кандидатов.

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

using NS::print(int); // ошибка: нельзя указать список параметров

using NS::print;      // ok: в объявлении using указывают только имена

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

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

Функции, предоставленные объявлением using, перегружают любые другие объявления одноименных функций, уже находящихся в данной области видимости.

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

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

namespace libs_R_us {

 extern void print(int);

 extern void print(double);

}

// обычное объявление

void print(const std::string &);

// директива using добавила имена в набор функций-кандидатов для вызова

// функции print():

using namespace libs_R_us;

// кандидатами на вызов print() в настоящий момент являются:

// print(int) from libs_R_us

// print(double) from libs_R_us

// print(const std::string &) declared explicitly

void fooBar(int ival) {

 print("Value: "); // вызов глобальной print(const string &)

 print(ival);      // вызов libs_R_us::print(int)

}

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

Если в коде присутствует несколько директив using, частью набора функций-кандидатов станут соответствующие функции из каждого пространства имен.

namespace AW {

 int print(int);

}

namespace Primer {

 double print(double);

}

// директивы using создают набор перегруженных функций из разных

// пространств имен

using namespace AW;

using namespace Primer;

long double print(long double);

int main() {

 print(1);   // вызов AW::print(int)

 print(3.1); // вызов Primer::print(double)

 return 0;

}

Набор перегруженных функций print() в глобальной области видимости содержит функции print(int), print(double) и print(long double). Все они составят набор перегруженных функций, рассматриваемых при вызове функции print() в функции main(), даже в том случае, если первоначально эти функции были объявлены в различных областях видимости пространства имен.

Упражнение 18.20. С учетом следующего кода укажите, какие из функций (если они есть) соответствуют обращению к функции compute(). Перечислите функции-кандидаты и подходящие функции. Какая последовательность преобразований типов (если есть) будет применена к аргументу, чтобы он точно соответствовал параметру каждой подходящей функции?

namespace primerLib {

 void compute();

 void compute(const void *);

}

using primerLib::compute;

void compute(int);

void compute(double, double = 3.4);

void compute(char*, char* = 0);

void f() {

 compute(0);

}

Что произойдет в случае, если объявления using будут расположены в функции main() перед обращением к функции compute()? Ответьте на те же вопросы, что и в предыдущем упражнении.

Множественное наследование (multiple inheritance) — это способность получить класс как производный непосредственно от нескольких базовых классов (см. раздел 15.2.2). Полученный в результате класс наследует свойства всех своих базовых классов. Несмотря на простоту концепции, одновременное использование нескольких базовых классов может создать достаточно много сложностей как на этапе проектирования, так и на этапе реализации.

Для исследования множественного наследования используем пример иерархии из животного мира. Животные расположены на разных уровнях абстракции. Есть индивидуальные животные, различающееся по именам, такие как Ling-ling (Линг-линг), Mowgli (Маугли) и Balou (Балу). Каждое животное можно отнести к определенному виду; Линг-линг, например, это гигантская панда. Виды в свою очередь относятся к определенным семействам. Гигантская панда принадлежит к семейству медведей, а каждое семейство является членом сообщества животного мира.

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

Кроме классов животных, здесь можно определить дополнительные классы, которые инкапсулируют различные абстракции, например, животных, подвергающихся опасности. В данной реализации класс Panda (Панда) будет получен в результате множественного наследования от классов Bear и Endangered (Подвергающийся опасности).

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

class Bear : public ZooAnimal { /* ... */ };

class Panda : public Bear, public Endangered { /* ... */ };

У каждого базового класса есть необязательный спецификатор доступа (см. раздел 15.5). Как обычно, если спецификатор доступа отсутствует, по умолчанию подразумевается спецификатор private (закрытый), если используется ключевое слово class, и public (открытый), если используется ключевое слово struct (см. раздел 15.5).

Как и при одиночным наследовании, список наследования может включить только те классы, которые были определены и не были определены как final (см. раздел 15.2.2). Язык С++ не налагает никаких ограничений на количество базовых классов, из которых может быть получен производный класс. Однако базовый класс может присутствовать в списке наследования только один раз.