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

#include <SuperCat.h>
struct ISerializable : ISuperCat {
using ISuperCat::Serialize;
};

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

#include <SuperDog.h>
struct ISerializable : ISuperDog {
using ISuperDog::Serialize;
};

struct IBase {
    virtual ~IBase(){}
    template<typename I> I* GetAs(  I*& dst ) { return dst = dynamic_cast<I*>( this ); }
    template<typename I> const I* GetAs(  const I*& dst ) const { return dst = dynamic_cast<const I*>( this ); }
}

    template<typename I> I* GetAs() {
        I* i = 0;
        return this->GetAs( i );
    }
    template<typename I> const I* GetAs() const {
        const I* i = 0;
        return this->GetAs( i );
    }

Q>////////////////////////////
Q>// Serializable.h

Q>#include <SuperCat.h>
Q>struct ISerializable : ISuperCat {
Q>using ISuperCat::Serialize;
Q>};
Q>

Q>////////////////////////////
Q>// Serializable.h

Q>#include <SuperDog.h>
Q>struct ISerializable : ISuperDog {
Q>using ISuperDog::Serialize;
Q>};
Q>

E>Ты же говорил, что у тебя только одна популярная версия MDT?

struct IGentlemansSet { ... };

#include "common.h"
struct IBarPublic1: IGentlemansSet { ... };
struct IBarPublic2: IBarPublic1 { ... };

#include <public/bar.h>
struct IBarPrivate1: IBarPublic2{ ... };
struct IBarPrivate2: IBarPrivate1 { ... };

struct CBar: IBarPrivate2 { ... };

E>Можно операторы приведения к ссылке на интерфейс сделать, а не к указателю.

virtual operator IBar1*() { return 0; }

struct IFoo;
struct IBar;
struct IBuz;

struct IObject {
  virtual proxy<IFoo> as_foo() = 0;  // proxy<> - на вкус и цвет.
  virtual proxy<IBar> as_bar() = 0;
  virtual proxy<IBuz> as_buz() = 0;
  // ну и какие-то совсем уж общие полезняшки, присущие всем объектам
  virtual ~IObject() {}
  virtual const char* classname() const = 0;
  .....
};

// пример реализации прокси

template<class I> using proxy = shared_ptr<I>; // неэффективно по скорости - тройная косвенность, но как proof of concept сойдёт

template<class T> struct impl_proxy_IFoo : IFoo {
  shared_ptr<T> obj_;
  impl_proxy_IFoo(shared_ptr<T> obj) : obj_(obj) {}

  void foo1() override { return obj_->foo1(); } // где у T эти функции даже не обязательно виртуальные
  void foo2() override { return obj_->foo2(); } // и даже необязательно совпадающие по именам (хотя это было бы проще)
};

template<class Final> struct impl_IObject {  // один большой CRTP, или россыпью миксинов, или вообще тупо на макросах в каждом классе...
  shared_ptr<IFoo> as_foo() override {
    static_if( support_foo<Final>::value )
      return make_shared<impl_proxy_IFoo<Final>>(static_cast<Final*>(this)->shared_from_this());
    else
      return shared_ptr<IFoo>();
  }
  . . .
};

// использование
shared_ptr<IObject> x = get_some_object_from_big_cloud();
shared_ptr<IFoo> f = x->as_foo();
f->foo1();
f->foo2();

struct IFoo {
  function<void()> foo1(); // или какой-то более легковесный контейнер для замыкания известной природы: T* ->* (T::*)(blablabla)
  function<void()> foo2();
};

template<class I> using proxy<I> = I;

.....
  IFoo as_foo() override {
    return {
      [this](){this->foo1();},
      [this](){this->foo2();},
    };
  }
.....

shared_ptr<IFoo> f = x->as_foo();

struct IBar: ISerializable,
             IClonable,
             ...
{
};

IBar& bar = findSomeBar(key);
saveToDisk("bar.dat", bar); // тип второго параметра: const ISerializable&

