复合模式+继承场景下指针管理困惑及C++11最佳实践咨询

我正在设计一个用于判断Point是否处于几何对象定义的边界内/外的模块，为此定义了如下基类：

#pragma once

#include "Point.h"

class IBound
{
    public:
    virtual bool isInside(const Point& point) const = 0;
    virtual ~IBound() {}
};

为实现判断点是否同时处于多个边界内、且不在其他边界内的需求，我创建了GeometricBoundaries类：

#pragma once

#include "IBound.h"

using BoundariesList = std::vector<IBound*>;

class GeometricBoundaries : public IBound
{
    public:
    GeometricBoundaries(const BoundariesList& boundaries_to_include, const BoundariesList& boundaries_to_exclude)
    : m_boundaries_to_include(boundaries_to_include), m_boundaries_to_exclude(boundaries_to_exclude) {}

    bool isInside(const Point& point) const override;

    /*
        因为要持有原始指针，不希望该对象被频繁传递。
        删除拷贝构造/赋值运算符可以确保该对象无法被拷贝或移动
    */
    GeometricBoundaries(const GeometricBoundaries&) = delete;
    GeometricBoundaries& operator=(const GeometricBoundaries&) = delete;

    private:
    const BoundariesList m_boundaries_to_include;
    const BoundariesList m_boundaries_to_exclude;
};

创建GeometricBoundaries对象的示例代码如下：

IBound* square_inc = new Square(...);
IBound* square_exc = new Square(...);
IBound* ellipse_inc = new Ellipse(...);
IBound* circle_exc = new Circle(...);

GeometricBoundaries geometric_boundaries(BoundariesList{square_inc, ellipse_inc}, BoundariesList{square_exc, circle_exc});

我选择使用原始指针而非智能指针，是因为仅需要多态特性，不需要引用计数，但发现存在GeometricBoundaries与内部指针生命周期不匹配的问题，可能导致内存泄漏或未定义行为。我尝试通过删除拷贝/移动构造函数让GeometricBoundaries尽可能"短命"，但不确定这种做法是否正确。作为C新手，想了解C11下该结构的安全使用最佳实践。

1. 明确指针所有权，优先使用智能指针解决生命周期问题 #

你担心智能指针的引用计数开销，但C++11的std::shared_ptr和std::unique_ptr在现代编译器下的开销极小，完全可以忽略。更重要的是，它们能彻底解决生命周期不匹配的问题：

• 如果GeometricBoundaries需要拥有这些边界对象的所有权（即负责销毁它们），使用std::vector<std::unique_ptr<IBound>>来存储。这样当GeometricBoundaries销毁时，所有内部的边界对象会自动被释放，避免内存泄漏。
• 如果GeometricBoundaries不需要所有权（边界对象由外部管理），则使用std::vector<std::weak_ptr<IBound>>或者继续用原始指针，但必须严格保证GeometricBoundaries的生命周期短于所有内部指向的边界对象。

修改后的GeometricBoundaries示例（使用unique_ptr）：

#include "IBound.h"
#include <memory>
#include <vector>

using BoundariesList = std::vector<std::unique_ptr<IBound>>;

class GeometricBoundaries : public IBound
{
public:
    // 使用移动语义传递unique_ptr，避免拷贝开销
    GeometricBoundaries(BoundariesList&& include, BoundariesList&& exclude)
        : m_include(std::move(include)), m_exclude(std::move(exclude)) {}

    bool isInside(const Point& point) const override
    {
        // 检查所有包含边界：点必须在所有包含边界内
        for (const auto& bound : m_include)
        {
            if (!bound->isInside(point))
                return false;
        }
        // 检查所有排除边界：点必须不在任何排除边界内
        for (const auto& bound : m_exclude)
        {
            if (bound->isInside(point))
                return false;
        }
        return true;
    }

    // unique_ptr默认不支持拷贝，所以拷贝构造/赋值会被自动禁用，无需手动删除
private:
    BoundariesList m_include;
    BoundariesList m_exclude;
};

创建对象的代码也需要调整为：

auto square_inc = std::make_unique<Square>(...);
auto square_exc = std::make_unique<Square>(...);
auto ellipse_inc = std::make_unique<Ellipse>(...);
auto circle_exc = std::make_unique<Circle>(...);

GeometricBoundaries boundaries(
    {std::move(square_inc), std::move(ellipse_inc)},
    {std::move(square_exc), std::move(circle_exc)}
);

2. 若坚持使用原始指针，严格约束生命周期 #

如果确实不想用智能指针，必须遵守以下规则：

• 确保所有传递给GeometricBoundaries的边界对象，其生命周期长于GeometricBoundaries实例。比如可以将边界对象声明在GeometricBoundaries之前，且在GeometricBoundaries销毁后再销毁边界对象。
• 不要在GeometricBoundaries内部尝试销毁这些原始指针，避免重复释放。
• 手动删除拷贝/移动构造函数是合理的，因为拷贝会导致多个GeometricBoundaries实例指向同一批原始指针，进一步增加生命周期管理的复杂度。

3. 考虑使用值语义或引用传递替代指针 #

如果你的边界对象不需要多态（或者可以通过其他方式实现多态，比如变体），可以直接存储对象而非指针，这样完全避免指针生命周期问题。但如果必须使用多态，智能指针仍是最优解。

内容的提问来源于stack exchange，提问作者IEatBagels