Обобщаем паттерн посетитель (С++)

struct BaseObject
{
    /* contructors */

    //общая функция для всех потомков
    std::string_view getName() const { return name; } 

    //строго говоря, эта функция не обязана быть чисто виртуально, мы вполне может сделать
    //базовое определение
    virtual void action() = 0; 
    //virtual void action() { /* BaseObject specific code */} 

protected:
    std::string name; //общее поле для всех потомков
};

struct SomeObject1 : BaseObject
{
    /* contructors */
    
    void action() override { /* SomeObject1 specific code */ }
    
protected:
    //имеем доступ к name 
};

struct SomeObject2 : BaseObject
{
    /* contructors */
    
    void action() override { /* SomeObject2 specific code */ }
    
protected:
    //имеем доступ к name
};

template< class T >
void test( T& obj )
{
    /*some code*/
}

std::vector< BaseObject* > vector = { /* some objects */ };

//Что хотел бы по пунктам:
for( auto* obj : vector )
{
    //1. вызывать обычную функцию базового класса напрямую (без оберток)
    std::cout « obj->getName();
    //2. вызывать виртуальную функцию (без оберток)
    obj->action();
    //3. а вот тут нам понадобился реальный тип, чтобы вызвать шаблон функции.
    //И об этом как раз статья и написана
    //obj->dispatch( [](auto&) { test( obj ); } );
}

struct SomeObject1
{
    /* contructors */
    std::string_view getName() const { return name; } //ok
    void action() { /* specific SomeObject1 code */ } //ok
    
protected:
    std::string name; //ok
};

struct SomeObject2
{
    /* contructors */
	//дублируем код (В SomeObject1 уже есть такая функция )
    std::string_view getName() const { return name; }
    void action() { /* specific SomeObject2 code */ } //ok
    
protected:
    std::string name; //дублируем код (В SomeObject1 уже есть такая функция)
};

struct Variant //Ваш класс обертка
{
    /* contructors */
    void getName() const { std::visit([]( auto&& obj) { return obj.getName(); }, var ) }
    void action() { std::visit([]( auto&& obj) { return obj.getName(); }, var ); }
    
    template< class Functor >
    void dispatch( Functor functor )
    {
    /* ... */
    }
    
private:
    std::variant< Object1, Object2 > var;
};

std::vector< Variant > vector = { /* some objects */ };

//Проводим парарелль
for( auto& var : vector )
{
    //1. вызываем функцию обертки, в которой вызываем std::visit и только потом вызываем getName.
    std::cout « var.getName();
    //2. тоже что и в 1
    var.action();
    //3. вытаскиваем тип тип из обертки и передали в шаблон функции
    var.dispatch( [](auto&) { test( obj ); } );
}

struct SomeObject1 //ok код не дублируется
{
    /* contructors */
    void action() { /* specific SomeObject1 code */ }
};

struct SomeObject2 //ok код не дублируется
{
    /* contructors */
    void action() { /* specific SomeObject2 code */ }
};

struct SamePart //Допустим
{
    std::string name;
};

struct Variant //Ваш класс обертка
{
    /* contructors */
    std::string_view getName() const { return samePart.name; }
    void action() { std::visit([]( auto&& obj) { return obj.action(); }, var ); }
    
    template< class Functor >
    void dispatch( Functor functor )
    {
    /* ... */
    }
    
private:
    SamePart samePart;
    std::variant< Object1, Object2 > var;
};