fork download
  1. template<typename A1>
  2. struct AbstractBinder
  3. {
  4. virtual void call(A1 a1)=0;
  5. virtual AbstractBinder<A1> *clone()=0;
  6. virtual ~AbstractBinder(){}
  7. };
  8.  
  9. template<typename A1, typename I, typename M>
  10. struct Binder : AbstractBinder<A1>
  11. {
  12. Binder(I i, M m) : i_(i), m_(m) { }
  13. void call(A1 a1)
  14. {
  15. (i_->*m_)(a1);
  16. }
  17. virtual AbstractBinder<A1> *clone()
  18. {
  19. return new Binder(*this);
  20. }
  21. I i_;
  22. M m_;
  23. };
  24.  
  25. template<typename A1>
  26. class BinderHolder
  27. {
  28. AbstractBinder<A1> *ptr;
  29. BinderHolder &operator=(const BinderHolder&);
  30. public:
  31. template<typename I, typename M>
  32. BinderHolder(I i, M m)
  33. : ptr(new Binder<A1,I,M>(i,m))
  34. {
  35. }
  36. BinderHolder(const BinderHolder &rhs)
  37. : ptr(rhs.ptr->clone())
  38. {
  39. }
  40. ~BinderHolder()
  41. {
  42. delete ptr;
  43. }
  44. void operator()(A1 a1)
  45. {
  46. ptr->call(a1);
  47. }
  48. };
  49.  
  50. template<typename A1, typename I, typename M>
  51. BinderHolder<A1> my_bind(I i, M m) {
  52. return BinderHolder<A1>(i, m);
  53. }
  54.  
  55. #include <iostream>
  56.  
  57. struct Foo {
  58. void x(int i) { std::cout << "Foo " << i << std::endl; }
  59. };
  60.  
  61. struct Bar {
  62. void y(int i) { std::cout << "Bar " << i << std::endl; }
  63. };
  64.  
  65. int main()
  66. {
  67. Foo foo;
  68. Bar bar;
  69.  
  70. BinderHolder<int> b1 = my_bind<int>(&foo, &Foo::x);
  71. BinderHolder<int> b2 = my_bind<int>(&bar, &Bar::y);
  72.  
  73. b1(1);
  74. b2(2);
  75. }
  76.  
Success #stdin #stdout 0.01s 2816KB
stdin
Standard input is empty
stdout
Foo 1
Bar 2