Question

在下面的代码段中，foo中的断言始终会触发。

任何人都可以解释为什么y是nullptr？这看起来像是终生问题，即在y和put的调用之间销毁了get，但我并不理解为什么。

我错过了什么？

TIA

class Y
{
public:
    Y(const std::string& name) : m_name(name)
    {
    }

    const std::string& getName() const
    {
        return m_name;
    }

private:
    Y(const Y&);

    const std::string m_name;
};

void foo(std::unique_ptr<Y> y)
{
    if (y == nullptr)
    {
        // ALWAYS FIRES
        assert(false && "nullptr\n");
    }

    std::string name = y->getName();
    std::cout << "name: " << name << "\n";
}

class X
{
public:
    X() {}

    void put(std::unique_ptr<Y> y)
    {
        m_queue.push([&] { foo(std::move(y)); });
    }

    void get()
    {
        std::function<void()> func = m_queue.front();
        func();
    }

private:
    std::queue<std::function<void()>> m_queue;
};


int main()
{
    std::unique_ptr<Y> y(new Y("fred"));
    X x;
    x.put(std::move(y));
    x.get();
    return 0;
}

Answer 1

void put(std::unique_ptr<Y> y)
{
    m_queue.push([&] { foo(std::move(y)); });
}

在此函数中，y是一个局部变量，当它超出范围时会被销毁。通过lambda捕获局部变量（引用），在执行时它不存在 - 它指向什么/ null / garbage / whatever，因为{ {1}}已被销毁。

Answer 2

因为y被破坏了：

void put(std::unique_ptr<Y> y)
{

    m_queue.push([&] {  // <== capturing y by-reference
        foo(std::move(y)); 
    });

    // <== y gets destroyed here
}

在put()结束时，y已被清理。

您希望您的仿函数取得y的所有权，理想情况如下：

[p = std::move(y)] {
    foo(std::move(p));
}

上面的lambda有一个类型为unique_ptr<Y>的成员变量，因此隐式删除了它的复制构造函数。但[func.wrap.func.con]规定：

template<class F> function(F f);
template <class F, class A> function(allocator_arg_t, const A& a, F f);

需要：F应为CopyConstructible。

所以这也不会编译。这让你有点卡住了。

Answer 3

void put(std::unique_ptr<Y> y)
{
    m_queue.push([&] { foo(std::move(y)); });
}

在这里，您推送一个包含对局部变量y的引用的lambda。离开put的那一刻，本地变量被销毁，而lambda包含一个悬空引用。任何进一步的行为都是未定义的。

您需要通过将局部变量移动到lambda中来捕获局部变量，但这非常先进，也不够，因为std::function无法保存仅移动的函数对象。解决此问题的最简单方法是从unique_ptr切换到shared_ptr并在lambda中按值捕获。

Answer 4

你的问题有两个问题。首先，您通过引用捕获其生命周期（及其副本的生命周期）超过当前本地范围的lambda。不要这样做。如果您的lambda（和所有副本）不会被复制到本地范围的生命周期之外，则仅使用[&]。

天真的答案是然后执行[=]或[y]，但您无法复制唯一指针。

在C ++ 14中，您可以执行[y=std::move(y)]将y移动到lambda捕获中。但是，无法复制已捕获unique_ptr按值的lambda。 std::function只能存储可调用，可销毁和可复制的对象。

解决这个问题的方法是等待仅限移动function（我认为这个问题正在进行中 - 我至少看过一个非正式的提案），或者推出自己的提议。

template<class Sig>
struct unique_function;
namespace details {
  template<class Sig>
  struct i_uf_impl;
  template<class R, class...Args>
  struct i_uf_impl<R(Args...)> {
    virtual ~i_uf_impl() {}
    virtual R invoke(Args&&...) = 0;
  };
  template<class Sig, class F>
  struct uf_impl;
  template<class R, class...Args>
  struct uf_impl<R(Args...):i_uf_impl<R(Args...)>{
    F f;
    virtual R invoke(Args&&...args) override final {
      return f(std::forward<Args>(args)...);
    }
  };
  template<class...Args>
  struct uf_impl<void(Args...):i_uf_impl<void(Args...)>{
    F f;
    virtual void invoke(Args&&...args) override final {
      f(std::forward<Args>(args)...);
    }
  };
}
template<class R, class...Args>
struct unique_function<R(Args...)> {
  std::unique_ptr<details::i_uf_impl<R(Args...)>> pimpl;
  unique_function(unique_function&&)=default;
  unique_function& operator=(unique_function&&)=default;
  unique_function()=default;
  template<class F, class=std::enable_if_t<
    !std::is_same<std::decay_t<F>, unique_function>
    && ( std::is_convertible<std::result_of_t< F(Args...) >, R >{}
      || std::is_same< R, void >{} )
  >>
  unique_function(F&& f):pimpl(
    new details::uf_impl<R(Args...), std::decay_t<F>>{std::forward<F>(f)}
  ) {}
  // override deduction helper:
  unique_function(R(*pfun)(Args...)):pimpl(
    pfun?
      new details::uf_impl<R(Args...), R(*)(Args...)>{pfun}
    : nullptr
  ) {}
  // null case
  unique_function(nullptr_t):unique_function(){}
  explicit bool operator() const { return static_cast<bool>(pimpl); }
  R operator()(Args...args)const{
    return pimpl->invoke( std::forward<Args>(args)... );
  }
};

可能会或可能不会奏效，但应该给你一个要点。

为什么unique_ptr为null？

4 个答案: