Let's say I want to emulate the behaviour of a duck-typed interface FuBar which looks like the following psuedo-code:

  interface FuBar {
    int Fu();
    int Bar(int x);
  }

  struct FuBarTable {
    int(*Fu)(void* pseudo_this);
    int(*Bar)(void* pseudo_this, int x);
  };

  template<typename T>
  struct StaticFuBarAdapter {
    static int Fu(void* pseudo_this) { return reinterpret_cast<T*>(pseudo_this)->Fu(); }
    static int Bar(void* pseudo_this, int x) { return reinterpret_cast<T*>(pseudo_this)->Bar(x); }
};

  template<typename T>
  FuBarTable* GetFuBarTable() {
    typedef StaticFuBarAdapter<T> U;
    static FuBarTable table = { U::Fu, U::Bar };
    return &table;
  };

  struct FuBar {
    template<typename T>
    FuBar(T& x) {
      object = &x;
      table = GetFuBarTable<T>();
    }
    int Fu() {
      return table->Fu(object);
    }
    int Bar(int x) {
      return table->Bar(object, x);
    }
  private:
    void* object;
    FuBarTable* table;
  }

  struct MyFuBar {
    int Fu() { return 1; }
    int Bar(int x) { return Fu() + x; }
  };

  struct YourFuBar {
    int Fu() { return 2; }
    int Bar(int x) { return Fu() + x; }
  };

  void DoFuAndBar(FuBar fb) {
    cout << fb.Bar(fb.Fu()) << endl;
  }

  int main() {
    MyFuBar fb1;
    DoFuAndBar(fb1);
    YourFuBar fb2;
    DoFuAndBar(fb2);
  }

  FuBar(T& x) : object(&x), table(GetFuBarTable<T>()) { }