Как узнать, какого типа объект находится по указателю

class Shape{
public:
  ~Shape(){}
  virtual void Draw() = 0;
};
class Triangle : public Shape{
  virtual void Draw(){}
};
class Circle : public Shape{
  virtual void Draw(){}
};
class Square : public Shape{
  virtual void Draw(){}
};
 
void main()
{
  std::vector<Shape *> vec;
  for(int i = 0; i < 10; i++){
    if ((i % 3) == 0)
      vec.push_back(new Triangle());
    if ((i % 3) == 1)
      vec.push_back(new Circle()); 
    if ((i % 3) == 2)
      vec.push_back(new Square());
  }
//предложите код который поможет узнать типы объектов в векторе
}

#include <iostream>
#include <vector>
#include <typeinfo>
 
class Shape
{
public:
    ~Shape(){}
    virtual void Draw() = 0;
};
 
class Triangle : public Shape
{
public:
    virtual void Draw(){}
};
 
class Circle : public Shape
{
public:
    virtual void Draw(){}
};
 
class Square : public Shape
{
public:
    virtual void Draw(){}
};
 
int main()
{
    std::vector<Shape*> vec;
    for(int i = 0; i < 10; i++)
    {
        if ((i % 3) == 0) vec.push_back(new Triangle());
        if ((i % 3) == 1) vec.push_back(new Circle());
        if ((i % 3) == 2) vec.push_back(new Square());
    }
    for(auto p : vec)
    {
        std::cout << typeid(*p).name() << std::endl;
    }
    return 0;
}

#include <cxxabi.h>
#include <stdio.h>
#include <vector>
using namespace std;
 
class Shape{
public:
  ~Shape(){}
  virtual void Draw() = 0;
};
class Triangle : public Shape{
  virtual void Draw(){}
};
class Circle : public Shape{
  virtual void Draw(){}
};
class Square : public Shape{
  virtual void Draw(){}
};
 
int main()
{
  std::vector<Shape *> vec;
  for(int i = 0; i < 10; i++){
    if ((i % 3) == 0)
      vec.push_back(new Triangle());
    if ((i % 3) == 1)
      vec.push_back(new Circle()); 
    if ((i % 3) == 2)
      vec.push_back(new Square());
  }
 
 //собсно идентификация: 
 
 int status;
 char* realname;
 
 realname = abi::__cxa_demangle(typeid(*vec[0]).name(), 0, 0, &status);
 printf (realname);
 getchar ();
 
 realname = abi::__cxa_demangle(typeid(*vec[1]).name(), 0, 0, &status);
 printf (realname);
 getchar ();
 
 realname = abi::__cxa_demangle(typeid(*vec[2]).name(), 0, 0, &status);
 printf (realname);
 getchar ();
 
 
 
}

//получили дугу из N точек
auto arc = Figure::create<Arc>(param1);
 
//получили отрезок
auto line = Figure::create<Line>(param2);
 
//получили замкнутую фигуру из одной дуги и одного отрезка
auto fugure = (arc + line).close();

#include <string>
#include <typeinfo>
#include <iostream>
using namespace std;
 
struct Circle;
struct Line;
struct Arc;
 
struct Element
{
    virtual void Intersect(Element& Object) = 0;
 
    virtual void Collision(Element&) = 0;
    
    //--- элементы не обязаны уметь обрабатывать данный тип фигуры
    // если они не определили алгоритм обработки - 
    // будет задействован универсальный алгоритм с применением адаптивной деградации
    virtual void Collision(Circle& el);
 
    virtual void Collision(Line&) = 0;
    virtual void Collision(Arc&) = 0;
 
    static void Collision(Line&, Line&)
        { cout << "intersection: line vs line\n";     }
    static void Collision(Line&, Arc&)
        {  cout << "intersection: line vs arc\n";     }
    static void Collision(Arc&, Arc&)
        { cout << "intersection: arc vs arc\n";       }
    static void Collision(Circle&, Circle&)
        { cout << "intersection: circle vs circle\n"; }
 
    template<class T>
    static void Collision(Circle&, T&)
        { cout << "circle vs figure with adaptive degradation...\n"; }
 
    
 
    
};
 
struct Line : Element
{
    //--- если срабатывает метод, принимающий базовый элемент
    // значит данная фигура не знает уникального алгоритма обработки
    // фактического типа этого элемента
    // в этом случае задействуется универсальный алгоритм 
    // с использованием адаптивной деградации
    virtual void Collision(Element&)
        { cout << "line vs figure with adaptive degradation...\n";  }
 
    virtual void Collision(Line& l)
        { Element::Collision(*this, l); }
    virtual void Collision(Arc& a)
        { Element::Collision(*this, a); }
    virtual void Intersect(Element& object)
        { object.Collision(*this); }
};
 
