Лекция №1. Неизвестные типы и пространство неизвестных имен. Динамическое определение типов. Операторы переключения типов. Создание пространства новых имен. Буферизированный вход и выход

2.2. Оператор typeid для типа (класса).
В примере приводится программный код, использующий оператор typeid() для определения типа объекта некоторого класса и переменной.
#include
#include
using namespace std;
// Набор классов
// Базовый класс
class A
{
// ...
};
// Производные классы
class B : public A
{
// ...
};
class C : public B
{
// ...
};
void main(void)
{
// 1. Создать экземпляры классов B, C
B objB;
C objC;
// 2. Проверка, к какому типу относится экземпляр objC
if (typeid(objC) == typeid(A))
cout << "objC is of type A" << endl;
if (typeid(objC) == typeid(B))
cout << "objC is of type B" << endl;
if (typeid(objC) == typeid(C))
cout << "objC is of type C" << endl; // +
// 3. Проверка, переменная ли a целого типа int
int a;
if (typeid(a) == typeid(int))
cout << "Variable a is of type int." << endl;
else
cout << "Variable a is not of type int" << endl;
}
Результат выполнения программы
objC is of type C
Variable a is of type int.
Динамическая идентификация типов. Операторы dynamic_cast, const_cast, reinterpret_cast, static_cast.
1. Оператор dynamic_cast. Пример.
Оператор dynamic_cast используется для динамического приведения типа с одновременной проверкой корректности приведения. Если приведение не может быть выполнено, то оно не выполняется и оператор возвращает нулевое значение (nullptr).
Общая форма оператора dynamic_cast следующая:
dynamic_cast (expression);
здесь

• 
  type – результирующий тип;
  
• 
  expression – выражение, которое приводится к типу type.
  

Оператор dynamic_cast эффективен в случае приведения типов, образующих иерархию наследования (полимофных типов).
Если оператор dynamic_cast применяется к указателям, возвращается нулевой указатель (nullptr). Если этот оператор применяется к ссылкам, в случае ошибки генерируется исключительная ситуация bad_cast.
В примере показано использование оператора dynamic_cast для двух классов A и B, которые образуют иеархию наследования. Рассматриваются всевозможные ситуации использования оператора.
#include
#include
using namespace std;
// Оператор dynamic_cast<> - определяет, можно ли динамически привести типы
// Базовый класс
class A
{
public:
virtual void Show()
{
cout << "A::Show()" << endl;
}
};
// Производный класс
class B :public A
{
public:
void Show()
{
cout << "B::Show()" << endl;
}
};
void main(void)
{
// 1. Объявить переменные
A* pA; // указатель на базовый класс
B* pB; // указатель на производный класс
A a;
B b;
// 2. Использовать указатель pA
pA = &a; // Так можно
pA->Show();
// Также можно, указатель на базовый класс может указывать на
// экземпляр производного класса.
pA = &b;
pA->Show();
// 3. Использовать указатель pB
// Так нельзя
// pB = &a; // запрещено, базовый класс не может расширяться до производного
// 4. Использование оператора dynamic_cast.
// Случай: указатель получает адрес экземпляра класса
cout << "dynamic_cast(&obj): " << endl;
// 4.1. Приведение B* <= A* с проверкой
pB = dynamic_cast (&a); // нельзя, pB = nullptr
if (pB==nullptr)
cout << "Cast A* <= B* -> Error" << endl; // этот вариант
else
cout << "Cast A* <= B* -> Ok" << endl;
// 4.2. Приведение B* <= B*
pB = dynamic_cast (&b); // можно
if (pB != nullptr)
cout << "Cast B* <= B* -> Ok" << endl; // этот вариант
else
cout << "Cast B* <= B* -> Error" << endl;
// 4.3. Приведение A* <= A*
pA = dynamic_cast(&a); // можно, pA!=nullptr
if (pA != nullptr)
cout << "Cast A* <= A* -> Ok" << endl;
else
cout << "Cast A* <= A* -> Error";
// 4.4. Приведение A* <= B*
pA = dynamic_cast(&b); // можно
if (pA)
cout << "Cast A* <= B* -> Ok" << endl;
else
cout << "Cast A* <= B* -> Error";
cout << "---------------------------------" << endl;
// 5. Использование оператора dynamic_cast.
// Случай: указатель получает адрес другого указателя
cout << "dynamic_cast(ptr -> Type): " << endl;
// 5.1. Приведение B* <= B*
// Указатель pA ссылается на объект класса B
pA = &b; // можно, pA->b
pB = dynamic_cast(pA); // можно, потому что pA ссылается на объект класса B
if (pB)
cout << "Cast B* <= (pA -> B) --> Ok " << endl; // +
else
cout << "Cast B* <= (pA -> B) --> Error " << endl;
// 5.2. Приведение B* <= A*
// Указатель pA ссылается на объект класса A
pA = &a; // pA -> A
pB = dynamic_cast(pA); // нельзя, потому что pA ссылается на объект класса A
if (pB)
cout << "Cast B* <= (pA -> A) --> Ok " << endl;
else
cout << "Cast B* <= (pA -> A) --> Error " << endl; // +
// 5.3. Приведение A* <= B*
// Указатель pB указывает на объект класса B
pB = &b;
pA = dynamic_cast (pB); // можно
if (pA)
cout << "Cast A* <= (pB -> B) --> Ok " << endl;
else
cout << "Cast A* <= (pB -> B) --> Error" << endl;
// 5.4. Приведение A* <= A*
// pB = &a; // ошибка компиляции
}