C++ 如何使用多重继承处理资源管理？

假设我有一个基类和一些派生类：

class Base1
{
public:
    virtual ~Base1() {}
    virtual void update() = 0;
};

class Derive1 : public Base1
{
public:
    void update() override {/*...*/}
};

class Derive2 : public Base1
{
public:
    void update() override {/*...*/}
};

以及管理派生对象的位置：

class Base1Manager
{
public:
    void add(Base1* p)
    {
        objs.push_back(p);
    }
    void update()
    {
        std::for_each(objs.begin(), objs.end(), [](Base1* p) { p->update(); });
    }
    void clear()
    {
        std::for_each(objs.begin(), objs.end(), [](Base1* p) { delete p; });
        objs.clear();
    }
    std::vector<Base1*> objs;
};

Base1Manager bm1;
bm1.add(new Derive1());
bm1.add(new Derive2());

最后，我必须在程序退出时释放资源：

bm1.clear();

上面的场景可以，但下一个场景不行：

---

问题是当我添加另一个基类并扩展我的派生类时：

class Base1
{
public:
    virtual ~Base1() {}
    virtual void update() = 0;
};

class Derive1 : public Base1
{
public:
    void update() override {/*...*/}
};

class Derive2 : public Base1
{
public:
    void update() override {/*...*/}
};

注意：根据这个答案： [，第3点和第4点，my

Base1

和

Base2

是不同的概念，因此多重继承在这里应该很好。

class Base1
{
public:
    virtual ~Base1() {}
    virtual void update() = 0;
};

class Base2
{
public:
    virtual ~Base2() {}
    virtual void do_different_thing() = 0;
};

class Derive1 : public Base1, public Base2
{
public:
    void update() override {/*...*/}
    void do_different_thing() override {/*...*/}
};

class Derive2 : public Base1, public Base2
{
public:
    void update() override {/*...*/}
    void do_different_thing() override {/*...*/}
};

还可以想象有一个新的

Base2Manager

，基本上与

Base1Manager

相同

最后，我的问题是，如何正确释放资源？

显然，我不能发布两次：

bm1.clear();
bm2.clear();

我只需要选择一个经理，让它来做这项工作，但这两个经理是分开的，彼此不认识，那么如何正确处理呢

---

智能指针会有帮助吗？我是否应该添加一个API，比如

addButNotRelase（Base2*p）

，这样我就可以操作

p

，但不能拥有

p

（比如将

p

放在

向量中，而不是
objs
？
std:：shared\u ptr
在这里有帮助，因为两位经理都拥有（可能相同的）指针

在第一个示例中，仅使用一个管理器，您可能已将
std:：shared_ptr
替换为
std:：unique_ptr

如果其他类必须拥有该对象才能控制生存期，则可以在管理器中使用简单指针

用法应该如下所示：

// The container
std::vector<std::shared_ptr<Base1>> base1s;
std::vector<std::shared_ptr<Base2>> base2s;

// The objects
std::shared_ptr<Derive1> d1 = std::make_shared<Derive1>();
std::shared_ptr<Derive2> d2 = std::make_shared<Derive2>();

// Feed the containers
base1s.push_back(d1);
base1s.push_back(d2);

base2s.push_back(d1);
base2s.push_back(d2);

//容器
std：：矢量基1s；
std：：矢量基2；
//物体
std:：shared_ptr d1=std:：make_shared（）；
std:：shared_ptr d2=std:：make_shared（）；
//喂容器
基底1。推回（d1）；
base1s.推回（d2）；
底座2。推回（d1）；
base2s.推回（d2）；
调用只清除一次是否真的会导致任何问题？这看起来像是共享所有权，应该适合
std:：shared\u ptr
。或者，如果
shared\u ptr
不合适，您可以滚动自己的引用计数。@user2040251问题是这些管理者彼此不认识，所以决定谁应该拥有这些资源有点棘手资源。如果我更改为
vector
和
vector
，如何将
new-Derive1（）
分配给它们作为共享内存？我尝试了
Derive1*d=new-Derive1（）；shared_ptr p1（d）；
但未能执行
shared_ptr p2（p1）
，因为它们是不同的类型。如果我尝试了
shared_ptr p2（d）
然后
p1
和
p2
没有共享。@MarsonMao：添加了使用示例。很好，这一个很好，我必须了解有关智能指针的更多信息，谢谢！；）