#include <iostream>

#include <boost/core/enable_if.hpp>


template <typename T>
struct HasDeleteOperator
{
  template <typename U, void (*)(void*, std::size_t)> struct SFINAE2 {};
  template <typename U, void (*)(void*)> struct SFINAE1 {};
  template <typename U> static char Test(SFINAE1<U, &U::operator delete>*);
  template <typename U> static char Test(SFINAE2<U, &U::operator delete>*);
  template <typename U> static int Test(...);
  static const bool value = sizeof(Test<T>(0)) == sizeof(char);
};


template <typename T, class Enable = void>
struct deleter {
  static void invoke(T *t) {
    std::cout << "Calling default operator delete" << std::endl;
    (operator delete)(t);
  }
};


template <typename T>
struct deleter<T, typename boost::enable_if< HasDeleteOperator<T> >::type> {
  template<void D(void *, std::size_t)>
  static void use_delete_operator(void * t, std::size_t s){
    std::cout << "Calling class-specific operator delete with two arguments" << std::endl;
    D(t, s);
  }

  template<void D(void *)>
  static void use_delete_operator(void * t, std::size_t s){
    std::cout << "Calling class-specific operator delete with one argument" << std::endl;
    D(t);
  }

  static void invoke(T *t) {
    use_delete_operator<T::operator delete>(t, sizeof(T));
  }
};


struct A {
  void operator delete(void *, std::size_t) {}
};


struct B {
  void operator delete(void *) {}
};


struct C {

};


int main()
{
  A *a = new A;
  deleter<A>::invoke(a);

  B *b = new B;
  deleter<B>::invoke(b);

  C *c = new C;
  deleter<C>::invoke(c);
}