使用 std::enable_if 声明带有可变参数模板参数的括号运算符

Question

我有以下smart_ptr 类。

template <typename T>
class smart_ptr
{
public:
    // ... removed other member functions for simplicity
    T* get() { return ptr; }

    template <typename... Args>
    decltype(T::template operator ()(Args()...)) operator ()(Args... args) const
    {
        return (*get()).operator ()(args...);
    }

private:
    T* ptr;
};

但是，当我将 smart_ptr 类用于没有 operator () 的类型 T 时，它无法编译（这是正确的）。

我想要的是只有当 T 有operator () 时才使用std::enable_if 来启用成员函数。当我开始这样做时，它变得非常模糊和复杂，因为我正在考虑使用 SFINAE 来检测 T 是否有operator ()，然后将它与std::enable_if 结合起来得到我想要的。但是，我在创建 SFINAE 时迷失了方向，该 SFINAE 能够检测 一个以 operator () 为模板的可变参数（即 不是Is it possible to write a template to check for a function's existence? 的副本）。

有人可以帮忙吗？或者给出另一个（也许更简单的）解决方案？

附言它必须在 GCC 4.5.3 上工作。

编辑：为了完整起见，我已经用 GCC 4.5.3 的有效解决方案回答了我自己的问题。

Answer 1

已编辑：与原始答案完全不同，没有给出真正的解决方案。

此代码在使用 gcc 4.5.1 的 ideone 上编译。这是我能做的最好的了。

#include <array>
#include <iostream>

using namespace std;

template<typename T>
struct has_property
{
    struct UnmentionableType { UnmentionableType() {} };

    //test if type has operator() (...)
    template<typename U, typename A1, typename A2, typename A3, typename A4, typename A5>
    static auto ftest(U* t, A1 a1, A2 a2, A3 a3, A4 a4, A5 a5) -> decltype((*t)(a1, a2, a3, a4, a5), char(0));
    static std::array<char, 2> ftest(...);

public:
    static const bool value = sizeof(ftest((T*)0, UnmentionableType(), UnmentionableType(), UnmentionableType(), UnmentionableType(), UnmentionableType())) == 1;
};

class c1
{
public:
    int operator() () {  return 0; }
};

class c2
{
public:
    void operator() (int) { }
};

class c3
{
public:
    template<typename... Args>
    void operator() (Args... a) { }
};

class c4
{
public:
    template<typename T>
    void operator() (T t) { }
};

int main()
{
    cout<<boolalpha<<has_property<c1>::value<<endl;
    cout<<boolalpha<<has_property<c2>::value<<endl;
    cout<<boolalpha<<has_property<c3>::value<<endl;
    cout<<boolalpha<<has_property<c4>::value<<endl;
}

输出：

false
false
true
false

注意事项：

1) 根据要求，它仅在可变参数模板化 operator() 上触发（嗯，几乎）

2) 这不是一个“完美”的解决方案，但对于实际使用来说应该足够了。

很遗憾 gcc 4.5.1 不能扩展参数包；我怀疑这可能对你有用：

template<typename U, typename... A>
static auto ftest(U* t, A... a) -> decltype((*t)(a...), char(0));

我仍然看不到一种方法来实际测试函数的真正可变性，而不是只传递 5 个（或更多）随机类型参数。

使用 with_enable if - 除了部分类专业化，我没有看到任何其他解决方案：

//non-specialized
template<typename T, typename E=void>
class container
{
    T* ptr;

public:
    T* get() { return ptr; }
};

//specialization for class with appropriate operator()
template<typename T>
class container<T, typename std::enable_if<has_property<T>::value, void>::type>
{
    T* ptr;

public:
    T* get() { return ptr; }

    template <typename... Args>
    decltype(T::template operator ()(Args()...)) operator ()(Args... args) const
    {
        return (*get()).operator ()(args...);
    }
};

Answer 2

最后，我找到了 GCC 4.5.3 的解决方法！

template <typename T>
class smart_ptr
{
public:
    // ... removed other member functions for simplicity
    T* get() const { return ptr; }

private:
    template <typename... Args>
    struct opparen_constret
    {
        typedef decltype(std::declval<T const>()(std::declval<Args>()...)) type;
    };

    template <typename... Args>
    struct opparen_ret
    {
        typedef decltype(std::declval<T>()(std::declval<Args>()...)) type;
    };

public:
    template <typename... Args>
    typename opparen_constret<Args...>::type operator ()(Args... args) const
    {
        return (*get())(args...);
    }

    template <typename... Args>
    typename opparen_ret<Args...>::type operator ()(Args... args)
    {
        return (*get())(args...);
    }

private:
    T* ptr;
};