Динамическое определение типа объекта в C++

else сэкономит тяжелый вызов dynamic_cast'а

не совсем верно получается. Программа выводит: 1 12.

А должна: 1 2

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

Добавить в A виртуальную функцию, которая делает то, что нужно, а в B её перекрыть.

программа выводит:

1
12

не должна

если у тебя иерархия сложная, ты устанешь разбираться с dynamic_cast'ами, лучше сделай виртуальный метод type(), который выведет то, что тебе нужно у каждого класса

не совсем верно получается. Программа выводит: 1 12.
А должна: 1 2

Просто в данном конкретном примере arr[2] можно преобразовать как к A*, так и к B*. Если же у тебя A будет абстрактным классом, от которого ты родишь B и C и будешь проверять уже их объекты, то такой подход будет работать.

Решил проблему вот так:

#include <iostream>
#include <typeinfo>

using namespace std;

class A
{
public:
    virtual ~A () {};
};

class B : public A
{

};


int main()
{
    A a;
    B b;
    auto ta = typeid(a).name(), tb = typeid(b).name();
    A* arr[2] = {&a, &b};
    for(int i = 0; i < 2; ++i)
    {
        if (typeid(*arr[i]).name() == ta) {
            cout << 1;
        }
        else if (typeid(*arr[i]).name() == tb) {
            cout << 2;
        }
        cout << endl;
    }
}

Какие есть минусы у этого подхода и имеет ли он право на жизнь?

Лучше без ртти сделай виртуальный метод, который вернёт 0 на родителе и указатель на себя в ребёнке.

минусы: производительность, по крайней мере debug-сборок, усложнённость клиентского кода (того, что у тебя в main)

сравни с:

#include <iostream>

using namespace std;

class A
{
public:
    virtual int getType () { return 1; }
};

class B : public A
{
    int getType () { return 2; }
};


int main()
{
    A a;
    B b;
    A* arr[2] = {&a, &b};
    for(int i = 0; i < 2; ++i)
    {
        cout << arr[i]->getType() << endl;
    }
}

Всем спасибо за обсуждение.

если таки хочется стильно модно молодёжно, то обрати внимание на комментарий m0rph Динамическое определение типа объекта в C++ (комментарий)

спасибо большое за совет

Либо упорядочить проверки в обратном порядке наследования (т.е. сначала проверять подкласс B, потом суперкласс A). Естественно, цепочкой if ... else if ... else ..., а не независимыми if'ами.

Впрочем, правильней всего, конечно, перенести этот код в методы классов и не морочить голову.

1. RTTI сам по себе тяжелый.
2. RTTI есть не всегда.
3. Тут он нафиг не нужен.

typeid(*arr[i]).name() == ta

Нужно сравнивать сами typeid(...), а не имена.

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

Пример такого поведения - обход AST,с целью оптимизации констант. Типа превратить a * c + ((2 -1) * 3) => a * c + 3, что бы ускорить вычисления.

Очевидно, что оптимизировать можно только выражения, содержащие только константы. Тогда как вычисляются элементы такого дерева через примерно такой интерфейс:

struct Expression {
    virtual double eval() = 0;
};

Но, даже тут лучше использовать ручную реализацию двойной диспетчеризации.

А как это сделать? просто на typeid ругается, что мол private он. Разве имён недостаточно? они ж уникальны

я этот вопрос задал только из-за академического интереса, ничего более. Но, быть может, и пригодится когда-нибудь. Как pon4ik пишет ниже, например