我们可以从函数中按值返回具有已删除/私有复制/移动构造函数的对象吗？

Question

在 C++03 中，不可能按值返回具有私有非定义复制构造函数的类的对象：

struct A { A(int x) { ... } private: A(A const&); };

A f() {
  return A(10); // error!
  return 10;    // error too!
}

我想知道，C++11 中是否取消了此限制，使得可以编写具有类类型的函数没有用于复制或移动的构造函数的类的返回类型？我记得允许函数的调用者使用新返回的对象可能很有用，但他们无法复制该值并将其存储在某个地方。

Answer 1

这是它的工作原理

A f() {
  return { 10 };
}

即使 A 没有工作副本或移动构造函数，也没有其他可以复制或移动 A 的构造函数，它仍然有效！

为了利用 C++11 的这一功能，构造函数（在本例中采用 int）必须是非显式的。

Answer 2

该限制尚未解除。根据访问说明符，§12.8/32 中有一条注释解释：

无论是否发生复制省略，都必须执行两阶段重载决策。如果不执行省略，它确定要调用的构造函数，并且即使省略调用，所选的构造函数也必须是可访问的。

从删除的复制/移动构造函数开始，§8.4.3/2 指出

除了声明之外，隐式或显式引用已删除函数的程序是格式错误的。 [ 注意：这包括隐式或显式调用函数以及形成函数的指针或指向成员的指针。它甚至适用于未潜在评估的表达式中的引用。如果函数被重载，则仅当该函数被重载决策选择时才会引用该函数。 ——尾注]

不确定这种特殊情况，但我对引用的理解是，如果在 §12.8/32 中的重载决策之后选择了删除的复制/移动构造函数，即使操作被省略，也可能构成引用该函数，并且程序的格式将不正确。

Answer 3

上面的代码在 C++11 中仍然是格式错误的。但是你可以向 A 添加一个公共移动构造函数，这样它就合法了：

struct A
{
    A(int x) {}
    A(A&&);
private:
    A(A const&);
};

A f() {
  return A(10); // Ok!
}

Answer 4

我想知道，C++11 中取消了这个限制吗？

怎么可能呢？通过按值返回某些内容，根据定义，您正在复制（或移动）它。虽然 C++ 可以允许在某些情况下省略复制/移动，但它仍然按照规范进行复制（或移动）。

我记得允许函数的调用者使用返回的对象可能很有用，但他们无法复制该值并将其存储在某个地方。

是的。您摆脱了复制构造函数/赋值，但允许移动值。 std::unique_ptr 就是这样做的。

您可以按值返回unique_ptr。但这样做时，您将返回一个“纯右值”：一个正在被销毁的临时值。因此，如果你有一个这样的函数g：

std::unique_ptr<SomeType> g() {...}

你可以这样做：

std::unique_ptr<SomeType> value = g();

但不是this：

std::unique_ptr<SomeType> value1 = g();
std::unique_ptr<SomeType> value2 = g();
value1 = value 2;

但是这个是可能：

std::unique_ptr<SomeType> value = g();
value = g();

第二行调用value 上的移动赋值运算符。它将删除旧指针并将新指针移入其中，将旧值保留为空。

通过这种方式，您可以确保任何 unique_ptr 的内容仅存储在一个位置。您无法阻止它们在多个位置引用它（通过指向 unique_ptr 的指针或其他方式），但内存中最多只有一个位置存储实际指针。

删除复制和移动构造函数会创建一个不可移动对象。它被创建的地方就是它的价值所在的地方，永远。移动让您拥有独特的所有权，但又不至于一动不动。

Answer 5

如果您确实想要的话，您可能可以将代理组合在一起来实现这一目的，并有一个转换构造函数来复制代理中存储的值。

不过，

template<typename T>
struct ReturnProxy {
    //This could be made private, provided appropriate frienship is granted
    ReturnProxy(T* p_) : p(p_) { }
    ReturnProxy(ReturnProxy&&) = default;

private:
    //don't want these Proxies sticking around...
    ReturnProxy(const ReturnProxy&) = delete;
    void operator =(const ReturnProxy&) = delete;
    void operator =(ReturnProxy&&) = delete;

    struct SUPER_FRIENDS { typedef T GO; };
    friend struct SUPER_FRIENDS::GO;
    unique_ptr<T> p;
};

struct Object {
    Object() : data(0) { }

    //Pseudo-copy constructor
    Object(ReturnProxy<Object>&& proxy)
      : data(proxy.p ? proxy.p->data : throw "Don't get sneaky with me \\glare") 
    {
      //steals `proxy.p` so that there isn't a second copy of this object floating around
      //shouldn't be necessary, but some men just want to watch the world burn.
      unique_ptr<Object> thief(std::move(proxy.p));
    }
private:
    int data;

    Object(const Object&) = delete;
    void operator =(const Object&) = delete;
};

ReturnProxy<Object> func() {
    return ReturnProxy(new Object);
}

int main() {
    Object o(func());
}

您可能可以在 03 中使用 auto_ptr 执行相同的操作。显然，它不会阻止存储结果对象，尽管它确实限制每个实例只能保存一份副本。