Какова стоимость typeid?

Как правило, вы не просто хотите знать тип, но и что-то делать с объектом как с этим типом. В этом случае dynamic_cast более полезен:

int main() 
{
    BaseThing* pThing = new Thing<B>();

    if(Thing<B>* pThingB = dynamic_cast<Thing<B>*>(pThing)) {
    {
        // Do something with pThingB
    }
    else if(Thing<A>* pThingA = dynamic_cast<Thing<A>*>(pThing)) {
    {
        // Do something with pThingA
    }
}

Я думаю, именно поэтому вы редко видите, как typeid используется на практике.

Обновлять:

Т.к. этот вопрос касается производительности. Я провел несколько тестов на g++ 4.5.1. С этим кодом:

struct Base {
  virtual ~Base() { }
  virtual int id() const = 0;
};

template <class T> struct Id;

template<> struct Id<int> { static const int value = 1; };
template<> struct Id<float> { static const int value = 2; };
template<> struct Id<char> { static const int value = 3; };
template<> struct Id<unsigned long> { static const int value = 4; };

template <class T>
struct Derived : Base {
  virtual int id() const { return Id<T>::value; }
};

static const int count = 100000000;

static int test1(Base *bp)
{
  int total = 0;
  for (int iter=0; iter!=count; ++iter) {
    if (Derived<int>* dp = dynamic_cast<Derived<int>*>(bp)) {
      total += 5;
    }
    else if (Derived<float> *dp = dynamic_cast<Derived<float>*>(bp)) {
      total += 7;
    }
    else if (Derived<char> *dp = dynamic_cast<Derived<char>*>(bp)) {
      total += 2;
    }
    else if (
      Derived<unsigned long> *dp = dynamic_cast<Derived<unsigned long>*>(bp)
    ) {
      total += 9;
    }
  }
  return total;
}

static int test2(Base *bp)
{
  int total = 0;
  for (int iter=0; iter!=count; ++iter) {
    const std::type_info& type = typeid(*bp);

    if (type==typeid(Derived<int>)) {
      total += 5;
    }
    else if (type==typeid(Derived<float>)) {
      total += 7;
    }
    else if (type==typeid(Derived<char>)) {
      total += 2;
    }
    else if (type==typeid(Derived<unsigned long>)) {
      total += 9;
    }
  }
  return total;
}

static int test3(Base *bp)
{
  int total = 0;
  for (int iter=0; iter!=count; ++iter) {
    int id = bp->id();
    switch (id) {
      case 1: total += 5; break;
      case 2: total += 7; break;
      case 3: total += 2; break;
      case 4: total += 9; break;
    }
  }
  return total;
}

Без оптимизации я получил такие среды выполнения:

test1: 2.277s
test2: 0.629s
test3: 0.469s

С оптимизацией -O2 я получил следующие среды выполнения:

test1: 0.118s
test2: 0.220s
test3: 0.290s

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

В качестве альтернативы BaseThing может иметь чистый виртуальный GetID(), который будет использоваться для вывода типа вместо использования typeid. В этой ситуации только с 1 уровнем наследования, какова стоимость typeid по сравнению со стоимостью вызова виртуальной функции? Я знаю, что typeid каким-то образом использует vtable, но как именно это работает?

В Linux и Mac или где-либо еще, использующем Itanium C++ ABI, typeid(x) компилируется в две инструкции загрузки — он просто загружает vptr (то есть адрес некоторой vtable) из первых 8 байтов объекта x, а затем загружает -1th указатель из этой vtable. Этот указатель &typeid(x). Это на одну функцию менее затратно, чем вызов виртуального метода.

В Windows это включает порядка четырех инструкций загрузки и пару (незначительных) операций ALU, потому что Microsoft C++ ABI немного более предприимчивым. (источник). Честно говоря, это может оказаться наравне с вызовом виртуального метода. Но это все еще слишком дешево по сравнению с dynamic_cast.

dynamic_cast включает вызов функции в среду выполнения C++, которая имеет множество загрузок, условных переходов и тому подобного.

Так что да, использование typeid будет намного быстрее, чем dynamic_cast. Будет ли это правильно для вашего варианта использования? — это сомнительно. (См. другие ответы о заменяемости Лисков и т. д.) Но будет ли это быстро? — да.

Здесь я взял код игрушечного теста из высоко оцененного ответа Вона и превратил его в настоящий тест, избегая очевидных оптимизация подъема цикла, которая испортила все его тайминги. Результат для libc++abi на моем Macbook:

$ g++ test.cc -lbenchmark -std=c++14; ./a.out
Run on (4 X 2400 MHz CPU s)
2017-06-27 20:44:12
Benchmark                   Time           CPU Iterations
---------------------------------------------------------
bench_dynamic_cast      70407 ns      70355 ns       9712
bench_typeid            31205 ns      31185 ns      21877
bench_id_method         30453 ns      29956 ns      25039

$ g++ test.cc -lbenchmark -std=c++14 -O3; ./a.out
Run on (4 X 2400 MHz CPU s)
2017-06-27 20:44:27
Benchmark                   Time           CPU Iterations
---------------------------------------------------------
bench_dynamic_cast      57613 ns      57591 ns      11441
bench_typeid            12930 ns      12844 ns      56370
bench_id_method         20942 ns      20585 ns      33965

(Нижний ns лучше. Вы можете игнорировать последние два столбца: «ЦП» просто показывает, что он тратит все свое время на работу и не ждет, а «Итерации» — это просто количество запусков, которое потребовалось, чтобы получить хорошую погрешность. .)

Вы можете видеть, что typeid проигрывает dynamic_cast даже при -O0, но когда вы включаете оптимизацию, становится еще лучше, потому что компилятор может оптимизировать любой код, который вы пишете. Весь этот уродливый код спрятан внутри __dynamic_cast libc++abi функция не может быть оптимизирована компилятором больше, чем это уже было, поэтому включение -O3 не сильно помогло.

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