通过组合来实现引用计数可以吗？

Question

最常见的可重用引用计数对象使用私有继承来实现重用。我不是私有继承的忠实粉丝，我很好奇这是否是一种可以接受的处理方式：

class ReferenceCounter {
    std::size_t * referenceCount;
public:
    ReferenceCounter()
        : referenceCount(NULL) {};
    ReferenceCounter(ReferenceCounter& other)
        : referenceCount(other.referenceCount) {
            if (!referenceCount) {
                referenceCount = new std::size_t(1);
                other.referenceCount = referenceCount;
            } else {
                ++(*referenceCount);
            }
    };
    ReferenceCounter& operator=(const ReferenceCounter& other) {
            ReferenceCounter temp(other);
            swap(temp);
            return *this;
    };
    void swap(ReferenceCounter& other) {
        std::swap(referenceCount, other.referenceCount);
    };
    ~ReferenceCounter() {
        if (referenceCount) {
            if (!*referenceCount)
                delete referenceCount;
            else
                --(*referenceCount);

        }
    };
    operator bool() const {
        return referenceCount && (*referenceCount != 0);
    };
};

class SomeClientClass {
    HANDLE someHandleThingy;
    ReferenceCounter objectsStillActive;
public:
    SomeClientClass() {
        someHandleThingy = RegCreateKeyEx(...);
    }
    ~SomeClientClass() {
        if (objectsStillActive)
            return;
        RegCloseKey(someHandleThingy);
    };
};

或者是否存在我没​​有看到的微妙问题？

编辑
我并不是超级关心这个特定的实现（它可能有错误——在生产代码中使用类似的东西之前我将花一些时间查看shared_ptr的内部结构）——我只是担心一般来说，有一个特定的原因可重用的引用计数好东西似乎总是使用继承而不是组合来实现。

Answer 1

复制句柄时一定要记住复制计数器。您可能不希望将操作系统类型传递到模板中，但我认为这里的安全性需要继承。 （不过，不是从 HANDLE 继承。）

HANDLE 也可能是一种特殊情况，因为它是 POD。本质上，您有一个除 T* 之外的类型的指针。

我看到了您希望在计数归零时发生除了删除之外的其他操作的动机。 smart_ptr 的改编可能会起作用，而且您可能离那不远了。

Answer 2

我不认为这有任何优点。引用计数仅对共享对象有意义。目标是节省堆分配和/或复制这些内容。事实上，您实现了某种复制计数器。但即使这样也没什么用，因为它不提供任何接口来查询计数器值。我可以建议重新访问 boost::intrusive？

Answer 3

事实上，您正在为 HANDLE 类之外的 HANDLE 实现引用计数...这非常接近 shared_ptr。

使用组合来实现引用计数很好，但如果您的引用计数对象 ReferenceCounter 拥有类 HANDLE 实例会更好...使用起来更安全，并且重用成本更低，因为您只实现一次删除例程，而不是在所有构造函数（arg）中执行它。

使用私有继承的唯一有效原因是空基优化，所有其他情况都可以通过组合来处理，组合在耦合方面要好得多，因此他们不太可能有充分的理由这样做，更有可能的是，他们这样做是出于误导或懒惰。