struct Arc : Element
{
    virtual void Collision(Element&)
        { cout << "arc vs figure with adaptive degradation...\n"; }
 
    virtual void Collision(Line& l)
        { Element::Collision(l, *this); }
    virtual void Collision(Arc& a)
        { Element::Collision(*this, a); }
    virtual void Intersect(Element& object)
        { object.Collision(*this); }
};
 
struct Circle : Element
{
    virtual void Collision(Element&)
        { cout << "circle vs figure with adaptive degradation...\n"; }
 
    virtual void Collision(Line& l)
        { Element::Collision(*this, l); }
    virtual void Collision(Arc& a)
        { Element::Collision(*this, a); }
    virtual void Collision(Circle& c)
        { Element::Collision(*this, c); }
    virtual void Intersect(Element& object)
        { object.Collision(*this); }
};
 
 
void Element::Collision(Circle& el)
{
    Collision(static_cast<Element&>(el));
}
 
int main()
{
    Line   line;
    Arc    arc;
    Circle cir;
 
    line.Intersect(line);
    line.Intersect(arc);
    arc.Intersect(arc);
    arc.Intersect(line);
 
    cout << "--------------------------\n";
 
    cir.Intersect(line);
    cir.Intersect(arc);
    cir.Intersect(cir);
}

#include <boost/variant.hpp>
#include <stdexcept>
 
struct line {
 
};
 
struct arc {
 
};
 
struct intersects_algo : boost::static_visitor<bool> {
    bool operator()( const line& l1, const line& l2 ) const {
        throw std::runtime_error( "not implemented" );
    }
 
    bool operator()( const arc& a1, const arc& a2 ) const {
        throw std::runtime_error( "not implemented" );
    }
 
    bool operator()( const line& l, const arc& a ) const {
        throw std::runtime_error( "not implemented" );
    }
 
    bool operator()( const arc& a, const line& l ) const {
        return this->operator()( l, a );
    }
};
 
using element = boost::variant<line, arc>;
 
bool intersects( const element& e1, const element& e2 ) {
    return boost::apply_visitor(intersects_algo(), e1, e2 );
}
 
 
 
int main() {
 
    element e1 = line{};
    element e2 = arc{};
 
    bool result = intersects( e1, e2 );
 
    return 0;
}

//участники 
struct Line: Element {...};
struct Arc: Element {...};
struct Circle: Element {...};
 
...
 
bool Collision(int, Arc&);      //<--- мультиметоду не важны наследственные связи
bool Collision(Some, Arc&);  // участники вообще не обязаны быть полиморфами
 
bool Collision(Line&, Arc&);
 
bool Collision(Arc&, Element&);  //<--- версия с базовым классом будет выбрана автоматически, 
//если нет обработчика, способного принять вторым аргументом фактический тип
 
bool CollisionEx(Element&, Element&); //<--- Можно использовать любые имена, а не только перегрузки
//версия, которая принимает оба аргумента в виде базовых классов
//выбирается, если не было обнаружено ни одного подходящего обработчика, 
//принимающего фактические типы
 
...
 
 
//где то в бизнес-коде функция, которая получает на вход базовые интерфейсы
//и ей нужно выполнить "пересечение"
 
boo Work(Element& one, Element& two )
{
     // здесь мы уже не владеем информацией о фактических типах элементов
     // но нам очень нужно выполнить пересечение
     // для этого мы создаем мультиметод
 
     // утилита make умеет создавать мультиметоды
     auto mmethod = tools::make<multimethod>(
 
         //от пользователя требуется просто перечислить функции-обработчики
 
         // утилита make помогает разрулить коллизии перегрузок
         tools::make<int, Arc&>(Collision),   
         tools::make<Some, Arc&>(Collision),
         tools::make<Line&, Arc&>(Collision),
         tools::make<Arc&, Element&>(Collision),
         CollisionEx //<--- уникальное имя можно закинуть без всяких утилит
     );
 
     return mmetod(one,two); //<--- механизм времени компиляции распарсил аргументы
     // всех функций-обработчиков, которыми его накормили при создании
 
     //он знает какими теоретически могут быть аргументы
     //времени компиляции он проверяет входящие аргументы на предмет наследственных связей
 
    //фактически там, внутри его на шаблонах развернулась невидимая архитектура, 
    //очень сильно похожая на ту, что я приводил в предыдущем своем примере
 
    //вот только умный механизм сделал это самостоятельно, 
    //автоматически, без участия человека
 
    //от человека нужно только написать сами функции-обработчики
    //и указать их список мультиметоду.
    //все остальное он сделает сам.
 
}