返回本地对象的元组

Question

如何利用结构化绑定和元组来返回函数的本地对象？

在函数中，我创建相互引用的本地对象，我希望以元组的形式返回这些对象，并在调用函数时使用结构化绑定来标识它们。我现在有：

std::tuple<Owner&&, State<Controller>&&, State<Ancillary>&&, State<Compressor>&&>
inline makeOwner() {
    State<Controller>&& controller = State<Controller>();
    State<Ancillary>&&  ancillary  = State<Ancillary>();
    State<Compressor>&& compressor = State<Compressor>();

    Owner&& owner = Owner(controller, ancillary, compressor);

    return {owner, controller, ancillary, compressor};
}

// using the function later

const &&[owner, controller, ancillary, compressor] = makeOwner();

这不起作用，我得到一个错误，说返回值不能转换为前面提到的返回类型的元组。我不确定为什么会这样，因为类型与声明匹配。

最终，我试图创建一个方便的函数，这样我就不必每次想创建一个新的所有者时都在函数中键入四行。这是我使用结构化绑定使其更容易的尝试。

编辑：我应该注意，我希望最后一行中的绑定引用owner中的对象。因此，副本不足。

Answer 1

inline auto makeOwner() {
   struct bundle {
     State<Controller> controller;
     State<Ancillary> ancillary;
     State<Compressor> compressor;
     Owner owner = Owner(controller, ancillary, compressor);
     bundle(bundle  const&)=delete;
     bundle& operator=(bundle  const&)=delete;
   };
   return bundle{};
}

// using the function later

const auto&&[owner, controller, ancillary, compressor] = makeOwner();

这里我们使用这样一个事实，即结构，即使是匿名的结构，也可以像元组一样被分解。

活生生的例子。

Answer 2

我希望最后一行的绑定引用所有者内部的对象。

让我们忽略所有新的语言功能，回到基础。你认为这会怎样？

int&& f() { return 0; }
int&& r = f();

你想让r成为f内部局部变量的引用吗？但是在执行f（）的最后，它会被破坏。这段代码可以编译，但r是一个悬而未决的参考。

唯一安全的方法是确保f（）返回一个对象的引用，该对象肯定比函数更有效。可能是局部的静态的，可能是全局的，可能是类的一个成员变量，f是类的一个成员函数，等等：

int global = 0;
int&& f() { return std::move(global); }
int&& r = f(); // okay, r is a reference to global, no dangling

或者，如果这没有意义，那么需要按值返回一个对象。你仍然可以参考它。或者不是：

int f() { return 0; }
int&& r = f(); // okay, lifetime extension
int i = f();   // okay, prvalue elision

一旦我们添加了tuple和结构化绑定的所有复杂性，相同的基本原则就会适用。通过值返回本地非静态对象，或者通过引用返回其他对象。但是不要通过引用返回本地非静态对象。

最终，我试图创建一个方便的函数，这样我就不必每次想创建一个新的所有者时都在函数中键入四行。这是我使用结构化绑定使其更容易的尝试。

为什么不直接做一个类型呢？

struct X {
    X() : owner(controller, ancillary, compressor) { }
    X(X const&) = delete;
    X& operator=(X const&) = delete;

    State<Controller> controller;
    State<Ancillary>  ancillary;
    State<Compressor> compressor;
    Owner owner;        
};

// lifetime extension on the X, no copies anywhere
// note that owner is last
auto&& [controller, ancillary, compressor, owner] = X();

// no lifetime extension, but also no copies because
// prvalue elision
auto [controller, ancillary, compressor, owner] = X();