Форум программистов [Powered by Invision Power Board]

Код

#include <iostream>

namespace detail {

template<typename Type>
struct has_member {
private:
   class yes { char m; };
   class no { yes m[2]; };

   struct BaseMixin {
      void func(){}
   };

   struct Base: Type, BaseMixin {};

   template<typename T, T t>
   class Helper {};

   template<typename U>
   static no deduce(U*, Helper<void (BaseMixin::*)(), &U::func>* = 0);
   static yes deduce(...);

public:
   enum { value = sizeof(yes) == sizeof(deduce((Base*)(0))) };
};

template <typename>
struct void_exp_result
{};

//Перегрузка оператора запятая 'operator,'
template <typename T, typename U>
U const& operator,(U const&, void_exp_result<T>);

template <typename T, typename U>
U& operator,(U&, void_exp_result<T>);

template <typename T1, typename T2>
struct clone_constness {
   typedef T2 type;
};

template <typename T1, typename T2>
struct clone_constness<const T1, T2> {
   typedef const T2 type;
};

} // namespace detail

template<typename Object, typename Sig>
struct has_member {
private:
   class yes {};
   class no { yes m[2]; };

   //добавляем перегруженный метод
   struct derived: public Object {
      using Object::func;
      no func(...) const; 
   };

   //Учтем возможную константность типа класса
   typedef typename detail::clone_constness<Object, derived>::type derived_type;

   //Проверка результата выражения
   template <typename T, typename due_type>
   struct return_value_check {
      static yes deduce(due_type);
      static no deduce(...);
      //явные перегрузки в случае, если
      //due_type имеет шаблонный конструктор
      static no deduce(no);                              
      static no deduce(detail::void_exp_result<Object>);
   };

   //Проверка результата выражения в случае,
   //если не интересует возвращаемый тип метода
   template <typename T>
   struct return_value_check<T, void> {
      static yes deduce(...);
      static no deduce(no);
   };

   template <bool has, typename F>
   struct impl {
      enum { value = false };
   };

   template <typename Arg1, typename r>
   struct impl<true, r(Arg1)> {
      enum { value = sizeof(
            return_value_check<Object, r>::deduce(
               (((derived_type*)0)->func(
                  *(Arg1*)0
               ), detail::void_exp_result<Object>())
            )
         ) == sizeof(yes)
      };
   };
   template <typename Arg1, typename Arg2, typename r>
   struct impl<true, r(Arg1, Arg2)> {
      enum { value = sizeof(
            return_value_check<Object, r>::deduce(
               (((derived_type*)0)->func(
                  *(Arg1*)0,
                  *(Arg2*)0
               ), detail::void_exp_result<Object>())
            )
         ) == sizeof(yes)
      };
   };

public:
   //сначала проверяем наличие метода с помощью has_member
   enum { value = impl<detail::has_member<Object>::value, Sig>::value };
};

/***************************************************************************/

struct With {
   void func(int) const {}
};

struct WithTemplate {
   template <typename T>
   void func(T){}
};

struct Without {};

int main() {
   std::cout << has_member<With, void(int)>::value << std::endl;
   std::cout << has_member<WithTemplate, void(int)>::value << std::endl;
   std::cout << has_member<Without, void(int)>::value << std::endl;
    
   return 0;
}