为了获得引用计数，我是否必须使用shared_ptr来扰乱我的API？

Question

我最近遇到了以下内存错误，在这里很容易发现，但在更复杂的代码中可能更难检测到：

class Foo : public IFoo {
  const Bar& bar_;
public:
  Foo(const Bar& bar) : bar_(bar) {
  }
  void test() {
    // access bar_ here
  }
};

int baz() {
  IFoo* foo = NULL;
  if(whatever) {
    Bar bar;
    foo = new Foo(bar);
  }
  else {
    // create other foo's
  }
  foo->test(); // segmentation fault
}

该错误是 Bar 立即超出范围，被销毁，然后在 foo->test() 中使用。一种解决方案是使用 Bar* bar = new Bar() 在堆上创建 Bar。但是，我不喜欢这样做，因为我必须将 Bar* bar 指针保留在顶层，以便我可以在最后删除它，即使 Bar 是特定于该特定代码块 if(whatever){} 的内容。

另一个解决方案是 boost::shared_ptr，但我不能只这样写：

  if(whatever) {
    boost::shared_ptr<Bar> bar(new Bar());
    foo = new Foo(*bar);
  }

因为 shared_ptr 也会立即超出范围，从而破坏所包含的对象。

简而言之，为了摆脱这个问题，我必须在任何地方使用 shared_ptr，在 Foo 中作为成员变量，在 >Foo 的构造函数等。为了消除这些问题，我的所有 API 等都必须使用 shared_ptr，这有点难看。但是，这样做是正确的吗？到目前为止，我有时会使用它来创建引用计数对象，但我的 API 中没有 shared_ptr。您如何处理这个问题：一旦您使用了shared_ptr，您就必须到处使用它？

（另外，如果您使用这些引用计数指针，您必须开始担心您是否真的想要 shared_ptr 还是 weak_ptr 等）

并且，我将使用什么作为相当于 Foo(const Bar& bar)？ Foo(const shared_ptrbar)?

当然，另一种选择是使用 pimpl 和您自己的计数器在 Bar 和其他对象中添加引用计数，但一般来说这太乏味了。

Answer 1

我实际上会提出另一种解决方案...

我不太喜欢引用计数，不仅仅是混乱，而且还因为当多个对象拥有同一项目的句柄时很难推理。

class IBar
{
public:
  virtual ~IBar() {}
  virtual IBar* clone() const;
};

class Foo: public IFoo
{
public:
  Foo(const IBar& ibar): m_bar(ibar.clone()) {}
  Foo(const Foo& rhs): m_bar(rhs.m_bar->clone()) {}
  Foo& operator=(const Foo& rhs) { Foo tmp(rhs); this->swap(tmp); return *this; }
  virtual ~Foo() { delete m_bar; }

  void swap(Foo& rhs) { std::swap(m_bar, rhs.m_bar); }

private:
  IBar* m_bar;
};

现在你的代码可以工作了，因为我做了一个副本:)

当然，如果 Bar 不是多态的，那么它会容易得多。

那么，即使它没有使用参考，您确定您确实需要一个吗？

---

现在让我们偏离正轨，因为你做错了很多事情：

• foo = new Foo(bar) 不太漂亮，你如何保证内存被删除，以防万一发生异常或在 if 混乱中引入一些 return ？您应该转向为您管理内存的对象 auto_ptr 或来自 C++0x 或 Boost 的新 unique_ptr。
• 为什么 Foo 不获取所有权，而不是使用引用计数？ Foo(std::auto_ptrbar) 也可以。

在不需要的地方回避引用计数。每次您分享某些内容时，您实际上会在代码中引入难以跟踪的错误来源（以及潜在的副作用）。这就是 Haskell 和函数式家族越来越受欢迎的原因:)

Answer 2

另外，如果你使用这些引用计数指针，你必须开始担心你是否真的想要shared_ptr还是weak_ptr等

如果你遵循你的设计并且你理解什么是weak_ptr（提示：它不是参考）以及它的用途（提示：它不是为了“打破循环”）。

如果您确实开始担心，那是因为您从未进行过设计，或者您不了解 shared_ptr 设计。

Answer 3

您可以简单地将 bar 对象移动到更高的范围，以防止过早删除它。

int baz() {
  Bar bar;
  IFoo* foo = NULL;
  if(whatever) {
    foo = new Foo(bar);
  }
  else {
    // create other foo's
  }
  foo->test(); // no more segmentation fault
}

Answer 4

事实上，我确实在任何地方都使用shared_ptr...有几种方法可以让它看起来不那么混乱。我使用的一个约定是为每个定义的类使用 typedef：

class AClass {
public:
    typedef boost::shared_ptr<AClass> Ptr;
    typedef boost::weak_ptr<AClass> Ref;
    //...
};

使代码更具可读性:)

至于您的具体问题，请记住您可以通过指针传递 bar - 但您必须记住在堆上分配它。

Answer 5

最好不要将 bar byref 传递到 Foo 中（换句话说，更改 Foos 构造函数），或者复制它，以便在 Foo 中保留一个副本。当然，在某些情况下这是不可能的。

关于使用 shared_ptr 覆盖代码，最简单的解决方案是将 shared_ptr 键入 BarPtr 或类似的。

Answer 6

我知道您提供了代码的简化版本，在没有看到其余部分的情况下，我不知道我现在所说的是否可行。

由于 foo 是寿命最长的对象，因此如何在其中创建 Bar 实例，并让其他变量（代码中的 bar）引用到那个？

另一方面，如果 Bar 确实特定于 if 块的内部，则 test() 根本不需要它。在这种情况下，将指针保留在 Foo 内然后在 if 块末尾删除它是没有问题的。否则，也许它不是那么特定于该块，您必须重新考虑您的设计。