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

Question

假设我有这样的模板函数

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

现在我用作该函数参数的每个类都有函数 X()， 但并非我用作参数的每个类都具有函数 Y()。 但是，如果函数 a.X() 返回 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

这是另一个受this answer 启发的版本，它更短一些（在我的看来更好：)。

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;
    }
};

Here 是现场演示。