class Bar: public IBar1,
           public IBar2,
           ...
           public IBar9
{
  int ref_count;
  unsigned flags;
  ...    
  // реализация IBar1
  virtual void foo1() override;
  ...
};

struct IBar1 { virtual void Foo1() {} };
struct IBar2 { virtual void Foo2() {} };
struct IBar3 { virtual void Foo3() {} };

struct CBar : IBar1, IBar2, IBar3 {
    void Foo1() { /*реализация IBar1::Foo1*/ }
    void Foo2() { /*реализация IBar2::Foo2*/ }
    void Foo3() { /*реализация IBar3::Foo3*/ }
};

struct ISuperBar {
    virtual void Foo1() {}
    virtual void Foo2() {}
    virtual void Foo3() {}
};

class IBar1 : ISuperBar {
public:
    static IBar1* To(ISuperBar* p) { return static_cast<IBar1*>(p); }
    using ISuperBar::Foo1;
};

class IBar2 : ISuperBar {
public:
    static IBar2* To(ISuperBar* p) { return static_cast<IBar2*>(p); }
    using ISuperBar::Foo2;
};

class CBar : ISuperBar {
public:
    operator IBar1*() { return IBar1::To(this); }
    operator IBar2*() { return IBar2::To(this); }

    void Foo1() { /*реализация IBar1::Foo1*/ }
    void Foo2() { /*реализация IBar2::Foo2*/ }
    void Foo3() { /*реализация IBar3::Foo3*/ }

};

CBar bar;
IBar2* pBar2 = bar;

E>Я верно понимаю, что методы IBar1, ... IBar9 не пересекаются и ты можешь их менять?..

E>    operator IBar1*() { return IBar1::To(this); }
E>    operator IBar2*() { return IBar2::To(this); }

virtual operator IBar1*() = 0;
virtual operator IBar2*() = 0;

Q>virtual operator IBar1*() = 0;
Q>virtual operator IBar2*() = 0;
Q>

virtual operator IBar1*() { return 0; }
virtual operator IBar2*() { return 0; }

E>>Я верно понимаю, что методы IBar1, ... IBar9 не пересекаются и ты можешь их менять?..

#include <iostream>

using std::cout;

struct IFoo1 {
    virtual void foo1() = 0;
};

struct IFoo2 {
    virtual void foo2() = 0;
};

struct Foo {
    void foo1() {}
    void foo2() {}
};

struct ImplementInterfaces : public IFoo1, IFoo2 {
    ImplementInterfaces(Foo &foo): foo_(foo) {}
    void foo1() override { foo_.foo1(); }
    void foo2() override { foo_.foo2(); }
private:
    Foo &foo_;
};


int main() {
    cout << sizeof(Foo) << "\n";
}

Q>class Bar: public IBar1,
Q>           public IBar2,
Q>           ...
Q>           public IBar9
Q>{
Q>  int ref_count;
Q>  unsigned flags;
Q>  ...    
Q>  // реализация IBar1
Q>  virtual void foo1() override;
Q>  ...
Q>};
Q>

class IBar1 {};
class IBar2: public IBar1 {}
class IBar3: public IBar2 {}
...
class Bar: public IBarN
{
Impl;
}
...
PROFIT

E>Почему?

E>С точки зрения клиентского кода вообще ничего, кроме того, что кастить надо иначе, не поменяется же?

void foo(ISerializable& arg);

template<typename Serializable>
void foo(Serializable& arg) { ... }

E>is a к интерфейсам вообще не применим. Там другое отношение "поддерживает интерфейс"...

class ISerializable: public IPrintable { ... };
// или
class IPrintable : public ISerializable{ ... };

// SuperBar.h
struct ISerializable;
struct IClonable;
struct IDeletable
//    И т. д...

class ISuperBar {
public:
    virtual operator ISerializable*() { return 0; }
    virtual operator IClonable*() { return 0; }
    virtual operator IDeletable*() { return to<IDeletable>(); }
    //    И т. д...

protected:
    template<typename I> I* to() { return (I*)this; }
    template<typename const I> I* to() const { return (const I*)this; }

    virtual ~ISuperBar() {}

    // ISerializable
    virtual void Serialize() { assert( false ); }

    // IClonable
    virtual ISuperBar* Clone() { assert( false ); }

    // IDeletable
    virtual void Delete() { delete this; }

    //    И т. д...

};

struct IDeletable : ISuperBar {
using ISuperBar::Delete;
};

////////////////////////////
// Serializable.h

#include <SuperBar.h>
struct ISerializable : ISuperBar {
using ISuperBar::Serialize;
};

////////////////////////////
// Clonable.h

#include <SuperBar.h>
struct IClonable : ISuperBar {
using ISuperBar::Clone;
};

struct CBar : ISuperBar {
    // ISerializable
    operator ISerializable*() { return to<ISerializable>(); }
    void Serialize() { /*реализация*/ }

    // IClonable
    operator IClonable*() { return to<IClonable>(); }
    IClonable* Clone() { /*реализация*/ }
};

class CFoo : public IClonable {
public:
    CFoo* Clone() { return new CFoo( *this ); }
};

void foo( IClonable* p ) { p->Clone()->operator IDeletable*()->Delete(); }

CBar b;
foo( b );

CFoo f;
foo( &f );