#include <iostream>
#include <typeinfo>

// a generic abstract interface; the specific interface operations depends on the specific interface
struct interface { virtual ~interface() = 0 ; } ; inline interface::~interface() = default ;

// a specific abstract interface; it declares a specific interface operation
struct some_interface : interface { virtual void do_something() const = 0 ; } ;

template < typename T > void try_do_something( T& object ) // do_something if the object supports some_interface
{
    if( auto itf = object.get_interface( typeid(some_interface) ) )
        if( auto some_itf = dynamic_cast< const some_interface* >(itf) ) return some_itf->do_something() ;

    std::cout << "this object does not currently support some_interface\n" ;
}

int main()
{
    struct A : private some_interface // expose some_interface if a a run-time condition is satisfied
    {
        // conditionally support some_interface
        const interface* get_interface( const std::type_info& tinfo ) const
        { return tinfo == typeid(some_interface) && can_do_something ? this : nullptr ; }

        virtual void do_something() const override { std::cout << "A::some_interface::do_something()\n" << '\n' ;}

        bool can_do_something = true ;
    };

    struct B // implement some_interface via delegation to an  external object
    {
        explicit B( const A& a ) : a(a) {}

        const interface* get_interface( const std::type_info& tinfo ) const { return a.get_interface(tinfo) ; }

        const A& a ;
    };

    A a ;
    B b(a) ;

    try_do_something(b) ;

    a.can_do_something = false ; // don't want to support some_interface now
    try_do_something(b) ;
}