c++ - 应该如何设计两个紧密相关的数据结构的所有权？

Question

我有一个类 A 和一个结构 B(这是一个普通的旧数据结构)。这两个对系统建模的方式是A在某种意义上表示整个系统的状态，由多个B和其他状态组成。这意味着如果没有 A，B 毫无值(value)。我想制作一个 API，您可以在其中将 B“添加”到 A，然后直接修改 B 的状态(通过保留对它们的引用之类的东西)。

不过，我不确定的是如何根据所有权来设计它。我有几个选择。由于我使用的是 C++，所以这很复杂。如果我使用 Java，我可能会这样设计代码:

class A {
    private List<B> bs = new ArrayList<>();

    public void add(B b) {
        bs.add(b);
    }
}

API 用户自己创建 B 的地方，或者像这样:

class A {
    private List<B> bs = new ArrayList<>();

    public B create(int data) {
        B b = new B(data);
        bs.add(b);
        return b;
    }
}

A 系统自己创建对象的位置。这可能是更好的方法，因为 B 没有 A 就什么都不是。我什至可以通过某种方式让 B 构造函数只能被 A 访问，但我不确定如何做。

但请记住，那是在 Java 中。该系统将使用 C++ 进行编程，并且其工作方式有所不同。

我想第一个例子看起来很相似:

class A {
public:
    void add(B& b)
    {
        bs.push_back(&b);
    }

private:
    std::vector<B*> bs;
};

但由于我更喜欢​​第二个选项，所以我尝试翻译它:

class A {
public:
    B& create(int data)
    {
        bs.emplace_back(data);
        return bs.back();
    }

private:
    std::vector<B> bs;
};

但在这种情况下，我将返回对 B 的引用。调整 bs 大小时，它可能会在内存中移动，从而使返回的引用无效。你会如何解决这个问题？或者您会尝试用什么其他方式来设计它？

Answer 1

没有理由不能在 C++ 中使用任何一种数据模型，只是语法不同而已。

在第一种情况下，add 的调用者必须实例化B 的实例。然后它将 B 传递给 A 的实例，后者持有对 b 的引用(或指针，在 C++ 术语中):

#include <memory>
#include <vector>

class B {
};

class A {
public:
    void add(std::shared_ptr<B> b) {
        bs.push_back(b);
    }
private:
    std::vector<std::shared_ptr<B> > bs;
};

int main(int argc, const char *argv[]) {
    A a;
    std::shared_ptr<B> b(new B);
    a.add(b);
}

在此实现中，我们持有指向 B 的每个实例的共享指针。共享指针使用类似于 Java 处理内存管理的方式的引用计数器。只要某人持有对 B 的特定实例的引用(通过 shared_ptr)，该特定实例将保留在内存中。 shared_ptr 与 Java 的不同之处在于，一旦引用计数减为 0，实例就会被删除。 Java 等待 future 的某个时间点进行垃圾收集。这种模式在C++中被称为RAII(资源获取即初始化)。

您的第二个模型可以类似地处理。您可以在 vector 中使用 shared_ptr 或直接使用原始指针。因为我已经在上面展示了 shared_ptr，所以我将在这里展示原始指针:

class B {};

class A {
public:
    ~A() {
        for (std::vector<B*>::iterator it = bs.begin(); it != bs.end(); ++it) {
            delete *it;
        }
        bs.clear();
    }

    B* create(int data) {
        B *b = new B(data);
        bs.push_back(b);
        return b;
    }

private:
    // block copy construction since we don't manually copy the contents of our
    // vector
    A(const A&) {}
    void operator=(const A&) {}
    std::vector<B*> bs;
};

在这个设计中，由于我们使用了裸指针，我们必须自己管理内存。这引入了对析构函数的需求，该析构函数在 A 的实例被销毁时释放存储在 vector 中的所有 B 实例。我们现在还返回一个指向我们在 create 中创建的每个新 B 实例的指针。这种内存模型比第一种方法更模糊，因为我们有 float 的原始指针，因此需要采用一种策略，该策略只能通过纪律强制执行，关于谁拥有并负责每个实例的内存管理B。针对此 API 编写代码的开发人员可以删除返回给他的 B 实例，这将在您下次尝试访问该 B 实例时导致段错误或未定义的行为。

我的建议？使用 shared_ptr 除非这需要快速性能并且每个操作都很重要。

编辑

根据 Yakk 的建议隐藏复制构造函数和赋值运算符。