Предположим, у нас есть бизнес кейз такой-то. Мы реализуем его вот так-то и так-то.
Теперь у нас изменился набор требований. Мы меняем вот этот класс вот так-то.
А вот теперь мы вынуждены сделать то-то и то-то, а это тяжелый ручной труд. Я предлагаю сделать так, чтобы работало то-то и то-то. Тогда в случаях, подобных описанному, произойдет то-то и то-то, и все станет работать само.

struct INode 
{
    int get(const char *key);
    void set(int value, const char *key);
};

class NodeWrapper : public INode
{
    private:
        const Node &wrapped;
    public: 
        // type conversion operator
        NodeWrapper(Node &toWrap) : wrapped(toWrap){};
    public: 
      // INode implementation
      int get( const char *key )
        {
          int value;
            wrapped.get(value, key);
            return value;
        }
        void set(int value, const char *key)
        {
          wrapped.set(value, key);
        }
}

...
void acceptMyNode(Node &n)
    {
        doNodeWork(n);
    }

    void acceptThirdPartyNode( ThirdPartyNode &n )
    {
        doNodeWork(n);
    }

    void doNodeWork(INode node )
    {
        int x = node.get("FooBar");
    }

class ThirdPartyNodeWrapper : public ThirdPartyNode, public INode
{
  public ThirdPartyNodeWrapper(&ThirdPartyNode node): ThirdPartyNode(node){};
}

S>struct INode 
S>{
S>    int get(const char *key);
S>    void set(int value, const char *key);
S>};

S>class NodeWrapper : public INode
S>{
// дальше поскипано.
S>

// вспомогательные классцы
struct ErrInfo {
    // поскипан
};

struct Error {
    Error( ErrInfo& ) {}
};

// class MyNode - его будем враппить
struct MyNode {
    int get( const char *key ) { return (int)key; }
};

// ВФ-Тейбл
struct INodeVFT {
    bool    (*int_get)(void*, const char*, int*, ErrInfo*);
    bool    (*int_set)(void*, const char *, int, ErrInfo*);
};

// W-интерфейс
struct INode {
    void              *xp;
    const INodeVFT    *vt;

public:
// хелперы:
    int int_get( const char *key )
    {
        ErrInfo e; int i;
        if ( (*vt->int_get)(xp, key, &i, &e) )
            return i;
        throw Error(e);
    }

    void int_set( const char *key, int value )
    {
        ErrInfo e;
        if ( (*vt->int_set)(xp, key, value, &e) )
            return;
        throw Error(e);
    }
};

// INode wrapper base
template <class This, class T>
struct WNodeImp {
    static const INodeVFT    vt;

// методы по дефлоту:
    static bool    int_get(void*, const char*, int*, ErrInfo*) { return false; }
    static bool    int_set(void*, const char *, int, ErrInfo*) { return false; }

    friend void wrap( T *node, INode &inode )
    {
        inode.xp = node;
        inode.vt = &vt;
    }
};

template <class This, class T>
const INodeVFT WNodeImp<This,T>::vt =
{
    This::int_get,
    This::int_set
};

// INode wrapper for MyNode
struct WMyNode : WNodeImp<WMyNode,MyNode>
{
    static bool int_get( void *x, const char *k, int *rv, ErrInfo* )
    {
        MyNode *n = (MyNode*)x;
        *rv = n->get(k);
        return true;
    }
};

// testing
void work_do( INode node )
{
    int x = node.int_get("ZZz");
    try {
        node.int_set("dgdf", 10); // not implemented
    } catch( Error& )
    {
    }
}

void learn()
{
    MyNode    node;
    INode        inode;
    wrap( &node, inode );

    work_do( inode );

    return;
}

S>class ThirdPartyNodeWrapper : public ThirdPartyNode, public INode
S>{
S>  public ThirdPartyNodeWrapper(&ThirdPartyNode node): ThirdPartyNode(node){};
S>}
S>

UNIT M1;

  TYPE
    IDocument = INTERFACE
      PROCEDURE OpenDocument();
      PROCEDURE CheckDocument();
      PROCEDURE CloseDocument();
    END;

    IDocuments = INTERFACE
      PROCEDURE IncludeDocument(doc: IDocument);
      PROCEDURE ExcludeDocument(doc: IDocument);
      PROCEDURE CheckDocuments();
    END;

  FUNCTION NewDocuments(): IDocuments;

END.

UNIT M2;

  TYPE
    ISuperDocument = INTERFACE
      PROCEDURE OpenDocument();
      PROCEDURE CheckDocument();
      PROCEDURE CloseDocument();
      PROCEDURE GetWriter(OUT Writer: IWriter);
      PROCEDURE GetReader(OUT Reader: IReader);
    END;

  FUNCTION NewSuperDocument(): ISuperDocument;

END.

M2.ISuperDocument >= M1.IDocument;

СГ>UNIT M1;
СГ>UNIT M2;
СГ>

// что-то типа
interface IFoo {
   int  foo();
   void bar();
};

class Some {
   int  dummy();
   void mummy();
};

wrapper Some : IFoo {
   foo = dummy;
   bar = mummy;
};

void test( Some &s )
{
   IFoo &foo = s; // компилер заюзает то что написано во wrapper Some
   foo.foo();
}

K>// что-то типа
K>interface IFoo {
K>   int  foo();
K>   void bar();
K>};

K>class Some {
K>   int  dummy();
K>   void mummy();
K>};

K>wrapper Some : IFoo {
K>   foo = dummy;
K>   bar = mummy;
K>};

K>void test( Some &s )
K>{
K>   IFoo &foo = s; // компилер заюзает то что написано во wrapper Some
K>   foo.foo();
K>}

K>

Node.get(a, b) <-> a=INode.get(b)

S>Node.get(a, b) <-> a=INode.get(b)
S>

S>

TVINSERTSTRUCT args;
args.hParent = ...;
args.hInsertAfter = ...;
args.item.mask = TVIF_IMAGE | TVIF_PARAM ...;
// еще куча всякой инициализации
TreeView_InsertItem(hwnd,&args);

// сигнатура в интерфейсе:
ITreeItem ITree::insert( string name, ITreeItem parent, ITreeItem after );

// сгенеренная враппер функция:
bool MyTreeWrp::insert( MyTree &This, ITreeItem *retval, string name, ITreeItem parent, ITreeItem after, ErrorInfo *e )
{
}