C++17 中具有引用成员的结构体的深拷贝

Question

我对 C++ 还是很陌生，对引用和移动语义感到困惑。 对于我正在编写的生成 C++17 代码的编译器，我需要能够拥有包含其他结构字段的结构。 由于结构定义将根据用户的另一种语言代码生成，因此它们可能非常大，因此我将内部结构存储为参考。 这对于处理开头声明但稍后定义的不完整类型也是必要的，这可能会发生在生成的代码中。 （我避免使用指针，因为在所有地方添加*来取消引用会使代码生成不那么简单。）

我正在编译的语言没有别名，所以像Outer b = a这样的东西应该总是一个“深拷贝”。 所以在这种情况下， b.inner应该是一个拷贝a.inner ，而不是对它的引用。 但我不知道如何设置构造函数以在 C++ 中创建深复制行为。 我为Outer尝试了许多不同的构造函数配置，我尝试了Inner&和Inner&&来存储inner 。

这是生成的代码外观的模拟示例：

#include <iostream>

template<typename T>
T copy(T a) {
    return a;
}

struct Inner;

struct Outer {
    Inner&& inner;
    
    Outer(Inner&& a);
    Outer(Outer& a);
};

struct Inner {
    int v;
};


Outer::Outer(Inner&& a) : inner(std::move(a)) {
    std::cout << " -- Constructor 1 --" << std::endl;
}

// Copy the insides of the original object, then move that rvalue to the new object?
Outer::Outer(Outer& a) : inner(std::move(copy(a.inner))) {
    std::cout << " -- Constructor 2 --" << std::endl;
}

int main() {
    Outer a = {Inner {30}};
    std::cout << a.inner.v << std::endl;    // Should be: 30
    a.inner.v += 1;
    std::cout << a.inner.v << std::endl;    // Should be: 31
    
    Outer b = a;   // Copy a to b
    
    std::cout << a.inner.v << std::endl;    // Should be: 31
    std::cout << b.inner.v << std::endl;    // Should be: 31
    
    b.inner.v += 1;
    
    std::cout << a.inner.v << std::endl;    // Should be: 31
    std::cout << b.inner.v << std::endl;    // Should be: 32
    
    return 0;
}

这就是它当前的输出（它可能因实现而异）：

 -- Constructor 1 --
30
31
 -- Constructor 2 --
297374876
32574
297374876
32574

显然这个输出是不正确的，我想我必须在其他地方有一个悬空参考。 我应该如何设置Outer以获得正确的行为？

Answer 1

（我避免使用指针，因为在所有地方添加 * 来取消引用会使代码生成不那么简单。）

不要让你想要的接口干扰你的实现。 接口和实现分离是一个强大的工具。

你的目标是深拷贝。 你的临时工不会活得足够长。 有些东西必须拥有复制的数据，这样它才能活得足够长（没有悬空引用）并且不会活得太久（没有内存泄漏）。 引用不拥有其数据。 由于数据不会直接成为您结构的一部分，因此您需要一个具有所有权语义的指针。

这并不意味着代码必须“到处”添加取消引用。 为了帮助您的接口，您可以引用指针拥有的对象。 通常这会浪费空间，但它可能会在您的项目中发挥作用，假设您对代码生成的评估是准确的。

例子：

struct Outer {
    // Order matters here! The pointer must be declared before the reference!
    // (This should be less of a problem for generated code than it can be for
    // code edited by human programmers.)
    const std::unique_ptr<Inner> inner_ptr;
    Inner & inner;
    // The idea is that `inner` refers to `*inner_ptr`, and the `const` on
    // `inner_ptr` will prevent `inner` from becoming a dangling reference.

    // Copy constructor
    Outer(const Outer& src) :
        inner_ptr(std::make_unique<Inner>(src.inner)),  // Make a copy
        inner(*inner_ptr)                               // Reference to the copy
    {}

    // The compiler-generated assignment operator will be deleted because
    // of the reference member, just as in the question's code
    // (so having it deleted because of the `unique_ptr` is not an issue).
    // However, to make this explicit:
    Outer& operator=(const Outer&) = delete;
};

通过上述设置，您仍然可以通过object.inner.field语法访问内部数据的成员。 虽然这对于通过object.inner_ptr->field语法进行访问是多余的，但您表示您已经建立了对前一种语法的需求。

为了未来读者的利益：
这种方法有一些缺点，通常会导致我反对它。 这是对哪些缺点更大的判断——这种方法中的那些或“不太直接”的代码生成。 有时机器生成的代码需要一些低效率来确保极端情况正确运行。 所以在这种特殊情况下这可能是可以接受的。

---

如果我可能会偏离你想要的语法，一个更简洁的选择是拥有一个访问器函数。 这是否适用于您的情况取决于此问题适当超出范围的详细信息。 可能值得考虑。

您可以通过成员函数根据需要生成引用，而不是通过在结构中存储引用来浪费空间。 这具有不需要标记指针const的副作用。

struct Outer {
    // Note the lack of restrictions imposed on the data.
    // All that might be needed is an assertion that inner_ptr will never be null.
    std::unique_ptr<Inner> inner_ptr;

    // Here, `inner` will be a member function instead of member data.
    Inner & inner() { return *inner_ptr; }
    // And a const version for good measure.
    const Inner & inner() const { return *inner_ptr; }

    // Copy constructor
    Outer(const Outer& src) :
        inner_ptr(std::make_unique<Inner>(src.inner()))  // Make a copy
    {}

    // With this setup, the compiler-generated copy assignment
    // operator is still deleted because of the `unique_ptr`.
    // However, a compiler-generated *move* assignment is
    // available if you specifically request it.
    Outer& operator=(const Outer&) = delete;
    Outer& operator=(Outer &&) = default;
};

通过这种设置，可以通过像object.inner().field这样的语法来访问内部数据的成员。 我不知道额外的括号是否会导致与星号相同的问题。

Answer 2

C++ 中的引用（几乎总是）是非拥有别名。

您不想要非拥有别名。

因此，不要使用引用。

您可以拥有一个拥有（智能）指针和一个引用别名，以使某些代码生成更容易。 不要这样做。 这样做的结果是一个混合语义的类； 在这种情况下，没有您可以编写的连贯合理的operator=和复制/移动构造函数。

我的建议是：

1. 编写一个从unique_ptr继承但在赋值时复制的value_ptr 。

那么要么：

2. 使用->生成代码

或者

3. 添加一个返回*ptr引用的辅助方法，并生成执行method()代码。

Answer 3

只有当类拥有所有权时，深度复制才有意义。 引用通常不用于所有权。

显然这个输出是不正确的，我想我必须在其他地方有一个悬空参考

你猜对了。 在声明中： Outer a = {Inner {30}}; Inner的实例是一个临时对象，它的生命周期一直延续到该声明结束。 之后，参考成员悬空。

所以我将内部结构存储为参考

引用不存储对象。 引用是指存储在其他地方的对象。

我应该如何设置 Outer 以获得正确的行为？

似乎智能指针可能对您的用例有用：

struct Outer {
    std::unique_ptr<Inner> inner;
};

不过，您需要定义一个深拷贝构造函数和赋值运算符。