Глава 19: Динамическая идентификация типов и операторы приведения типа

В этой главе рассматриваются два средства C++, которые поддерживают современное объектно-ориентированное программирование: динамическая идентификация типов (runtime type identification - RTTI) и набор дополнительных операторов приведения типа. Ни одно из этих средств не было частью оригинальной спецификации C++, но оба они были добавлены с целью усиления поддержки полиморфизма времени выполнения. Под RTTI понимается возможность проведения идентификации типа объекта во время выполнения программы. Рассматриваемые здесь операторы приведения типа предлагают программисту более безопасные способы выполнения этой операции. Как будет показано ниже, один из них, dynamic_cast, непосредственно связан с RTTI-идентификацией, поэтому операторы приведения типа и RTTI имеет смысл рассматривать в одной главе.

Динамическая идентификация типов (RTTI)

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

Для получения типа объекта во время выполнения программы используйте оператор typeid.

Чтобы получить тип объекта во время выполнения программы, используйте оператор typeid. Для этого необходимо включить в программу заголовок <typeinfo>. Самый распространенный формат использования оператора typeid таков.

typeid(object)

Здесь элемент object означает объект, тип которого нужно получить. Можно запрашивать не только встроенный тип, но и тип класса, созданного программистом. Оператор typeid возвращает ссылку на объект типа type_infо, который описывает тип объекта object.

В классе type_info определены следующие public-члены.

bool operator = (const type_info &ob);

bool operator !=(const type_info &ob);

bool before(const type_info &ob);

const char *name();

Перегруженные операторы "==" и "!=" служат для сравнения типов. Функция before() возвращает значение true, если вызывающий объект в порядке сопоставления стоит перед объектом (элементом ob), используемым в качестве параметра. (Эта функция предназначена в основном для внутреннего использования. Возвращаемое ею значение результата не имеет ничего общего с наследованием или иерархией классов.) Функция name() возвращает указатель на имя типа.

Рассмотрим простой пример использования оператора typeid.

// Пример использования оператора typeid.

#include <iostream>

#include <typeinfo>

using namespace std;

class myclass {

// . . .

};

int main()

{

int i, j;

float f;

myclass ob;

cout << "Тип переменной i: " << typeid(i).name();

cout << endl;

cout << "Тип переменной f: " << typeid(f).name();

cout << endl;

cout << "Тип переменной ob: " << typeid(ob).name();

cout << "\n\n";

if(typeid(i) == typeid(j))

cout << "Типы переменных i и j одинаковы.\n";

if(typeid(i) != typeid(f))

cout << "Типы переменных i и f неодинаковы.\n";

return 0;

}

При выполнении этой программы получены такие результаты.

Тип переменной i: int

Тип переменной f: float

Тип переменной ob: class myclass

Типы переменных i и j одинаковы.

Типы переменных i и f неодинаковы.

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

Следовательно, оператор typeid можно использовать для динамического определения типа объекта, адресуемого указателем на базовый класс. Применение этой возможности

демонстрируется в следующей программе.

/* Пример применения оператора typeid к иерархии полиморфных классов.

*/

#include <iostream>

#include <typeinfo>

using namespace std;

class Base {

virtual void f() {}; // делаем класс Base полиморфным

// . . .

};

class Derived1: public Base {

// . . .

};

class Derived2: public Base {

// ...

};

int main()

{

Base *p, baseob;

Derived1 ob1;

Derived2 ob2;

p = &baseob;

cout << "Переменная p указывает на объект типа ";

cout << typeid(*p).name() << endl;

p = &ob1;

cout << "Переменная p указывает на объект типа ";

cout << typeid(*p).name() << endl;

p = &ob2;

cout << "Переменная p указывает на объект типа ";

cout << typeid(*p).name() << endl;

return 0;

}

Вот как выглядят результаты выполнения этой программы:

Переменная р указывает на объект типа Base

Переменная р указывает на объект типа Derived1

Переменная р указывает на объект типа Derived2

Если оператор typeid применяется к указателю на базовый класс полиморфного типа, тип реально адресуемого объекта, как подтверждают эти результаты, будет определен во время выполнения программы.

Во всех случаях применения оператора typeid к указателю на неполиморфную иерархию классов будет получен указатель на базовый тип, т.е. то, на что этот указатель реально указывает, определить нельзя. В качестве эксперимента превратите в комментарий виртуальную функцию f() в классе Base и посмотрите на результат. Вы увидите, что тип каждого объекта после внесения в программу этого изменения будет определен как Base, поскольку именно этот тип имеет указатель p.

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

/* Демонстрируем применение оператора typeid к ссылочному параметру.

*/

void WhatType(Base &ob)

{

cout << "Параметр ob ссылается на объект типа ";

cout << typeid(ob).name() << endl;

}

int main()

{

int i;

Base baseob;

Derived1 obi;

Derived2 ob2;

WhatType(baseob);

WhatType(ob1);

WhatType(ob2);

return 0;

}

Эта программа генерирует такие результаты.

Параметр ob ссылается на объект типа Base

Параметр ob ссылается на объект типа Derived1

Параметр ob ссылается на объект типа Derived2

Существует еще одна версия применения оператора typeid, которая в качестве аргумента принимает имя типа. Формат ее таков.

tуре id(имя_типа)

Например, следующая инструкция совершенно допустима.

cout << typeid(int).name();

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

Пример RTTI-приложения

В следующей программе показано, насколько полезной может быть средство динамической идентификации типов (RTTI). Здесь используется модифицированная версия иерархии классов геометрических фигур из главы 15, которая вычисляет площадь круга, треугольника и прямоугольника. В данной программе определена функция fасtorу(), предназначенная для создания экземпляра круга, треугольника или прямоугольника. Эта функция возвращает указатель на созданный объект. (Функция, которая генерирует объекты, иногда называется фабрикой объектов.) Конкретный тип создаваемого объекта определяется в результате обращения к функции rand() С++-генератора случайных чисел. Таким образом, мы не можем знать заранее, объект какого типа будет сгенерирован. Программа создает десять объектов и подсчитывает количество созданных фигур каждого типа. Поскольку при вызове функции fасtorу() может быть сгенерирована фигура любого типа, для определения типа реально созданного объекта в программе используется оператор typeid.

/* Демонстрация использования средства динамической идентификации типов.

*/

#include <iostream>

#include <cstdlib>

using namespace std;

class figure {

protected:

double x, y;

public:

figure(double i, double j) {

x = i;

У = j;

}

virtual double area() = 0;

};

class triangle : public figure {

public:

triangle(double i, double j) : figure(i, j) {}

double area() {

return x * 0.5 * y;

}

};

class rectangle : public figure {

public:

rectangle(double i, double j) : figure (i, j) {}

double area() { return x * y;}

};

class circle : public figure {

public:

circle(double i, double j=0) : figure(i, j) {}

double area() {return 3.14 * x * x;}

};

// Фабрика объектов класса figure.

figure *factory()

{

switch(rand() % 3 ) {

case 0: return new circle (10.0);

case 1: return new triangle (10.1, 5.3);

case 2: return new rectangle (4.3, 5.7);

}

return 0;

}

int main()

{

figure *p; // указатель на базовый класс

int i;

int t=0, r=0, c=0;

// генерируем и подсчитываем объекты

for(i=0; i<10; i++) {

p = factory(); // генерируем объект

cout << "Объект имеет тип " << typeid(*р).name();

cout << ". ";

// учитываем этот объект

if(typeid(*р) == typeid(triangle)) t++;

if(typeid(*p) == typeid(rectangle)) r++;

if(typeid(*p) == typeid(circle)) c++;

// отображаем площадь фигуры

cout << "Площадь равна " << p->area() << endl;

}

cout << endl;

cout << "Сгенерированы такие объекты:\n";

cout << " треугольников: " << t << endl;

cout << " прямоугольников: " << r << endl;

cout << " кругов: " << с << endl;

return 0;

}

Возможный результат выполнения этой программы таков.

Объект имеет тип class rectangle. Площадь равна 24.51

Объект имеет тип class rectangle. Площадь равна 24.51

Объект имеет тип class triangle. Площадь равна 26.765

Объект имеет тип class triangle. Площадь равна 26.765

Объект имеет тип class rectangle. Площадь равна 24.51

Объект имеет тип class triangle. Площадь равна 26.765

Объект имеет тип class circle. Площадь равна 314

Объект имеет тип class circle. Площадь равна 314

Объект имеет тип class triangle. Площадь равна 26.765

Объект имеет тип class rectangle. Площадь равна 24.51

Сгенерированы такие объекты:

треугольников: 4

прямоугольников: 4

кругов: 2

Применение оператора typeid к шаблонным классам

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

/* Использование оператора typeid с шаблонными классами.

*/

#include <iostream>

using namespace std;

template <class T>

class myclass {

T a;

public:

myclass(T i) { a = i; }

// . . .

};

int main()

{

myclass<int> o1(10), o2(9);

myclass<double> o3(7.2);

cout << "Объект o1 имеет тип ";

cout << typeid(o1).name() << endl;

cout << "Объект o2 имеет тип ";

cout << typeid(o2).name() << endl;

cout << "Объект o3 имеет тип ";

cout << typeid(o3).name() << endl;

cout << endl;

if(typeid(o1) == typeid(o2))

cout << "Объекты o1 и o2 имеют одинаковый тип.\n";

if(typeid(o1) == typeid(o3)) cout << "Ошибка\n";

else cout << "Объекты o1 и o3 имеют разные типы.\n";

return 0;

}

Эта программа генерирует такие результаты.

Объект o1 имеет тип class myclass<int>

Объект o2 имеет тип class myclass<int>

Объект o3 имеет тип class myclass<double>

Объекты o1 и o2 имеют одинаковый тип.

Объекты o1 и o3 имеют разные типы.

Как видите, несмотря на то, что два объекта являются экземплярами одного и того же шаблонного класса, если их параметризованные данные не совпадают, они не эквивалентны по типу. В этой программе объект o1 имеет тип myclass<int>, а объект o3 — тип myclass<double>. Таким образом, это объекты разного типа.

Рассмотрим еще один пример применения оператора typeid к шаблонным классам, а именно модифицированную версию программы определения геометрических фигур из предыдущего раздела. На этот раз класс figure мы сделали шаблонным.

// Шаблонная версия figure-иерархии.

#include <iostream>

#include <cstdlib>

using namespace std;

template <class T>

class figure

{

protected:

T x, y;

public:

figure(T i, T j) {

x = i;

у = j;

}

virtual T area() = 0;

};

template <class T>

class triangle : public figure<T>

{

public:

triangle(T i, T j) : figure<T>(i, j) {}

T area() {

return x * 0.5 * y;

}

};

template <class T>

class rectangle : public figure<T>

{

public:

rectangle(T i, T j) : figure<T>(i, j) {}

T area() {

return x * y;

}

};

template <class T>

class circle : public figure<T>

{

public:

circle(T i, T j=0) : figure<T>(i, j) {}

T area() {

return 3.14 * x * x;

}

};

// Фабрика объектов, генерируемых из класса figure.

figure<double> *generator()

{

switch(rand() % 3 ) {

case 0: return new circle<double> (10.0);

case 1: return new triangle<double>(10.1, 5.3);

case 2: return new rectangle<double> (4.3, 5.7);

}

return 0;

}

int main()

{

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

dynamic_cast<type> (expr)

Здесь элемент type означает новый тип, который является целью выполнения этой операции, а элемент expr— выражение, приводимое к этому новому типу. Тип type должен быть представлен указателем или ссылкой, а выражение expr должно приводиться к указателю или ссылке. Таким образом, оператор dynamic_cast можно использовать для преобразования указателя одного типа в указатель другого или ссылки одного типа в ссылку другого.

Этот оператор в основном используется для динамического выполнения операций приведения типа среди полиморфных типов. Например, если даны полиморфные классы В и D, причем класс D выведен из класса В, то с помощью оператора dynamic_cast всегда можно преобразовать указатель D* в указатель В*, поскольку указатель на базовый класс всегда можно использовать для указания на объект класса, выведенного из базового. Однако оператор dynamic_cast может преобразовать указатель В* в указатель D* только в том случае, если адресуемым объектом действительно является объект класса D. И, вообще, оператор dynamic_cast будет успешно выполнен только при условии, если разрешено полиморфное приведение типов, т.е. если указатель (или ссылка), приводимый к новому типу, может указывать (или ссылаться) на объект этого нового типа или объект, выведенный из него. В противном случае, т.е. если заданную операцию приведения типов выполнить нельзя, результат действия оператора dynamic_cast оценивается как нулевой, если в этой операции участвуют указатели. (Если же попытка выполнить эту операцию оказалась неудачной при участии в ней ссылок, генерируется исключение типа bad_cast.)

Рассмотрим простой пример. Предположим, что класс Base — полиморфный, а класс Derived выведен из класса Base.

Base *bp, b_ob;

Derived *dp, d_ob;

bp = &d_ob; // Указатель на базовый класс указывает на объект класса Derived.

dp = dynamic_cast<Derived *> (bp); // Приведение к указателю на производный класс разрешено.

if(dp) cout << "Приведение типа прошло успешно!";

Здесь приведение указателя bp (на базовый класс) к указателю dp (на производный класс) успешно выполняется, поскольку bp действительно указывает на объект класса

bp = dynamic_cast<Base *> (&b_ob);

if(bp) {

cout << "Приведение типов " <<"(из Base * в Base *)

реализовано.\n";

bp->f();

}

else cout << "Ошибка\n";

cout << endl;

dp = dynamic_cast<Derived *> (&b_ob);

if(dp) cout <<"Ошибка\n";

else

cout <<"Приведение типов " <<"(из Base * в Derived *) не реализовано.\n";

cout << endl;

bp = &d_ob; // bp указывает на объект класса Derived

dp = dynamic_cast<Derived *> (bp);

if(dp) {

cout << "Приведение bp к типу Derived *\n" << "реализовано, поскольку bp действительно\n" << "указывает на объект класса

Derived.\n";

dp->f();

}

else cout << "Ошибка\n";

cout << endl;

bp = &b_ob; // bр указывает на объект класса Base

dp = dynamic_cast<Derived *> (bp);

if(dp) cout << "Ошибка";

else {

cout <<"Теперь приведение bp к типу Derived *\n" <<"не реализовано, поскольку bp\n" <<"в действительности указывает на объект\n" <<"класса Base.\n";

}

cout << endl;

dp = &d_ob; // dp указывает на объект класса Derived

bp = dynamic_cast<Base *> (dp);

if(bp) {

cout <<"Приведение dp к типу Base * реализовано.\n";

bp->f();

}

else cout <<"Ошибка\n";

return 0;

}

Программа генерирует такие результаты.

if(typeid(*bp) == typeid(Derived)) dp = (Derived *) bp;

В этом случае используется обычная операция приведения типов. Здесь это вполне безопасно, поскольку инструкция if проверяет законность операции приведения типов с помощью оператора typeid до ее реального выполнения. То же самое можно сделать более эффективно, заменив операторы typeid и инструкцию if оператором

dynamic_cast:

dp = dynamic_cast<Derived *> (bp);

Поскольку оператор dynamic_cast успешно выполняется только в том случае, если объект, подвергаемый операции приведения к типу, уже является объектом либо заданного типа, либо типа, выведенного из заданного, то после завершения этой инструкции указатель dp будет содержать либо нулевое значение, либо указатель на объект типа Derived. Кроме того, поскольку оператор dynamic_cast успешно выполняется только в том случае, если заданная операция приведения типов законна, то в определенных ситуациях ее логику можно упростить. В следующей программе показано, как оператор typeid можно заменить оператором dynamic_cast. Здесь выполняется один и тот же набор операций дважды: с использованием сначала оператора typeid, а затем оператора dynamic_cast.

/* Использование оператора dynamic_cast вместо оператора typeid.

*/

#include <iostream>

#include <typeinfo>

using namespace std;

class Base {

public:

virtual void f() {}

};

class Derived : public Base {

public:

void derivedOnly() {

cout << "Это объект класса Derived.\n";

}

};

int main()