IBar& bar = findSomeBar(key);
shared_ptr<ISerializable> s = bar.as_serializable();
assert(s);
saveToDisk("bar.dat", *s);

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

Q>shared_ptr<IFoo> f = x->as_foo();
Q>

#include <iostream>
#include <memory>
using namespace std;

// наши интерфейсы...
struct IObject;

struct IFoo {
    struct Ref; // ссылкообразный тип на данный интерфейс
    virtual operator IObject&() = 0; // возвращение к первоисточнику
    virtual void f() = 0;
    virtual void g() = 0;
};
struct IBar {
    struct Ref;
    virtual operator IObject&() = 0;
    virtual void b() = 0;
    virtual void c() = 0;
};

// ссылки - это фасады пимплов
struct IFoo::Ref {
    template<class T> struct Thunk; // а это - реализация пимпла
    shared_ptr<IFoo> ptr; // лень следить за копиями/ссылками; хочешь, возьми unique_ptr
    operator IObject&() { return *ptr; }
    void f() { ptr->f(); }
    void g() { ptr->g(); }
};
struct IBar::Ref {
    template<class T> struct Thunk;
    shared_ptr<IBar> ptr;
    operator IObject&() { return *ptr; }
    void b() { ptr->b(); }
    void c() { ptr->c(); }
};

// реализации пимплов
template<class T> struct IFoo::Ref::Thunk : IFoo {
    T* ptr; // как и просил - никакого контроля за владением (а может, всё же, хотя бы weak_ptr?)
    Thunk(T* p) : ptr(p) {}
    operator IObject&() { return *ptr; }
    void f() override { ptr->f(); }
    void g() override { ptr->g(); }
};
template<class T> struct IBar::Ref::Thunk : IBar {
    T* ptr;
    Thunk(T* p) : ptr(p) {}
    operator IObject&() { return *ptr; }
    void b() override { ptr->b(); }
    void c() override { ptr->c(); }
};

// порождающая функция проксей
template<class I, class T> // I явный, T выводится
typename I::Ref make_proxy(T* p) {
    return typename I::Ref{
        make_shared<typename I::Ref::template Thunk<T>>(p)
    };
}

// метаинтерфейс (должен быть объявлен после фасадов, ибо возвращает значения)
struct IObject {
    virtual operator IFoo::Ref() = 0;
    virtual operator IBar::Ref() = 0;
};

// вот наш класс!
struct Something : IObject {
    operator IFoo::Ref() override { return make_proxy<IFoo>(this); }
    operator IBar::Ref() override { return make_proxy<IBar>(this); }
    void f() { cout << "Something::f\n"; }
    void g() { cout << "Something::g\n"; }
    void b() { cout << "Something::b\n"; }
    void c() { cout << "Something::c\n"; }
};

// вот наш объект (один штучка)
Something smth;
IObject* lookup() { return &smth; }

// вот наш клиентский код!
void doit(IFoo::Ref foo) {
    foo.f();
    foo.g();
    IBar::Ref bar = (IObject&)foo; // поскольку IFoo и IBar независимы, делаем up-down-каст
    bar.b();
    bar.c();
}

int main() {
    doit(*lookup());
}

virtual operator IBar1*() { return 0; }

virtual ISerializable* getSerializable() { return 0; }
operator ISerializable&() { return *getSerializable(); } // добавить обработку ошибок по вкусу

template<typename I> bool QI( T*& dst ) { return ( dst = dynamic_cat<T*>( this ) ) != 0; }
virtual bool QI( ISerializable*& dst ) { return ( dst = 0 ) != 0; }
virtual bool QI( IClonable*& dst ) { return ( dst = 0 ) != 0; }
//...
template<typename I> operator I&()
{
    I* dst = 0;
    if( !this->QI( dst ) ) {
        // тут обрабатываем ошибку как-то.
    }
    return *dst;
}

struct IBar: ISerializable,
             IClonable,
             ...
{
};

struct IBaz: IClonable,
         IComparable,
             ...
{
};

