使用函子的返回类型来声明模板方法的返回类型，无需 decltype

Question

我想避免在调用模板成员函数时指定返回类型。 'decltype' 关键字与 'auto' 结合可以实现这一点，但不幸的是，我们没有适用于我们需要支持的所有平台的 C++11 编译器。使用类型限定模板方法应用程序也可以，但需要调用者...使用类型限定模板方法。

以下是否可能，有一些模板魔法？ boost 1.48 在这里提供任何帮助吗？

我们的实际代码是利用 boost::thread、boost::packaged_task 和 boost::unique_future，但这里是一个人为的例子：

#include <functional>

#ifdef WONT_COMPILE
struct WrapNoDecltype
{
    WrapNoDecltype() {}

    template<typename F>
    std::result_of<F>::type // warning: 'std::result_of<_Fty>::type' : dependent name is not a type
    operator()(const F& f)
    {
        setup();
        std::result_of<F>::type result = f();
        teardown();

        return result;
    }

    void setup() { }
    void teardown() { }
};
#endif

struct Wrap
{
    Wrap() {}

    template<typename F>
    auto operator()(const F& f) -> decltype(f())
    {
        setup();
        typename std::result_of<F()>::type result = f();
        teardown();

        return result;
    }

    void setup() { }
    void teardown() { }
};

struct WrapWithReturnType
{
    WrapWithReturnType() {}

    template<typename RetType>
    RetType
    apply(const std::function<RetType(void)>& f)
    {
        setup();
        RetType result = f();
        teardown();

        return result;
    }

    void setup() { }
    void teardown() { }
};

int answer()
{
    return 42;
}

int main()
{
    Wrap w;
    WrapWithReturnType wwr;
#ifdef WONT_COMPILE
    WrapNoDecltype wna;
#endif

    int i = w(answer);
    int j = wwr.apply<int>(answer);
#ifdef WONT_COMPILE
    int k = wna(answer);
#endif
    return 0;
}

Answer 1

struct WrapNoDecltype
{
    WrapNoDecltype() {}

    // version for function references
    template < typename Res >
    Res operator()( Res(&f)() )
    {
        setup();
        Res result = f();
        teardown();

        return result;
    }

    // version for everything
    template < typename T >
    typename std::result_of<typename std::decay<T>::type ()>::type
    operator()( T const& f )
    {
        setup();
        typename std::result_of<typename std::decay<T>::type ()>::type result = f();
        teardown();

        return result;
    }

    void setup() { }
    void teardown() { }
};

正如Yakk 指出的那样，通过合并decay，第二个版本始终有效。第一个版本要简单得多，但仅在传递函数引用时才有效。

当然，你也可以使用boost::result_of或std::tr1::result_of。

Answer 2

据我所知，如果我们修改您的调用以包含 & 运算符，则原始代码中唯一的错误是在谈论依赖类型时缺少 typename，并且缺少参数列表拨打std::result_of时：

struct WrapNoDecltype
{
  WrapNoDecltype() {}

  template < typename T >
  typename std::result_of<T()>::type operator()( T const &f )
  {
    setup();
    typename std::result_of<T()>::type result = f();
    teardown();

    return result;
  }
};

但是，std::result_of 是 C++11 特征类，因此如果您的编译器不支持 decltype，它可能无法正确支持 std::result_of。

std::tr1::result_of 可能有妨碍上述工作的怪癖。

在野外，在函数指针类型上使用std::result_of：http://ideone.com/dkGid8

正如@DyP 所指出的，这仅在您使用&f 而不是f 调用它时才有效。要解决此问题，请像这样使用std::decay：

struct WrapNoDecltype
{
  WrapNoDecltype() {}

  template < typename T >
  typename std::result_of<typename std::decay<T>::type()>::type
    operator()( T const &f )
  {
    // setup()
    typename std::result_of<typename std::decay<T>::type()>::type
      result = f();
    // teardown()

    return result;
  }
};

int foo() { return 7; }
int main()
{
  WrapNoDecltype test;
  int x = test(foo);
}

将函数类型转换为函数指针类型。

这是必需的，因为 std::result_of 滥用 C++ 语法。 std::result_of< Func_Type ( Args... ) > 实际上是对 返回 Func_Type 并采用 (Args...) 的函数类型进行操作。然后它说“如果我们将Args... 应用于Func_Type 会怎样。当Func_Type 是函数的实际类型时，这将无法工作，因为不允许您返回函数的实际实例。

std::decay 将 Func_Type 作为函数的类型转换为指向相同类型函数的指针，这是函数可以返回的东西。你可以像调用一个实际函数一样调用一个指向函数的指针，所以也没有什么坏处。