Вот вам еще жирчику!

[Infinite-Void]

Итак, продолжение предыдущего поста.

Собственно, сам адаптер

template <class inner_iface, class outer_class>
class Adapter : public inner_iface {
  private:
    typedef Adapter<inner_iface, outer_class> This_Adapter;
    struct list {
      void ** const ptr;
      list * const next;
      
      list(list * & list_head, void **elem) : ptr(elem), next(list_head) { list_head = this; }
      ~list() { *ptr = 0; }
      
      static void clear_list(list * &list_head) {
        while (list * cur = list_head) {
          list_head = cur->next;
          delete cur;
        }
        list_head = 0;
      }
    };
  
  protected:
    
    class Adaptive : public outer_class {
      friend class Adapter<inner_iface, outer_class>;
      private:
        bool adapter_killed;
        list * adaptive_list_head;
        
      protected:
        Adapter * const _adapter;
        
      public:
        Adaptive (Adapter * const ptr) : _adapter(ptr), adapter_killed(false), adaptive_list_head(0) { }
        virtual ~Adaptive () {
          if (!adapter_killed) {
            _adapter->adaptive_killed = true;
            delete _adapter;
          }
          list::clear_list(adaptive_list_head);
        }
        
        // framework interface implementations and delegations
    };
    
    Adapter(Adaptive * adaptive) : _adaptive(adaptive), adaptive_killed(false), adapter_list_head(0) { }
    
  private:
    friend class Adaptive;
    
    list * adapter_list_head;
    
    Adaptive * _adaptive;
    bool adaptive_killed;
    
    outer_class * const get_adaptive() const {
      return (outer_class * const) _adaptive;
    }
    
    Adapter * & operator & ();
  
  public:
    
    virtual ~Adapter() {
      if (!adaptive_killed) {
        _adaptive->adapter_killed = true;
        delete _adaptive;
      }
      list::clear_list(adapter_list_head);
    }
    
    void get_registered_adaptive(void** pointer) {
      *pointer = (void *)get_adaptive();
      new list(_adaptive->adaptive_list_head, pointer);
    }
    
    void get_registered_adapter(void** pointer) {
      *pointer = (void*)this;
      new list(adapter_list_head, pointer);
    }
    
    // framework realizations
};

Пример использования

struct Interface_framework {
  virtual void framework_foo() = 0;
  virtual ~Interface_framework () { }
};

struct Interface_inner {
  virtual void inner_foo() = 0;
  virtual ~Interface_inner () { }
};

#include "adapter.h"

using namespace std;

// class from framework
class Framework_class : public Interface_framework {
  public:
    void framework_id() { cout << "Framework_class" << endl; }
};

// adapter framework -> local
class Concrete_adapter : public Adapter<Interface_inner, Framework_class> {
  
  private:
    typedef Adapter<Interface_inner, Framework_class> Parent_adapter;
    
    class Adaptive : public Parent_adapter::Adaptive
    {
      public:
        void framework_foo() { _adapter->inner_foo(); }  // delegate
        Adaptive(Concrete_adapter * const ptr) : Parent_adapter::Adaptive(ptr) { }
    };
    
  public:
    Concrete_adapter() : Parent_adapter(new Adaptive (this)) { }
    
    void inner_foo() { cout << "Adapter_class::inner_foo" << endl; }
};

// -------------------------------------------------------------------------------------------------------

// int main (int argc, char *argv[])
  // inner code
  Concrete_adapter * obj_ptr = new Concrete_adapter;
  obj_ptr->inner_foo();
  
  // framework code
  Interface_framework * ptr;
  obj_ptr->get_registered_adaptive((void**)&ptr);
  ptr->framework_foo();
  ((Framework_class *) ptr)->framework_id();
  
  Concrete_adapter * adapter_ptr_test;
  obj_ptr->get_registered_adapter((void**)&adapter_ptr_test);
  
  // адаптер удаляется вместе с внутренним классом
  // adapter_ptr_test = 0; 
  delete ptr;

Я опубликовал, а вы раскуривайте.