IBar& getRandomBar();
IBaz& getRandomBaz();

void saveSomethingToDisk(const char* filename, ISerializable& s);

int main()
{
  IBar& bar = getRandomBar();
  saveSomethingToDisk("bar.dat", bar);

  IBaz& baz = getRandomBaz();
  saveSomethingToDisk("baz.dat", baz); // << compile time error, IBaz не поддерживает ISerializable
  return 0;
}

К>// вот наш клиентский код!
К>void doit(IFoo::Ref foo) {
К>    foo.f();
К>    foo.g();
К>    IBar::Ref bar = (IObject&)foo; // поскольку IFoo и IBar независимы, делаем up-down-каст
К>    bar.b();
К>    bar.c();
К>}
К>

struct OldBig: IFoo
{
  // реализация IFoo
  virtual void f() override;
  virtual void g() override;

  // теперь еще
  virtual operator IObject&() override { /*запретить бы его вызов в compile time*/ } 
};

void doit(IFoo& foo);
...
doit((IFoo::Ref)*lookup());
...

Q>struct OldBig: IFoo
Q>{
Q>  // реализация IFoo
Q>  virtual void f() override;
Q>  virtual void g() override;

Q>  // теперь еще
Q>  virtual operator IObject&() override { /*запретить бы его вызов в compile time*/ } 
Q>};
Q>

unique_ptr<IEverything> lookup() {
  ..... make_everything( the_object ) .....
}

Q>struct IBar: ISerializable,
Q>             IClonable,
Q>             ...
Q>{
Q>};

struct IBar : protected IGentlemansSet {
    using IGentlemansSet::operator ISerializable&;
    using IGentlemansSet::operator IClonable&;
        ...
};

Q>struct IBaz: IClonable,
Q>         IComparable,
Q>             ...
Q>{
Q>};

Q>IBar& getRandomBar();
Q>IBaz& getRandomBaz();

Q>void saveSomethingToDisk(const char* filename, ISerializable& s);

Q>int main()
Q>{
Q>  IBar& bar = getRandomBar();
Q>  saveSomethingToDisk("bar.dat", bar);

Q>  IBaz& baz = getRandomBaz();
Q>  saveSomethingToDisk("baz.dat", baz); // << compile time error, IBaz не поддерживает ISerializable
Q>  return 0;
Q>}
Q>

// Предъобявления интиерфейсов
struct ISerializable;
struct IClonable
// ...

struct IGentlemansSet {
protected:
    virtual ~IGentlemansSet() {}

    template<typename T> T* to();
    template<typename T> const T* to() const; // если надо
    
    operator ISerializable& () { return *to<ISerializable>(); }
    operator IClonable&() { return *to<IClonable>(); }
    // ...

    // virtual методы ISerializable
    virtual void save( TSaveDst& ) const { assert( false ); }
    virtual bool load( TLoadSrc& ) { assert( false ); return false; }
    
    // virtual методы IClonable
    // ...

    // ...

};

template<typename T>
T* IGentlemansSet::to<T>() { return static_cast<T*>( this ); }

template<typename T>
const T* IGentlemansSet::to<T>() const { return static_cast<T*>( this ); }

// было
struct ISerializable {
    virtual void save( TSaveDst& ) const = 0;
    virtual bool load( TLoadSrc& ) = 0;
};

