缺少类型的模板函数（在运行时未使用）函数

Question

说我有这样的模板功能

template <typename T> bool func(T a)
{
  if(a.X())
    return a.Y();
  return false;
}

现在我用作此函数的参数的每个类都有函数X（），但不是我用作参数的每个类都有函数Y（）。 但是，如果函数aX（）返回true，那么我保证给定的类具有函数Y（）。 我可以以某种方式编译此代码，因为我知道函数Y（）哪个编译器抱怨某些类型的缺失永远不会被调用？ 这个功能实际上非常大，使用的类型很多，所以制作一些专业是不切实际的。

Answer 1

SFINAE可能有所帮助，例如：（ https://ideone.com/XmjQY8 ）

#include <type_traits>
#include <cstdint>

#define DEFINE_HAS_SIGNATURE(traitsName, funcName, signature)               \
    template <typename U>                                                   \
    class traitsName                                                        \
    {                                                                       \
    private:                                                                \
        template<typename T, T> struct helper;                              \
        template<typename T>                                                \
        static std::uint8_t check(helper<signature, &funcName>*);           \
        template<typename T> static std::uint16_t check(...);               \
    public:                                                                 \
        static                                                              \
        constexpr bool value = sizeof(check<U>(0)) == sizeof(std::uint8_t); \
    }

DEFINE_HAS_SIGNATURE(has_X, T::X, bool (T::*)());
DEFINE_HAS_SIGNATURE(has_Y, T::Y, bool (T::*)());

template <typename T>
typename std::enable_if<has_X<T>::value && has_Y<T>::value, bool>::type
func(T a)
{
  if(a.X())
    return a.Y();
  return false;
}

template <typename T>
typename std::enable_if<!has_X<T>::value || !has_Y<T>::value, bool>::type
func(T /*a*/)
{
    return false;
}

Answer 2

这是另一个灵感来自这个答案的版本，它有点短（在我看来更好:)）。

struct Action
{
    template <typename T>
    static bool func_real(T a){return func(a, special_());}

private:

    struct general_ {};
    struct special_ : general_ {};
    template<typename> struct bool_ { typedef bool type; };

    template<typename S, typename bool_<decltype(std::declval<S>().Y())>::type = 0>
    static bool func(S a, special_) {
        cout<<"Y() exists"<<endl;
        if(a.X()){
            return a.Y();
        }
        return false;
    }

    template<typename S>
    static bool func(S a, general_) {
        cout<<"Y() does not exist"<<endl;
        return false;
    }
};

这是一个现场演示。