将C对象数组封装为C++类：operator[]返回值选型困惑

这确实是封装C不透明对象数组时非常典型的痛点——既要避免返回的对象错误释放数组元素，又不想为了所有权差异写大量重复代码。我给你分享两个经过实践验证的解决方案：

方案一：基类封装核心逻辑，派生所有权类和引用类 #

把所有和Opaque*交互的核心操作抽离到一个基类中，然后分别派生出独占所有权的Foo类和仅引用的FooRef类。这样核心逻辑只写一次，完全避免重复代码：

// 基类：封装所有共享操作，不处理所有权
class FooBase {
protected:
    Opaque* ptr;
    explicit FooBase(Opaque* p) : ptr(p) {}
public:
    // 在这里实现所有Foo的业务操作，比如：
    void do_something() { foo_do_something(ptr); }
    int get_value() { return foo_get_value(ptr); }

    // 禁止拷贝赋值，避免指针所有权混乱
    FooBase(const FooBase&) = delete;
    FooBase& operator=(const FooBase&) = delete;
};

// 独占所有权的Foo类：负责在析构时释放对象
class Foo : public FooBase {
public:
    explicit Foo(Opaque* p) : FooBase(p) {}
    ~Foo() { if (ptr) foo_delete(ptr); }

    // 支持移动语义，转移所有权
    Foo(Foo&& other) noexcept : FooBase(other.ptr) {
        other.ptr = nullptr;
    }
    Foo& operator=(Foo&& other) noexcept {
        if (this != &other) {
            if (ptr) foo_delete(ptr);
            ptr = other.ptr;
            other.ptr = nullptr;
        }
        return *this;
    }
};

// 仅引用的FooRef类：不负责释放对象
class FooRef : public FooBase {
public:
    explicit FooRef(Opaque* p) : FooBase(p) {}
    ~FooRef() = default; // 析构什么都不做

    // 允许拷贝，因为只是引用对象
    FooRef(const FooRef&) = default;
    FooRef& operator=(const FooRef&) = default;
};

然后你的FooArray就可以安全地返回FooRef了：

class FooArray {
private:
    std::vector<Opaque*> elements;
    // 这里可以添加数组的创建、扩容等逻辑，比如从C库加载数组
public:
    // 返回引用，不会触发对象释放
    FooRef operator[](size_t index) {
        return FooRef(elements[index]);
    }

    // const版本的operator[]
    const FooRef operator[](size_t index) const {
        return FooRef(elements[index]);
    }

    // 数组自身负责释放所有元素
    ~FooArray() {
        for (auto p : elements) {
            foo_delete(p);
        }
    }
};

方案二：用模板参数控制所有权 #

如果你更喜欢更紧凑的代码，可以用模板参数来控制是否在析构时释放对象，这样只需要写一个模板类就能同时实现所有权和引用两种语义：

template<bool Owns>
class FooImpl {
private:
    Opaque* ptr;
public:
    explicit FooImpl(Opaque* p) : ptr(p) {}

    // 用constexpr条件判断是否释放对象
    ~FooImpl() {
        if constexpr (Owns) {
            if (ptr) foo_delete(ptr);
        }
    }

    // 共享的业务操作
    void do_something() { foo_do_something(ptr); }
    int get_value() { return foo_get_value(ptr); }

    // 移动语义：所有权版本需要转移指针，引用版本直接拷贝指针
    FooImpl(FooImpl&& other) noexcept : ptr(other.ptr) {
        if constexpr (Owns) {
            other.ptr = nullptr;
        }
    }
    FooImpl& operator=(FooImpl&& other) noexcept {
        if (this != &other) {
            if constexpr (Owns) {
                if (ptr) foo_delete(ptr);
                ptr = other.ptr;
                other.ptr = nullptr;
            } else {
                ptr = other.ptr;
            }
        }
        return *this;
    }

    // 拷贝语义：仅非所有权版本允许拷贝
    FooImpl(const FooImpl&) requires (!Owns) = default;
    FooImpl& operator=(const FooImpl&) requires (!Owns) = default;
};

// 类型别名，让代码更直观
using Foo = FooImpl<true>;
using FooRef = FooImpl<false>;

这个方案和方案一的效果完全一致，只是用模板替代了继承，代码更紧凑，适合对模板熟悉的开发者。

总结 #

两种方案都完美解决了你的问题：

• FooArray::operator[]返回FooRef（或FooImpl<false>），不会错误释放数组元素
• 核心逻辑只写一次，不会产生重复代码

我个人更推荐方案一，因为继承的方式更直观，团队里的其他开发者更容易理解和维护；如果你的团队对C++模板很熟悉，方案二的紧凑代码会更讨喜。

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