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

Объект 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()

{

　 figure< double> *p;

　 int i;

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

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

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

　　 p = generator();

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

　　 cout < < ". ";

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

　　 if(typeid(*p) == typeid(triangle< double> )) t++;

　　 if(typeid(*p) == typeid(rectangle< double> )) r++;

　　 if(typeid(*p) == typeid(circle< double> )) c++;

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

　 }

　 cout < < endl;

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

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

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

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

　 return 0;

}

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

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

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

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

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

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

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

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

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

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

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

　 кругов: 2

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

Операторы приведения типов

В C++ определено пять операторов приведения типов. Первый оператор (он описан выше в этой книге), применяемый в обычном (традиционном) стиле, был с самого начала встроен в C++. Остальные четыре (dynamic_cast, const_cast, reinterpret_cast и static_cast) были добавлены в язык всего несколько лет назад. Эти операторы предоставляют дополнительные " рычаги управления" характером выполнения операций приведения типа. Рассмотрим каждый из них в отдельности.

Оператор dynamic_cast

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

Возможно, самым важным из новых операторов является оператор динамического приведения типов 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 действительно указывает на объект класса Derived. Поэтому при выполнении этого фрагмента кода будет выведено сообщение Приведение типа прошло успешно! . Но в следующем фрагменте кода попытка совершить операцию приведения типа будет неудачной, поскольку bp в действительности указывает на объект класса Base, и неправомерно приводить указатель на базовый класс к типу указателя на производный, если адресуемый им объект не является на самом деле объектом производного класса.

bp = & b_ob; /* Указатель на базовый класс ссылается на объект класса Base. */

dp = dynamic_cast< Derived *> (bp); // ошибка!

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

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

В следующей программе демонстрируются различные ситуации применения оператора dynamic_cast.

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

#include < iostream>

using namespace std;

class Base {

　 public:

　　 virtual void f() { cout < < " В классе Base."; }

　　 //...

};

class Derived: public Base {

　 public:

　　 void f() { cout < < " В классе Derived."; }

};

Int main()

{

　 Base *bp, b_ob;

　 Derived *dp, d_ob;

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

　 if(dp) {

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

　　 dp-> f();

　 }

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

　 cout < < endl;

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

　 if(bp) {

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

　　 bp-> f();

　 }

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

　 cout < < endl;

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

　 if(bp) {

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

　　 bp-> f();

　 }

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

　 cout < < endl;

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

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

　 else

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

　 cout < < endl;

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

　 dp = dynamic_cast< Derived *> (bp);

　 if(dp) {

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

　　 dp-> f();

　 }

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

　 cout < < endl;

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

　 dp = dynamic_cast< Derived *> (bp);

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

　 else {

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

　 }

　 cout < < endl;

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

　 bp = dynamic_cast< Base *> (dp);

　 if(bp) {

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

　　 bp-> f();

　 }

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

　 return 0;

}

⇐ Предыдущая 51 52 53 54 555657 58 59 60 Следующая ⇒