2

我想避免在调用模板成员函数时指定返回类型。'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;
}
4

2 回答 2

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_ofor std::tr1::result_of。

于 2013-04-24T17:13:24.123 回答
1

据我所知，如果我们修改您的调用以包含&运算符，则原始代码中唯一的错误是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函数的类型转换为指向相同类型函数的指针，这是函数可以返回的东西。并且您可以像调用实际函数一样调用指向函数的指针，因此也没有什么坏处。

于 2013-04-24T17:44:14.723 回答