c++ - 使用哪种类型的指针来实现对集合元素的共享访问？

Question

为了使讨论清楚，我将以非常笼统的方式描述问题，即我既不会提供真实类的名称，也不会描述域/上下文(但是，如果结果是紧急)。

想象类A .让这个类(class)有 2 不可变 字段，例如 x和 y (请注意，这些可能是 大 对象，即复制效率低下)。此外，让这些 x和 y是 初级 字段，即仅在 == 的实现中使用它们/!=运算符以及哈希计算函数。

自 A是 不可变 在 x 方面和 y ，想法是让A的多个实例(比如 a1 和 a2 )有 a1.x == a2.x a1.y == a2.y (即 a1 == a2 )到 隐含 共享访问权限 x和 y ，这样就没有不必要的重复。

此外，现在想象在 A 中还有另一个字段。 :z , 即 二级和 可变 ，并作为 A 的一种行为调整.根据设计，希望在 之间共享此字段。等于 A 的实例太 .所以，如果我调用 a1.setZ(...)此更改也将影响 a2因为他们访问了z是 共享 .

结果，我们最终得到一个类 A其中有纯值语义 , 但共享其成员 隐含 跨越相等的实例。 AFAIK 这种模式被称为 Flyweight或 别名 .

在我们进入问题之前，还有一个细节。项目中的大多数类都是使用 实现的粉刺 成语:

private:
  class Private;

  Private* p;

和类(class) A不是排除。这就是为什么实现上述方案的建议想法如下。

使用 共享指针至 A::Private而不是原始的
粉刺 成语;

有全局套共享指针 至 A::Private ;

在 A 的构造函数中检查是否有 共享
指针适合A::Private已经存在于集合中
(当然使用 x 和 y)，如果是，那么只需设置 p给它，否则创建 A::Private 的新实例并存储
共享指针在这个集合中，类似地设置 p给它；

A::Private的析构函数应该删除 共享指针至 this从集合。

这看起来是最直接和直观的实现。然而，问题在于，由于这个全局集合拥有一个 共享指针至 A::Private ，这意味着即使当对应 A 的所有实例被销毁，引用计数器将停留在 1 ，即它永远不会到达 0 ，因此内存永远不会被释放。

我想如果有一些 就好了共享指针 将提供一种设置引用计数器下限的方法。例如，在这种情况下，我只需将其设置为 1这意味着当它到达 1 时它释放了内存。不幸的是，我还没有在流行的库(Boost、Qt、Poco 等)中找到任何此类行为的实现。当然，我可以为我的问题进行手动引用计数，但这感觉不对，而且闻起来像是在重新发明轮子。

可能还有其他方法可以解决这个问题。期待您的建议。

注意:我想立即拦截任何建议将问题转化为 指针语义 我很清楚。我需要完全适用于上述方案的解决方案。

Answer 1

如果我正确理解您的设计问题是什么，那么我会让全局集包含弱的、非拥有的指针(例如 weak_ptr<> )，它们能够检查它们是否悬空，但它们不会增加引用计数。

std::vector<std::weak_ptr<Private>> _objects;

因此，当所有拥有对象的共享指针都被销毁时， 对象将是 也被摧毁**。

现在你的全局集合将留下一个悬空 weak_ptr<> ，但好处是你可以检查该指针是否指向一个活着的对象(使用 lock () 成员函数来获取一个可能为空的 shared_ptr<> 。如果不是，你赢了不要取消引用它:

// A simple, hypothetical loop through the collection of objects
// which does something, but checks whether the pointers are
// dangling before doing that something on a possibly dead object
// that would be Undefined Behavior)
std::for_each(_objects.begin(), _objecs.end(), [] (std::weak_ptr<Private> p) 
{
    std::shared_ptr<Private> sp = p.lock();
    if (sp != nullptr)
    {
        sp->callMember(); // For instance...
    }
});

如果您还想删除相应的 weak_ptr<>一旦对象被销毁，从集合中删除一个对象，那么您可以使用自定义删除程序。您的例程将在对象被销毁时被调用，并将传递指向该对象的指针:此时，在释放之前，您可以从集合中删除相应的元素。

例如，一个实例化类型为 A 的新对象的函数。并返回 shared_ptr它可以看起来像这样:

static std::shared_ptr<object> make_A()
{
    std::shared_ptr<Private> sp(
        new Private(),   // Instantiate the object
        [] (Private* p)  // Set up the custom deleter...
        {
            // Remove the corresponding element from the vector...
            _objects.erase(
                // ...so let's find that element!
                std::find_if( 
                    _objects.begin(),
                    _objects.end(),
                    [p] (std::weak_ptr<priv> wp)
                    {
                        // lock() will return a null pointer if wp is dangling
                        std::shared_ptr<priv> sp = wp.lock();

                        // In case wp is not dangling, return true if and only
                        // if it points to the object we're about to delete
                        return ((sp != nullptr) && (sp.get() == p));
                    })
                );
        });
}

这里我假设 C++11，你可以通过替换 std::shared_ptr<> 在 C++03 中轻松地做同样的事情。与 boost::shared_ptr<> , std::weak_ptr<>与 boost::weak_ptr<> , 以及带有正确定义仿函数的 lambda。

希望这可以帮助。