成员模板静态函数的类型特征 我在C++中有类型特征的问题。我习惯于进行SFINAE检查以确保函数是否存在。但是，我希望有一个特性，可以判断类是否具有特定的模板成员静态函数

这个例子将有助于解释我的问题。让我们假设

doMake

函数将函数指针作为参数，其参数作为包

struct A {
    static A construct(int mA, double mB) {
        return A{mA, mB};
    }

    int a;
    double b;
};

struct B {
    // silly but some of my code need this
    template<typename T>
    static B construct(int mA, T mB) {
        return B{mA, mB};
    }

    int a;
    double b;
};

struct Container {
    // function (1)
    template<typename T, typename... Args,
        typename std::enable_if<has_template_construct<T>::value, int>::type = 0>
    T make(Args&&... args) {
        return doMake(&T::construct<Args...>, std::forward<Args>(args)...);
    }

    // function (2)
    template<typename T, typename... Args,
        typename std::enable_if<has_construct<T>::value, int>::type = 0>
    T make(Args&&... args) {
        return doMake(&T::construct, std::forward<Args>(args)...);
    }

    // function (3)
    template<typename T, typename... Args,
        typename std::enable_if<!has_construct<T>::value, int>::type = 0>
    T make(Args&&... args) {
        return T{std::forward<Args>(args)...};
    }
};

// ...

int main() {
    Container c;
    auto a = c.make<A>(1, 5.7); // would call (2)
    auto b = c.make<B>(2, 5.8); // would call (1)
    auto d = C.make<float>(4.f); // obviously call the last
    return 0;
}

结构A{ 静态构造（整数mA，双mB）{ 返回一个{mA，mB}； } INTA； 双b； }; 结构B{ //很傻，但是我的一些代码需要这个 模板 静态B构造（int-mA，T-mB）{ 返回B{mA，mB}； } INTA； 双b； }; 结构容器{ //职能（1） 模板 T make（Args&&…Args）{ 返回doMake（&T:：construct，std:：forward（args）…）； } //职能（2） 模板 T make（Args&&…Args）{ 返回doMake（&T:：construct，std:：forward（args）…）； } //职能（3） 模板：：类型=0> T make（Args&&…Args）{ 返回T{std:：forward（args）…}； } }; // ... int main（）{ 容器c； 自动a=c.make（1，5.7）；//将调用（2） 自动b=c.make（2，5.8）；//将调用（1） auto d=C.make（4.f）；//显然调用最后一个 返回0； } 我知道如何实现

has\u构造

，但我对如何实现

has\u模板

非常迷茫。有人能给我一些提示吗？ 谢谢

通过实验，您可以：

template<class T>
using construct_t = decltype(&T::construct);

template<class T, typename...Ts>
using template_construct_t = decltype(&T::template construct<Ts...>);

template <typename T>
using has_construct = is_detected<construct_t, T>;

template <typename T, typename...Ts>
using has_template_construct = is_detected<template_construct_t, T, Ts...>;

模板
使用construct=decltype（&t:：construct）；
模板
使用template\u construct\u t=decltype（&t:：template construct）；
模板
检测到使用has_construct=is_；
模板
检测到使用has_template_construct=is_；

---

请注意，在函数1中，您必须使用

has_template_construct:：value

（

，Args…

已添加）。

为什么不使用表达式SFINAE，如

decltype（&T:：template construct）

？