struct A {
  //const char * AaBbCcDd(int i) { return "aa"; }
  void AaBbCcDd() {}
};
struct B {};



template <typename T, typename = void>
struct  HasMethod : public std::false_type {};
template <typename T >
struct HasMethod < T, std::void_t< decltype(&T::AaBbCcDd) > > : public std::true_type {};


int main() {
    printf("\n%u %u %u", HasMethod<A>::value, HasMethod<B>::value, HasMethod<int>::value );
    return 0;    
}

#include <iostream>
#include <tuple>
#include <type_traits>
#include <utility>

#include <iostream>
#include <cstdio>


struct A {
  void AaBbCcDd() {}
};

struct B {
  const char * SomeFun(int i) { return "aa"; }
  };

/// @brief создаёт структурку ClassName с помощью которого можно определить наличие метода FunName в заданном классе (класс задаётся как параметр шаблона)
/// @details учитывает полностью аргументы функции
///          пример: 
///           HAS_METHOD_DEFINTION( HasPrintMethod, Print )
///           struct S { void Print( int, char, long) {} };
///           struct B { void NotPrint() {} };
///           void main () {
///             bool exist;
///             exist = HasPrintMethod<S, int, char, long>::value; // exist = 1
///             exist = HasPrintMethod<S, int, char>::value;       // exist = 0
///             exist = HasPrintMethod<B, int, char, long>::value; // exist = 0
///           }
/// @author rg45 aka Сергей Романченко в оформлении Molchalnik
/// @warning не работает, если в методе есть 2 перегрузки метода, наличие которого мы проверяем
#define HAS_METHOD_DEFINITION( ClassName, FunName )  \
    namespace curicios_hasmethod_namespace_ck9fs98 { \
    template <typename, typename = void>             \
    struct ClassName##_Helper : std::false_type {}; \
                                                     \
    template <typename Obj, typename...Args>             \
    struct ClassName##_Helper<std::tuple<Obj, Args...>, \
        std::void_t<decltype(std::declval<Obj>().FunName(std::declval<Args>()...))>> : std::true_type {}; \
    }  \
    template <typename Obj, typename...Args> using ClassName = curicios_hasmethod_namespace_ck9fs98::ClassName##_Helper<std::tuple<Obj, Args...> >; \
    
        

HAS_METHOD_DEFINITION( HasMethod, AaBbCcDd )
HAS_METHOD_DEFINITION( HasMethod2, SomeFun )


int main() {
    printf("\n%u %u %u", HasMethod <A>::value, HasMethod <B>::value, HasMethod <int>::value );
    printf("\n%u %u %u", HasMethod2<A, int>::value, HasMethod2<B, int>::value, HasMethod2<int, int>::value );
    return 0;    
}

#include <iostream>
#include <string>
#include <vector>
#include <cstdio>


struct A {
  //const char * AaBbCcDd(int i) { return "aa"; }
  void AaBbCcDd() {}
};

struct B {};


template <typename T> struct HasMethod {
 private:
  struct HasMethodHelperFalse {
    static constexpr const bool value = 0;
  };

  template <class T2, decltype(&T2::AaBbCcDd) U = &T2::AaBbCcDd > struct HasMethodHelperTrue {
    static constexpr const bool value = 1;
  };

  HasMethodHelperFalse static constexpr detect(...) { return HasMethodHelperFalse(); }

  template <typename T2> HasMethodHelperTrue<T2> static constexpr detect( T2 * ) { return HasMethodHelperTrue<T2>();  }

 public:
  static constexpr const bool value = decltype(     detect(   static_cast<T*>( nullptr )   )     ):: value;
};


int main() {
    printf("\n%u %u %u", HasMethod<A>::value, HasMethod<B>::value, HasMethod<int>::value );
    return 0;    
}

#include <iostream>
#include <string>
#include <vector>
#include <cstdio>


struct A {
  const char * SomeFun(int i) { return "aa"; }
  void AaBbCcDd() {}
};

struct B {};

/// @brief создаёт структурку ClassName с помощью которого можно определить наличие метода FunName в заданном классе (класс задаётся как параметр шаблона)
/// @details пример: 
///           HAS_METHOD_DEFINTION( HasPrintMethod, Print )
///           struct S { void Print() {} };
///           void main () {
///             bool exist = HasPrintMethod<S>::value;
///           }
/// @warning не работает, если в методе есть 2 перегрузки метода, наличие которого мы проверяем
#define HAS_METHOD_DEFINITION( ClassName, FunName ) \
template <typename T> struct ClassName { \
 private: \
  struct HasMethodHelperFalse { \
    static constexpr const bool value = 0; \
  };\
\
  template <class T2, decltype(&T2::FunName) U = &T2:: FunName > struct HasMethodHelperTrue { \
    static constexpr const bool value = 1; \
  }; \
\
  HasMethodHelperFalse static constexpr detect(...) { return HasMethodHelperFalse(); } \
\
  template <typename T2> HasMethodHelperTrue<T2> static constexpr detect( T2 * ) { return HasMethodHelperTrue<T2>();  } \
\
 public: \
  static constexpr const bool value = decltype(     detect(   static_cast<T*>( nullptr )   )     ):: value;\
};

HAS_METHOD_DEFINITION( HasMethod, AaBbCcDd )
HAS_METHOD_DEFINITION( HasMethod2, SomeFun )


int main() {
    printf("\n%u %u %u", HasMethod <A>::value, HasMethod <B>::value, HasMethod <int>::value );
    printf("\n%u %u %u", HasMethod2<A>::value, HasMethod2<B>::value, HasMethod2<int>::value );
    return 0;    
}

S>class Class {
S>public:
S>    void Method();
S>};

S>int main() {
S>    __if_exists(Class::Method) {
S>        print("Class::Method exists");
S>    }

S>    __if_not_exists(Class::Method1) {
S>        print("Class::Method1 not exists");
S>    }
S>}
S>