Стенли Липпман - Язык программирования C++. Пятое издание

Применение оператора typeidк указателю (в отличие от объекта, на который указывает указатель) возвращает статический тип времени компиляции указателя.

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

Если динамический тип выражения может отличаться от статического, то выражение следует вычислить (во время выполнения), чтобы определить результирующий тип. Это различие имеет значение при выполнении оператора typeid(*p). Если pуказывает на тип без виртуальных функций, то указатель pне обязан быть допустимым указателем. В противном случае выражение *pвычисляется во время выполнения, тогда указатель pобязан быть допустимым. Если указатель pпуст, то выражение typeid(*p)передаст исключение bad_typeid.

Упражнение 19.6. Напишите выражение для динамического приведения указателя на тип Query_baseк указателю на тип AndQuery(см. раздел 15.9.1). Проверьте приведение, используя объект класса AndQueryи класса другого запроса. Выведите сообщение, подтверждающее работоспособность приведения, и убедитесь, что вывод соответствует ожиданиям.

Упражнение 19.7. Напишите то же приведение, но приведите объект класса Query_baseк ссылке на тип AndQuery. Повторите проверку и удостоверьтесь в правильности работы приведения.

Упражнение 19.8. Напишите выражение typeid, чтобы убедиться, указывают ли два указателя на класс Query_baseна тот же тип. Затем проверьте, не является ли этот тип классом AndQuery.

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

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

К сожалению, виртуальные функции не очень хороши для решения этой задачи. Параметры виртуальной функции должны иметь одинаковые типы и в базовом, и в производных классах (см. раздел 15.3). Если бы пришлось определить виртуальную функцию equal(), то ее параметр был бы ссылкой на базовый класс. Если параметр является ссылкой на базовый класс, то функция equal()сможет использовать только члены из базового класса. Функция equal()никак не могла бы сравнить члены, определенные в производном классе.

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

С учетом этого наблюдения можно прийти к выводу, что решить данную проблему можно с использованием RTTI. Определим оператор равенства, параметр которого будет ссылкой на тип базового класса. Оператор равенства будет использовать оператор typeidдля проверки наличия у операндов одинакового типа. Если тип операндов разный, оператор возвратит значение false. В противном случае он возвратит виртуальную функцию equal(). Каждый класс определит функцию equal()так, чтобы сравнить переменные-члены собственного типа. Эти операторы получают параметр типа Base&, но приводят операнд к собственному типу, прежде чем начать сравнение.

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

class Base {

friend bool operator==(const Base&, const Base&);

public:

// члены интерфейса для класса Base

protected:

virtual bool equal(const Base&) const;

// данные и другие члены реализации класса Base

};

class Derived: public Base {

public:

// данные и другие члены реализации класса Base

protected:

bool equal(const Base&) const;

// данные и другие члены реализации класса Derived

};

Рассмотрим, как можно было бы определить общий оператор равенства:

bool operator==(const Base &lhs, const Base &rhs) {

// возвращает false, если типы не совпадают; в противном случае вызов

// виртуальной функции equal()

return typeid(lhs) == typeid(rhs) && lhs.equal(rhs);

}

Этот оператор возвращает значение false, если операнды имеют разный тип. Если они имеют одинаковый тип, оператор делегирует реальную работу по сравнению операндов виртуальной функции equal(). Если операнды являются объектами класса Base, вызывается функция Base::equal(), а если объектами класса Derived— то функция Derived::equal().

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

bool Derived::equal(const Base &rhs) const {

// известно, что типы равны, значит, приведение не передаст

// исключения

auto r = dynamic_cast(rhs);

// действия по сравнению двух объектов класса Derived и возвращению

// результата

}

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

Эта функция гораздо проще других:

bool Base::equal(const Base &rhs) const {

// действия по сравнению двух объектов класса Base