class INotifiable {
public:
   virtual void notify() =0;
};

class ISerializable {
public:
   virtual void serialize() =0;
};

shared_ptr<INotifiable> obj = ...;

if ( obj поддерживает еще и интерфейс ISerializable ) {
   сохранить obj в файл
}

	Скрытый текст

МР>if ( obj поддерживает еще и интерфейс ISerializable ) {
МР>   сохранить obj в файл
МР>}
МР>

if (typeof(ISerializable).IsAssignableFrom(typeof(obj))) {
   сохранить obj в файл
}

template <class T, class I> struct is_iface_supported : std::false_type
{
};

class A
{
};

class B
{
};

class C : public A
{
};
template <> struct is_iface_supported <C, A> : std::true_type
{
};

class D : public B
{

};
template <> struct is_iface_supported <D, B> : std::true_type
{
};

class E : public A, public B
{

};
template <> struct is_iface_supported <E, A> : std::true_type
{
};
template <> struct is_iface_supported <E, B> : std::true_type
{
};


int main()
{

    A a;
    B b;
    C c;
    D d;
    E e;

    if (is_iface_supported<decltype(c), A>::value) puts("c is support interface A");
    if (is_iface_supported<decltype(c), B>::value) puts("c is support interface B");
    if (is_iface_supported<decltype(d), A>::value) puts("d is support interface A");
    if (is_iface_supported<decltype(d), B>::value) puts("d is support interface B");
    if (is_iface_supported<decltype(e), A>::value) puts("e is support interface A");
    if (is_iface_supported<decltype(e), B>::value) puts("e is support interface B");

return 0;
}

МР>class INotifiable {
МР>public:
МР>   virtual void notify() =0;
МР>};

МР>class ISerializable {
МР>public:
МР>   virtual void serialize() =0;
МР>};

МР>shared_ptr<INotifiable> obj = ...;

МР>if ( obj поддерживает еще и интерфейс ISerializable ) {
МР>   сохранить obj в файл
МР>}
МР>

if(std::is_convertible<std::decay_t<decltype(obj)>*, ISerializable*>::value) { // std::is_base_of<ISerializable, std::decay_t<decltype(obj)>>::value для прямого наследования
   сохранить obj в файл
}

В С++17 можно использовать if constexpr(...), но оптимизатор и так сработает.

class A
{
};

class B
{
};

class C : public A
{
};

class D : public A, public B
{
};

int main()
{
    if (std::is_convertible<C*, A*>::value) puts("C convertible to A"); // true
    if (std::is_convertible<C*, B*>::value) puts("C convertible to B"); // false
    if (std::is_convertible<D*, A*>::value) puts("D convertible to A"); // true
    if (std::is_convertible<D*, B*>::value) puts("D convertible to B"); // true
    return 0;
}

class SomeClass : public ConcreteClass, // класс
                  public Interface1,    // интерфейс
                  public Interface2,    // интерфейс
                  ...
                  public InterfaceN     // интерфейс
{
//...
};

// Так можно? Этот вариант чем-нибудь отличается от первого варианта?
class SomeClass : public Interface1,    // интерфейс
                  public ConcreteClass, // класс
                  public Interface2,    // интерфейс
                  ...
                  public InterfaceN     // интерфейс
{
//...
};

МР>class INotifiable {
МР>public:
МР>   virtual void notify() =0;
МР>};

МР>class ISerializable {
МР>public:
МР>   virtual void serialize() =0;
МР>};

МР>shared_ptr<INotifiable> obj = ...;

МР>if ( obj поддерживает еще и интерфейс ISerializable ) {
МР>   сохранить obj в файл
МР>}
МР>

 shared_ptr<ISerializable> objSer = std::dynamic_pointer_cast<ISerializable>(obj);

class SomeClass : public Interface1,    // интерфейс
                  public Interface2,    // интерфейс
                  ...
                  public InterfaceN     // интерфейс
{
public:
   ~SomeClass();
//...
};

std::unique_ptr<Interface2> obj(new SomeClass()); // удаляться будет через интерфейс Interface2

class A : public B, public C {};

class Interface1 {
public:
   virtual ~Interface1() {}         // vtbl[0]
   virtual void doSomething() = 0;  // vtbl[1] Такой же как и в Interface2, но на первой позиции в vtbl
   virtual void doSomething1() = 0; // vtbl[2]
   
};

class Interface2 {
public:
   virtual ~Interface2() {}          // vtbl[0]
   virtual void doSomething2() = 0;  // vtbl[1]
   virtual void doSomething() = 0;   // vtbl[2] Такой же как и в Interface1, но на второй позиции в vtbl
};

class SomeClass : public Interface1,
                  public Interface2
{
public:
   ~SomeClass();                      // vtbl[0]
   void doSomething1() override;      // vtbl[1]
   void doSomething2() override;      // vtbl[2]
   void doSomething() override;       // vtbl[3]
   //...
};

std::unique_ptr<Interface1> obj1(new SomeClass());
std::unique_ptr<Interface2> obj2(new SomeClass());

obj1->doSomething();
obj2->doSomething();

class Interface1 {
public:
    virtual ~Interface1() {}         // vtbl[0]
    virtual void doSomething() = 0;  // vtbl[1] Такой же как и в Interface2, но на первой позиции в vtbl
    virtual void doSomething1() = 0; // vtbl[2]

};

class Interface1Cool : public Interface1
{
    virtual void doSomethingCool() = 0; 
    virtual void doSomething2() = 0;
};

class SomeClass : public Interface1Cool
{
public:
    ~SomeClass() {};                   
    void doSomething1() override;      
    void doSomething2() override;      
    void doSomething() override;  
    void doSomethingCool() override;     
                   //...
};

class Interface1 {
public:
   virtual ~Interface1() {}         // vtbl[0]
   virtual void doSomething() = 0;  // vtbl[1] 
   virtual void doSomething1() = 0; // vtbl[2] = void doSomething1()
   
};

class SomeClass : public Interface1,
                  public Interface2
{
public:
   ~SomeClass();                      // vtbl[0]
   void doSomething1() override;      // vtbl[1] = void doSomething1()
   void doSomething2() override;      // vtbl[2]
   void doSomething() override;       // vtbl[3]
   //...
};

std::unique_ptr<Interface1> obj1(new SomeClass());
obj1->doSomething1(); // как компилятор определяет где в vtbl находится метод doSomething1()?

// метод doSomething1() в Interface1 - это vtbl[2]
// но в классе SomeClass метод doSomething1() - это уже vtbl[1]

call vtbl[2]; // такой?
call vtbl[1]; // или такой?

//первая часть - собственная
vtbl[0] -> SomeClass::~SomeClass
vtbl[1] -> void SomeClass::doSomething1()
vtbl[2] -> void SomeClass::doSomething2()
vtbl[3] -> void SomeClass::doSomething()

//вторая часть - для базы Interface1
vtbl[4] -> SomeClass::~SomeClass
vtbl[5] -> void SomeClass::doSomething()
vtbl[6] -> void SomeClass::doSomething1()

//еще часть - для базы Interface2
vtbl[7] -> SomeClass::~SomeClass
vtbl[8] -> void SomeClass::doSomething2()

SomeClass *p = ...
p->doSomething1(); //SomeClass::vtbl[1]

Interface1 *p1 = p; //Interface1::vtbl = SomeClass::vtbl+4, "вторая часть"
p1->doSomething1(); //Interface1::vtbl[2] == SomeClass::vtbl[6]