std::function 赋值是否应该忽略返回类型？ [复制]

Question

根据 C++11 或 C++14 标准，下面的代码是有效的 C++ 吗？

#include <functional>

int ReturnInt()
{
  return 5;
}

int main( int argc, char **argv )
{
  std::function< void () > BoundType = ReturnInt;
  return 0;
}

该代码可以使用最新的 cygwin 版本的 gcc (4.8.3) 和 clang (4.3.2) 编译，但不能使用 Visual Studio 2013、Visual Studio 2013 年 11 月 CTP 或 Visual Studio 14 预览版。如果 std::function 更改为 boost::function，它也可以在所有平台上编译。

我发现 this 其他堆栈溢出问题表明它应该可以工作。

Answer 1

代码在 C++11 中是未定义的行为，在 C++14 中格式错误。 C++14 将此 Remark 添加到此构造函数的规范中：

备注：这些构造函数不得参与重载 分辨率除非 f 对于参数类型是 Callable (20.9.11.2) ArgTypes... 和返回类型 R。

Callable 定义在 [func.wrap.func]/p2:

F 类型的可调用对象 f 对于参数类型 ArgTypes 是可调用 如果表达式 INVOKE (f, declval<ArgTypes>()..., R)，则返回类型 R，被视为未计算的操作数 （第 5 条），格式正确 (20.9.2)。

为了使这个 INVOKE 格式正确，没有R 的INVOKE 的返回类型必须隐式转换为R（[func.require]/ p2)。

在 C++11 中，这些语句位于 Requries 子句下，这意味着由客户端来确保它们正确，如果客户端失败，任何事情都可能发生，包括成功编译。

这已被 LWG 2132 更改。

Answer 2

C++11 和 14 中的std::function 没有您想要的行为。

SFINAE 也无法检测到严重的过载。

我们可以将它包装成另一种类型，既具有您想要的行为（void 丢弃返回），又具有 SFINAE 错误过载检测，而我们如下：

template<class Sig>
struct checked_function;

template<class R, class... Args>
struct checked_function<R(Args...)>:std::function<R(Args...)> {
  using function = std::function<R(Args...)>;
  checked_function(std::nullptr_t):function() {}
  checked_function():function() {}
  template<class F, class=typename std::enable_if<
    std::is_convertible<
      typename std::result_of< F(Args...) >::type
      , R
    >::value
  >::type>
  checked_function( F&& f ):function( std::forward<F>(f) ) {}

  template<class F, class=typename std::enable_if<
    std::is_convertible<
      typename std::result_of< F(Args...) >::type
      , R
    >::value
  >::type>
  checked_function& operator=( F&& f ) { return function::operator=( std::forward<F>(f) ); }

  checked_function& operator=( checked_function const& o ) = default;
  checked_function& operator=( checked_function && o ) = default;
  checked_function( checked_function const& o ) = default;
  checked_function( checked_function && o ) = default;
};

template<class... Args>
struct checked_function<void(Args...)>:std::function<void(Args...)> {
  using function = std::function<void(Args...)>;
  checked_function(std::nullptr_t):function() {}
  checked_function():function() {}
  template<class F, class=typename std::enable_if<
    std::is_same<
      typename std::result_of< F(Args...) >::type
      , void
    >::value
  >::type>
  checked_function( F&& f, int*unused=nullptr ):function( std::forward<F>(f) ) {}

  template<class F>
  static auto wrap(F&& f){
    return [f_=std::forward<F>(f)](auto&&...args){
      f_( std::forward<decltype(args)>(args)... );
    };
  }
  template<class F, class=typename std::enable_if<
    !std::is_same<
      typename std::result_of< F(Args...) >::type
      , void
    >::value
  >::type>
  checked_function( F&& f, void*unused=nullptr ):
    function( wrap(std::forward<F>(f)) ) {}

   template<class F>
  typename std::enable_if<
    !std::is_same<
      typename std::result_of< F(Args...) >::type
      , void
    >::value,
    checked_function&
  >::type operator=( F&& f ) { return function::operator=( wrap(std::forward<F>(f)) ); }

  template<class F>
  typename std::enable_if<
    std::is_same<
      typename std::result_of< F(Args...) >::type
      , void
    >::value,
    checked_function&
  >::type operator=( F&& f ) { return function::operator=( std::forward<F>(f) ); }

  checked_function& operator=( checked_function const& o ) = default;
  checked_function& operator=( checked_function && o ) = default;
  checked_function( checked_function const& o ) = default;
  checked_function( checked_function && o ) = default;
};

它现在在 C++14 中编译（不是在 C++11 中，因为 wrap：wrap 可以在调用点替换为它自己的主体副本，所以......）。可能会减少一堆样板。

它使用了一些 C++14 特性（确切地说是 wrap 中的 move-into-lambda -- 你可以通过添加更多样板来消除它）。

尚未运行。