{

Base *bp, b_ob;

Derived *dp, d_ob;

//--------------------------------

// Использование оператора typeid

//--------------------------------

bp = &b_ob;

if(typeid(*bp) == typeid(Derived)) {

dp = (Derived *) bp;

dp->derivedOnly();

<<"типу Derived не выполнилась.\n";

bp = &d_ob;

if(typeid(*bp) == typeid(Derived)) {

dp = (Derived *) bp;

dp->derivedOnly();

Оператор const_cast переопределяет модификаторы const и/или volatile.

Оператор const_cast используется для явного переопределения модификаторов const и/ или volatile. Новый тип должен совпадать с исходным, за исключением его атрибутов const или volatile. Чаще всего оператор const_cast используется для удаления признака постоянства (атрибута const). Его общий формат имеет следующий вид.

const_cast<type> (expr)

Здесь элемент type задает новый тип операции приведения, а элемент expr означает выражение, которое приводится к новому типу.

Использование оператора const_cast демонстрируется в следующей программе.

// Демонстрация использования оператора const_cast.

#include <iostream>

using namespace std;

void f (const int *p)

{

int *v;

// Переопределение const-атрибута.

v = const_cast<int *> (p);

*v = 100; // теперь объект можно модифицировать

}

int main()

{

int x = 99;

cout << "Значение x до вызова функции f(): " << x<< endl;

f (&x);

cout <<"Значение x после вызова функции f(): " << x<< endl;

return 0;

}

Результаты выполнения этой программы таковы.

Значение х до вызова функции f(): 99

Значение х после функции f(): 100

Как видите, переменная x была модифицирована функцией f(), хотя параметр, принимаемый ею, задается как const-указатель.

Необходимо подчеркнуть, что использование оператора const_cast для удаления const- атрибута является потенциально опасным средством. Поэтому обращайтесь с ним очень осторожно.

И еще. Удалять const-атрибут способен только оператор const_cast. Другими словами, ни dynamic_cast, ни static_cast, ни reinterpret_cast нельзя использовать для изменения const-

атрибута объекта.

Оператор static_cast

Оператор static_cast выполняет операцию неполиморфного приведения типов.

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

static_cast<type> (expr)

Здесь элемент type задает новый тип операции приведения, а элемент expr означает выражение, которое приводится к этому новому типу.

Оператор static_cast, по сути, является заменителем оригинального оператора приведения типов. Он лишь выполняет неполиморфное преобразование. Например, при выполнении следующей программы переменная типа float приводится к типу int.

// Использование оператора static_cast.

#include <iostream>

using namespace std;

int main()

{

int i;

float f;

f = 199.22F;

i = static_cast<int> (f);

cout << i;

return 0;

}

Оператор reinterpret_cast

Оператор reinterpret_cast выполняет фундаментальное изменение типа.

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

reinterpret_cast<type> (expr)

Здесь элемент type задает новый тип операции приведения, а элемент expr означает выражение, которое приводится к этому новому типу.

Использование оператора reinterpret_cast демонстрируется в следующей программе.

// Пример использования оператора reinterpret_cast.

#include <iostream>

using namespace std;

int main()

{

int i;

char *p = "Это короткая строка.";

i = reinterpret_cast<int> (p); // Приводим указатель к типу int.

cout << i;

return 0;

}

Здесь оператор reinterpret_cast преобразует указатель p в целочисленное значение. Данное преобразование представляет фундаментальное изменение типа.

Сравнение обычной операции приведения типов с новыми четырьмя castоператорами

Кому-то из читателей могло бы показаться, что описанные выше четыре cast-оператора полностью заменяют традиционную операцию приведения типов. И тогда у них может возникнуть такой вопрос: "Стоит ли всегда вместо обычной операции приведения типов использовать более новые средства?". Дело в том, что общего правила для всех программистов не существует. Поскольку новые операторы были созданы для повышения безопасности довольно рискованной операции приведения одного типа данных к другому, многие С++-программисты убеждены, что их следует использовать исключительно с этой целью. И здесь трудно что-либо возразить. Другие же программисты считают, что поскольку традиционная операция приведения типов служила им "верой и правдой" в течение многих лет, то от нее не стоит так легко отказываться. Например, для выполнения простых и относительно безопасных операций приведения типов (как те, что требуются при вызове функций ввода-вывода read() и write(), описанных в предыдущей главе) "старое доброе" средство вполне приемлемо.

Существует еще одна точка зрения, с которой трудно не согласиться: при выполнении операций приведения полиморфных типов определенно стоит использовать оператор dynamic_cast.