我需要一些C++结构的建议

I need some C++ structure advice

本文关键字：结构 C++      更新时间：2023-10-16

我有一个类A的实例。它有两个成员，对象A和对象B。我需要创建一个对象A的实例（这是一个相当大的对象）和两个对象B的实例，然后让对象B的两个实例都访问该对象A。他们永远不需要更改对象A，只需要访问它的信息。

现在，我通过创建对象A作为指针，将其传递到对象B的两个实例中，这两个实例都有自己的指针，然后指针指向内存中与对象A的指针相同的位置。这很好，但我认为这是一个很大的不不，对吧？因为一旦A类删除了原始指针，我就会有一些悬空指针，对吧？有更好的方法吗？

（仅供参考-在需要快速加载时间的程序中，对象A每次加载需要几秒钟，这就是为什么我必须只创建一个实例并将其传递给两个对象B，而不是让对象B创建自己的对象A实例。）

如果我没有错，你想要这样的东西：

// Class for "Object A" in your question
class Foo
{
    // ...
};
// Class for "Object B" in your question
class Bar
{
    Foo &foo_;
public:
    Bar(Foo &foo)
        : foo_(foo)
        {}
};
class A
{
    Foo foo_;
    Bar bar1_;
    Bar bar2_;
public:
    A()
        : bar1_(foo_),
          bar2_(foo_)
        {}
};

不使用指针，不使用分配，因此没有悬挂指针/引用或内存泄漏。当A被破坏时，bar1_和bar2_以及foo_也被破坏，因此Bar的两个实例也不会留下任何悬空引用。

如果"B事物"的寿命不超过"它们都有指针指向的大对象"，那么删除"大对象"时就不会有悬空指针。

如果"类A的一个实例"将这两个对象都作为数据成员，那么它们将同时被销毁（好吧，以与在类中声明它们的顺序相反的顺序，但几乎是在同一时间），因此应该很容易确保永远不会使用悬空指针。

另一方面，如果你随意地传递指向"大对象"的指针，将它们存储在寿命未知的各种不同的地方，然后删除"大对象"——当然，这是不允许的。问题是"随意"——你需要保持控制，并确保大物体比指向它的物体更耐用

例如，以下是完全安全的：

struct Big {
    // big stuff
};
struct Little {
    Little(const Big *a) : bigthing(a) {}
    // stuff that uses bigthing
  private:
    const Big *bigthing;
};
struct Foo {
    Big onlybigthing;
    Little firstlittlething;
    Little secondlittlething;
    Foo() : 
        onlybigthing(), 
        firstlittlething(&onlybigthing), 
        secondlittlething(&onlybigthing) 
    {}
};

当然，前提是Little的实例不将其指向Big的指针分发给任何来请求它并在Foo对象的生存期之后存储它的人。同样，Foo必须避免将Little实例的副本分发给可能存储这些副本（以及与之相关的指针）的人。

但是你说你的类A有两个成员，而这里我有三个（一个Big和两个Little），因为你还说你创建了这两个对象的三个实例。我不明白那是什么意思。

下面是另一个安全的例子：

int main() {
    Big big;
    Little little1(&big);
    Little little2(&big);
}

这里有第三个安全的例子：

struct Little {
    Little(const std::shared_ptr<Big> &a) : bigthing(a) {}
    // stuff that uses bigthing
  private:
    std::shared_ptr<Big> bigthing;
};
int main() {
    std::shared_ptr<Big> big(new Big());
    Little little1(big);
    Little little2(big);
    big.reset(); // release our shared ownership
    // safely do stuff using little1 and little2
    return 0;
    // on exit, little2 is destroyed first, then when little1 is destroyed
    // it releases the last shared ownership of the instance of `Big`,
    // which is destroyed.
}
相关文章：