// стало
struct ISerializable : protected IGentlemansSet {
    using IGentlemansSet::load;
    using IGentlemansSet::save;
}

	таки прикручиваются CT проверки реализации нужных методов!
	собственно было у тебя, как я понимаю, так:   было // Serializable.h class CSaveDst { // тут определение }; class CLoadSrc { // тут определение }; struct ISerializable { virtual void Save(CSaveDst&) const = 0; virtual bool Load(CLoadSrc&) = 0; }; // Printable.h struct IPrintable { virtual void Print() const = 0; }; // FreqUsed.h struct IFreqUserBar : IPrintable, ISerializable { }; struct IFreqUsedBaz : IPrintable { }; // FreqUsed.inc struct CFreqUsedBar : IFreqUsedBar { // ISerializable void Save(CSaveDst&) const override { }; bool Load(CLoadSrc&) override { return false; } // IPrintable void Print() const override { } // *** }; struct CFreqUsedBaz : IFreqUsedBaz { // IPrintable void Print() const override { } }; // UsualUsed.h struct IBar : IPrintable, ISerializable { }; struct IBaz : IPrintable { }; // UsualUsed.inc struct CBar : IBar { // ISerializable void Save(CSaveDst&) const override { }; bool Load(CLoadSrc&) override { return false; } // IPrintable void Print() const override { } }; struct CBaz : IBaz { // IPrintable void Print() const override { } }; // Test.cpp void saveIt(ISerializable&); void test(IFreqUsedBar& fr, IFreqUsedBaz& fz, IBar& r, IBaz& z) { CFreqUsedBar bar; // если закомментировать строчку ***, то не соберётся saveIt(fr); // saveIt(fz); // не соберётся, так как IFreqUsedBaz не умеет ISerializable saveIt(r); // saveIt(z); // не соберётся, так как IBaz не умеет ISerializable } Напоминаю, что проблема у нас в том, что в оптимизированном варианте нет проверки что все нужные методы во всех MDT реализованы. Тут подход с фейковыми интерфейсами сразу в плюсе, потому, что позволяет оставить проверки хотя бы для того клиентского кода, который в оптимизации не нуждается, а просто поддерживает ISerializable. Но если пойти на то, что бы проверка делалась при сборке специальной неоптимизированной сборки, то всё получается вообще хорошо, кроме того, что в оптимизированном коде есть какое-то количество макросни.   магия на макросах // GentlemansSet.h // Управляет тем, оптимизированную или проверочную версию мы собираем. #define _USE_GENTLEMANS_SET_OPTIMIZATION #ifdef _USE_GENTLEMANS_SET_OPTIMIZATION #define GENTLEMANS_SET_OPTIMIZATION_BASE(...) private IGentlemansSet #define GENTLEMANS_SET_OPTIMIZATION_ENABLE_( I ) \ using IGentlemansSet::operator I&; #define GENTLEMANS_SET_OPTIMIZATION_ENABLE( I ) \ GENTLEMANS_SET_OPTIMIZATION_ENABLE_( I )\ GENTLEMANS_SET_OPTIMIZATION_ENABLE_( const I ) #define GENTLEMANS_SET_OPTIMIZATION_OVERRIDE_ override = 0 #else// _USE_GENTLEMANS_SET_OPTIMIZATION #define GENTLEMANS_SET_OPTIMIZATION_BASE(...) __VA_ARGS__ #define GENTLEMANS_SET_OPTIMIZATION_ENABLE( I ) #define GENTLEMANS_SET_OPTIMIZATION_INTERFACE_IMP_( I ) #define GENTLEMANS_SET_OPTIMIZATION_OVERRIDE_ = 0 #endif// _USE_GENTLEMANS_SET_OPTIMIZATION struct ISerializable; class CSaveDst; class CLoadSrc; struct IPrintable; // ... struct IGentlemansSet { protected: virtual ~IGentlemansSet() {} # ifdef _USE_GENTLEMANS_SET_OPTIMIZATION #define GENTLEMANS_SET_OPTIMIZATION_INTERFACE_BEGIN_( I )\ operator I&();\ operator const I&() const; #define GENTLEMANS_SET_OPTIMIZATION_INTERFACE_END_() #define GENTLEMANS_SET_OPTIMIZATION_INTERFACE_IMP_( I )\ inline IGentlemansSet::operator I&() { return *static_cast<I*>(this); }\ inline IGentlemansSet::operator const I&() const { return *static_cast<const I*>(this); } GENTLEMANS_SET_OPTIMIZATION_INTERFACE_BEGIN_(ISerializable) virtual void Save(CSaveDst&) const { assert(false); } virtual bool Load(CLoadSrc&) { assert(false); return false; } GENTLEMANS_SET_OPTIMIZATION_INTERFACE_END_() GENTLEMANS_SET_OPTIMIZATION_INTERFACE_BEGIN_(IPrintable) virtual void Print() const { assert(false); } GENTLEMANS_SET_OPTIMIZATION_INTERFACE_END_() // ... # endif// _USE_GENTLEMANS_SET_OPTIMIZATION }; // Serializable.h //#include <GentlemansSet.h> class CSaveDst { // тут определение }; class CLoadSrc { // тут определение }; struct ISerializable : private IGentlemansSet { friend IGentlemansSet; virtual void Save(CSaveDst&) const GENTLEMANS_SET_OPTIMIZATION_OVERRIDE_; virtual bool Load(CLoadSrc&) GENTLEMANS_SET_OPTIMIZATION_OVERRIDE_; }; GENTLEMANS_SET_OPTIMIZATION_INTERFACE_IMP_(ISerializable) // Printable.h //#include <GentlemansSet.h> struct IPrintable : private IGentlemansSet { friend IGentlemansSet; virtual void Print() const GENTLEMANS_SET_OPTIMIZATION_OVERRIDE_; }; GENTLEMANS_SET_OPTIMIZATION_INTERFACE_IMP_(IPrintable) // FreqUsed.h struct IFreqUsedBar : GENTLEMANS_SET_OPTIMIZATION_BASE(IPrintable, ISerializable) { GENTLEMANS_SET_OPTIMIZATION_ENABLE(ISerializable); GENTLEMANS_SET_OPTIMIZATION_ENABLE(IPrintable); }; struct IFreqUsedBaz : GENTLEMANS_SET_OPTIMIZATION_BASE(IPrintable) { GENTLEMANS_SET_OPTIMIZATION_ENABLE(IPrintable); }; // FreqUsed.inc struct CFreqUsedBar : IFreqUsedBar { // ISerializable void Save(CSaveDst&) const override { }; bool Load(CLoadSrc&) override { return false; } // IPrintable void Print() const override { } // *** }; struct CFreqUsedBaz : IFreqUsedBaz { // IPrintable void Print() const override { } }; // UsualUsed.h struct IBar : IPrintable, ISerializable { }; struct IBaz : IPrintable { }; // UsualUsed.inc struct CBar : IBar { // ISerializable void Save(CSaveDst&) const override { }; bool Load(CLoadSrc&) override { return false; } // IPrintable void Print() const override { } }; struct CBaz : IBaz { // IPrintable void Print() const override { } }; // Test.cpp void saveIt(ISerializable&); void test(IFreqUsedBar& fr, IFreqUsedBaz& fz, IBar& r, IBaz& z) { CFreqUsedBar bar; // если закомментировать строчку ***, то не соберётся saveIt(fr); // saveIt(fz); // не соберётся, так как IFreqUsedBaz не умеет ISerializable saveIt(r); // saveIt(z); // не соберётся, так как IBaz не умеет ISerializable } Да, обрати внимание, что как-то меняется только тот код, который нуждается в оптимизации. И твой код, который в оптимизации не нуждается, и все реализации (это FreqUsed.inc, UsualUsed.h, UsualUsed.inc Test.cpp) переехал из версии "было" БЕЗ ПРАВОК Ну и левых связностей не возникло. Все наследования из IGentlemansSet приватные, явно он нигде не фигурирует и т. д Думаю, что на той же идее специальной тестовой сборки без оптимизации, но с проверками, можно и более шаблонное решение сделать, что бы вместо struct IFreqUsedBar : GENTLEMANS_SET_OPTIMIZATION_BASE(IPrintable, ISerializable) { GENTLEMANS_SET_OPTIMIZATION_ENABLE(ISerializable); GENTLEMANS_SET_OPTIMIZATION_ENABLE(IPrintable); }; можно было писать что-то вроде struct IFreqUsedBar : IGentlemansSet::TBase<IPrintable, ISerializable> { }; Ща подумаю...