C++OO风格中的引用计数

这是管理对象生存期的智能指针方法的合适替代方案，还是只是在找麻烦？

不，我认为重新发明引用计数不是一个好主意，尤其是因为我们现在在C++11中有std:：shared_ptr。根据std:：shared_ptr，您可以很容易地实现您可能具有多态引用计数的Pimpl习语类。请注意，我们不再需要实现复制-ctor、赋值、dtor，与引用计数器和克隆相比，突变变得更简单：

// to be placed into a header file ...
#include <memory>
#include <utility>
#include <string>
class Fred
{
public:
    static Fred create1(std::string const& s, int i);
    static Fred create2(float x, float y);
    void sampleInspectorMethod() const;   // No changes to this object
    void sampleMutatorMethod();           // Change this object
private:
    class Data;
    std::shared_ptr<Data> data_;
    explicit Fred(std::shared_ptr<Data> d) : data_(std::move(d)) {}
};

以及实施。。。

// to be placed in the corresponding CPP file ...
#include <cassert>
#include "Fred.hpp"
using std::shared_ptr;
class Fred::Data
{
public:
    virtual ~Data() {}                               // A virtual destructor
    virtual shared_ptr<Data> clone() const = 0;      // A virtual constructor
    virtual void sampleInspectorMethod() const = 0;  // A pure virtual function
    virtual void sampleMutatorMethod() = 0;
};
namespace {
class Der1 : public Fred::Data
{
public:
    Der1(std::string const& s, int i);
    virtual void sampleInspectorMethod() const;
    virtual void sampleMutatorMethod();
    virtual shared_ptr<Data> clone() const;
    ...
};
// insert Der1 function definitions here
class Der2 : public Data
{
public:
    Der2(float x, float y);
    virtual void sampleInspectorMethod() const;
    virtual void sampleMutatorMethod();
    virtual shared_ptr<Data> clone() const;
    ...
};
// insert Der2 function definitions here
} // unnamed namespace
Fred Fred::create1(std::string const& s, int i)
{
    return Fred(std::make_shared<Der1>(s,i));
}
Fred Fred::create2(float x, float y)
{
    return Fred(std::make_shared<Der2>(x,y));
}
void Fred::sampleInspectorMethod() const
{
    // This method promises ("const") not to change anything in *data_
    // Therefore we simply "pass the method through" to *data_:
    data_->sampleInspectorMethod();
}
void Fred::sampleMutatorMethod()
{
    // This method might need to change things in *data_
    // Thus it first checks if this is the only pointer to *data_
    if (!data_.unique()) data_ = data_->clone();
    assert(data_.unique());
    // Now we "pass the method through" to *data_:
    data_->sampleMutatorMethod();
}

（未经测试）

如果它合适，你为什么不经常使用它？

我认为引用计数，如果你自己实现的话，更容易出错。它在多线程环境中也有速度慢的名声，因为引用计数器必须以原子方式递增和递减。但我想，由于C++11提供了shared_ptr和move语义，这种写时复制模式可能会再次流行起来。如果为Fred类启用move语义，则可以避免原子递增引用计数器的一些开销。因此，将Fred对象从一个位置移动到另一个位置应该比复制它更快。

这是管理对象生存期的智能指针方法的合适替代方案，还是只是在找麻烦？

这是一种替代方案，但除非你有充分的理由使用它，否则它只是（以不可重复使用的方式）重新发明轮子。

如果您将代码更改为使用shared_ptr，您将不再需要显式定义复制/所有权语义（以及在您的pimpl库中定义复制构造函数和赋值）。您还将使用已经定义和测试过的代码（因为它是库的一部分）。

如果它合适，你为什么不经常使用它？

因为shared_ptr是可用的，并且已经实现了功能和所有的"gotcha"。

我也是，我想知道它是否适合作为智能指针的替代品。

但是，IMO，要成为智能指针，类必须可用作指针，即：

SmartPtr<int> ptr = new int(42);
int x = *ptr;

是的，这是一种内存管理，但它不是一个智能指针，因为它没有指针的语义。

正如评论中提到的，pimpl习惯用法确实有助于维护兼容性，而且它还可以促进开发，因为您不必重新编译包含类。但是，为了获得后一个优势，您不能在父类内部定义内部类（即Data），而只能提出一个前向声明，并将实际定义放在另一个头中。

class Fred {
    ...
private:
class Data;
};

而且，我发现在类Fred中声明Data的变体对未来的开发没有用处，因为如果你需要添加另一个类，你需要修改Fred，而不仅仅是创建另一个类别。这可能是需要的，但我建议你避免那个部分。

如果我不清楚什么，请随时提问！

1. C++FAQ的答案似乎更像是一个如何管理共享数据（使用写时复制）的简单示例。缺少几个方面，这可能很重要。

2. 不同意我对1的看法。

为了避免像std::shared_ptr那样使用"外部"引用计数带来的开销，您可以使用Andrei Alexandrescu的《现代C++设计》一书中描述的侵入式引用计数机制。Loki:：COMRefCounted类展示了如何为Windows共享COM对象实现这样的所有权策略。

从本质上讲，它可以归结为智能指针模板类接受一个接口，该接口管理指针类实例本身中的引用计数和delete可用性检查。我不知道STD C++库是否支持为std::shared_ptr类实现这样的策略覆盖。

我们在许多嵌入式项目中非常成功地将Loki库仅用于智能指针模型。特别是由于这个特性，模型在细粒度方面的效率更高。

注意建议的（内置）实现默认情况下不是线程安全的。

如果以上所有方面都与您的目的无关，我建议使用sellibitze的答案中所示的Fred::Data类的简单std::shared_ptr表示。我也同意他在最后一段中提出的观点，引用计数和智能指针语义很容易被误解和实现错误。

如果C++11标准或boost不适合您，那么loki库仍然提供了一个易于集成和健壮的智能指针实现。