Question

我在下面给出一个例子。该程序编译并运行良好，但我想知道它是否在理论上是根据C ++ 11标准的未定义行为;我可以返回绑定（临时）本地函数对象的结果吗？

示例代码（简称编辑）：

#include <iostream>
#include <functional>

struct MyFunctionObject
{
    inline void operator() ( const std::string& name )
        { std::cout<< "Hello " << name << "!" << std::endl; }
};

std::function< void () > my_greeter( const std::string& name )
{
    MyFunctionObject fun;
    return std::bind( fun, name );
}

int main()
{
    auto g = my_greeter("sheljohn");
    g();
}

编辑原始示例：

#include <random>
#include <functional>
#include <algorithm>
#include <utility>
#include <iostream>



        /********************     **********     ********************/
        /********************     **********     ********************/



namespace foo {


/**
 * Type of the generator returned by the method 'bind' below.
 */
template <class _dist>
using generator_type = std::function< typename _dist::result_type () >;

// ------------------------------------------------------------------------

/**
 * Wrapper for C++11 random library.
 */
template <
    class _engine = std::mt19937_64,
    class _device = std::random_device
>
struct random
{
    typedef _engine engine_type;
    typedef _device device_type;
    typedef random<_engine,_device> self;

    template <class _dist>
    static inline generator_type<_dist>
    bind( _dist& distribution )
        { return std::bind( distribution, self::engine ); }

    template <class _dist>
    static inline generator_type<_dist>
    bind( _dist&& distribution )
        { return std::bind( distribution, self::engine ); }

    static engine_type engine;
    static device_type device;
};

// Initialize static engine
template <class _engine,class _device>
_device random<_engine,_device>::device;

template <class _engine,class _device>
_engine random<_engine,_device>::engine = _engine( device() );

// ------------------------------------------------------------------------

/**
 * Generic binder to standard random distributions.
 *
 * SO QUESTION: does this cause undefined behaviour?
 */

template <class _dist, class... Args>
constexpr generator_type<_dist> random_generator( Args&&... args )
    { return random<>::bind( _dist( std::forward<Args>(args)... ) ); }


}; // namespace: foo



        /********************     **********     ********************/
        /********************     **********     ********************/



int main()
{
    auto ngen = foo::random_generator< std::normal_distribution<double> >( 0.0, 1.0 );

    for(unsigned i=0; i<10; ++i) 
        std::cout<< ngen() << " " << std::endl;
}

Answer 1

标准实际上有一个关于使用随机数生成器调用bind()的具体位，见第26.5节：

[注意：这些实体的指定方式允许将任何统一的随机数生成器对象e作为参数绑定到任何随机数分布对象d，从而产生零 - 参数函数对象如给出的绑定（d，e）所示。 -end note ]

因此明确允许您正在做的事情。

同样来自[func.bind.bind]，说明当您致电bind(F&& f, BoundArgs&&... bound_args)时（强调我的）：

FD类型为 decay_t<F>，

fd是由{strong> FD
构建的std::forward<F>(f)类型的左值
Ti是模板参数包中的 ith 类型BoundArgs

TiD的类型为 decay_t<Ti>

ti是函数参数包bound_args
中的 ith 类型
tid是由{strong> TiD
构建的std::forward<Ti>(ti)类型的左值
..


返回：转发调用包装器g ... g(,u1, u2, ..., uM)的效果应为INVOKE(fd, std::forward<V1>(v1), std::forward<V2>(V2), ... std::forward<VN>(vN), result_of_t<FD cv & (V1, V2, ..., VN)>)

这部分对我来说有点混乱，但基本上你传递的仿函数和参数被转发（复制/移动）到本地版本fd和tid...。 bind不会保留对仿函数的引用（FD 不是引用类型！），所有参数都是如此（{{1 TiD的类型也是不是引用类型。因此，在您的新示例中，即使BoundArgs和fun引用的字符串都超出范围，name结果仍然是有效的可调用对象。

这里没有UB。

Answer 2

你没有UB，但你真的有更多的运气而非理性。

此处没有未定义的行为，但仅限于此处：

return std::bind( distribution, self::engine );

您按值传递'distribution'，这意味着传递的是它的副本（尽管 distribution 是一个可变引用）。由于函数不能在指定位置对相同类型的值和引用进行重载，因此在您希望执行此操作的函数中必须存在各种技巧 - 这里是这样的：bind（）需要 std：：reference_wrapper - 用于传递引用的包装类型。所以，如果你这样做，你肯定会有一个未定义的行为：

return std::bind( ref(distribution), self::engine );

在这里可以找到。在这种情况下，你会传递一个真正的引用来绑定，在这种情况下，它将是一个对传递给包含它的函数外部的局部变量的引用。

返回绑定的本地函数对象会导致未定义的行为吗？

2 个答案: