Дорого ли приведение указателей?

#include <chrono>
#include <iostream>
 
class A
{
    int f1=0;
public:
    virtual ~A()
    {
    }
};
 
class B:public A
{
public:
    virtual ~B()
    {
    }
};
 
int main()
{
    const int64_t iters=10000000;
    std::cout<<"iters: "<<iters<<std::endl;;
    {
        auto start = std::chrono::system_clock::now();
        for(int64_t i=0; i<iters; i++ )
        {
            A* a=new B();
 
            auto* b=dynamic_cast<B*>(a);
 
            delete a; a=0;
        }
        auto end = std::chrono::system_clock::now();
        auto elapsed = std::chrono::duration_cast<std::chrono::milliseconds>(end-start).count();
        std::cout<<"dynamic_cast: "<<elapsed<<" ms"<<std::endl;
    }
 
    {
        auto start = std::chrono::system_clock::now();
        for(int64_t i=0; i<iters; i++ )
        {
            A* a=new B();
 
            const std::type_info& info=typeid(*a);
            //std::string s=info.name();
 
            delete a; a=0;
        }
        auto end = std::chrono::system_clock::now();
        auto elapsed = std::chrono::duration_cast<std::chrono::milliseconds>(end-start).count();
        std::cout<<"typeid: "<<elapsed<<" ms"<<std::endl;;
    }
 
    system("pause");
    return 0;
}

std::type_info * info = a->vptr->ptypeinfo;

std::type_info * info = a->vptr->ptypeinfo;
b = someoffsetalgo(info, a); // см. ссылку выше

#include <stdio.h>
#include <string.h>
 
//объявляем родительский класс с виртуальными полями
class cCl{
public:
  int field;
  cCl(){field = 1;}
  virtual void func(){printf("cCl\n");}
  virtual int func2(int a, int b){printf("cCl(%i, %i) ", a, b); return a+b+field;}
};
 
//объявляем дочерний класс с не менее виртуальными полями
class cChild:public cCl{
public:
  cChild(){field = 2;}
  virtual void func(){printf("cChild\n");}
  virtual int func2(int a, int b){printf("cChild(%i, %i) ", a, b); return a-b+field;}
};
 
//прототипы "методов"
typedef void (cCl_func)(cCl*);
typedef int (cCl_func2)(cCl*, int, int);
 
//хакерская структура для получения доступа к внутренностям классов
struct sCl{
  void **fn; //таблица виртуальных функций!
  int field; //поля класса (для демонстрации не обязательны)
};
 
void test(cCl *self){printf("test\n");}
 
int main(){
  cCl *sample = new cCl; //создаем "чистый" экземпляр родителя
  cCl *virt = new cChild; //создаем потомка через наследование
  cChild *child = new cChild; //создаем "чистого" потомка
  sCl *str;
  int res;
  
  //влезаем во внутренности родителя
  str = (sCl*)sample;
  printf("Sample: ");
  ((cCl_func*)str->fn[0])(sample); //ТАДАМ! Мы вызвали виртуальный метод func
  res = ((cCl_func2*)str->fn[1])(sample, 2, 1); //ТАДАМ! Мы вызвали виртуальный метод func2 даже с параметрами
  printf("%i\n", res);
  printf("\n");
  
  str = (sCl*)virt;
  printf("Virt  : ");
  ((cCl_func*)str->fn[0])(virt);
  res = ((cCl_func2*)str->fn[1])(virt, 2, 1);
  printf("%i\n", res);
  printf("\n");
  
  str = (sCl*)child;
  printf("Child : ");
  ((cCl_func*)str->fn[0])(child);
  res = ((cCl_func2*)str->fn[1])(child, 2, 1);
  printf("%i\n", res);
  printf("\n");
  
  
  str->fn = ((sCl*)sample)->fn;
  printf("Hacked: ");
  child->func();
  res = child->func2(2,1);
  printf("%i\n", res);
  str->fn = ((sCl*)child)->fn;
  
  
  //не забываем прибраться за собой!
  delete child;
  delete virt;
  delete sample;
}

        for(int64_t i=0; i<iters; i++ )
        {
             auto* b=dynamic_cast<B*>(a);
        }
 
        for(int64_t i=0; i<iters; i++ )
        {
            const std::type_info& info=typeid(*a);
        }