struct data
{
    int i;
};

struct base
{
    virtual void draw() = 0;
};

struct impl1 : base, virtual data
{
    virtual void draw()
    {
        std::cout << "impl1 " << i << std::endl;
    }
};

struct impl2 : base, virtual  data
{
    virtual void draw()
    {
        std::cout << "impl2 " << i << std::endl;
    }
};

struct last : impl1, impl2
{
};

int main()
{
    last l;
    base& b1 = static_cast<impl1&>(l);
    b1.draw();
    base& b2 = static_cast<impl2&>(l);
    b2.draw();
}

struct data
{
    int i;
};

struct base
{
    virtual void draw() = 0;
};

struct impl1 : base, virtual data
{
    virtual void draw()
    {
        std::cout << "impl1 " << i << std::endl;
    }
};

struct impl2 : base, virtual  data
{
    virtual void draw()
    {
        std::cout << "impl2 " << i << std::endl;
    }
};

struct last : impl1, impl2
{
    last() : self(static_cast<impl1*>(this)) {}

    template<typename type>
    void switch_to()
    {
        self = static_cast<type*>(this);
    }

    template<void (base::*f)()>
    void exec()
    {
        (self->*f)();
    }

    base* self;
};


int main()
{
    last l;
    l.exec<&base::draw>();
    l.switch_to<impl2>();
    l.exec<&base::draw>();
}

R>

  base* pb = ... ; 
  pb->draw();

(self->*f)();

CS>  base* pb = ... ; 
  pb->>draw();
CS>

// Было примерно так (схема упрощённая, так как у Base может быть много наследников...
// Ко всем классам, которые надо изменить припишу слово Old
class OldBase {
public:
    virtual void Method1() = 0; // На самом деле тут есть два варианта Impl1 и Impl2

protected:
    BaseData data;
};

class OldImpl1 : public OldBase {
public:
    virtual void Method1() { data.Impl1(); }
}; 

class OldImpl2 : public OldBase {
public:
    virtual void Method1() { data.Impl2(); }
}; 

void foo( OldBase* obj )
{
    obj->Method1();
}

// а станет так

struct IBaseProcessor {
    virtual void Method( BaseData& ) = 0;
};

class CBase {
public:
    
    void Method1() { processor->Method( data ); }

protected:
    IBaseProcessor* processor;
    BaseData data;
};

struct CBasePocessorImpl1 : IBaseProcessor {
    virtual void Method( BaseData& data ) { data.Impl1(); }
};

struct CBasePocessorImpl2 : IBaseProcessor {
    virtual void Method( BaseData& data ) { data.Impl2(); }
};

foo( Base * base )
{
    base->Method1(); // вообще ничего не меняется!!!
}

    last l;
    base& b1 = static_cast<impl1&>(l);
    base& b2 = static_cast<impl2&>(static_cast<last&>((b1));

#if defined(__cplusplus) && !defined(CINTERFACE)
    IXMLElement : public IDispatch
    {
    public:
        virtual HRESULT STDMETHODCALLTYPE get_tagName( BSTR *p) = 0;
    // ...
    };
    
#else     /* C style interface */

    typedef struct IXMLElement2Vtbl
    {
        BEGIN_INTERFACE
        /* IUnknown + IDispatch vtbl skipped*/
        

        HRESULT ( STDMETHODCALLTYPE *get_tagName )( IXMLElement2 * This, BSTR *p);
        
        /* ... */
        
        END_INTERFACE
    } IXMLElement2Vtbl;

    interface IXMLElement2
    {
        CONST_VTBL struct IXMLElement2Vtbl *lpVtbl;
    };
#endif

struct base
{
    int i;
    virtual void draw() = 0;
};

struct d1 : base
{
    virtual void draw()
    {
        std::cout << "d1 " << i << std::endl;
    }

    static d1 instance;
};

struct d2 : base
{
    virtual void draw()
    {
        std::cout << "d2 " << i << std::endl;
    }

    static d2 instance;
};

d1 d1::instance;
d2 d2::instance;

int main()
{
    d1 d;
    base& b = d;
    b.draw();
    *reinterpret_cast<void**>(&b) = *reinterpret_cast<void**>(&d2::instance);
    b.draw();
}

E>Всё равно отсанется необходимость в ручном поддержании "эквивалентности" различных реализаций

class P 
{
  virtual int foo() = 0;
}

class A 
{
  virtual int foo() { ... 1 }
}

class B 
{
  virtual int foo() { ... 2 }
}