c++ - 指针和抽象类

Question

struct Abstract{
    virtual void methodA() = 0;
};

struct Test : public Abstract{
    virtual void methodA(){
        printf("Test message");
    }
};

class Foo{
    Abstract* abs; //I made it this way so that an instance of Foo 
                   //can easily switch between any class that implements 
                   //Abstract
public:
    virtual ~Foo(){
        delete abs; //free abs
    }

    void setAbs(Abstract* a){
        abs = a; //is there any other way to do this?
    }

    void changeAbs()//method to switch abs

    void show(){
        abs->methodA();
    }
};

int main(){
    Test *test = new Test();
//    Test test; //local instantiation will throw a segmentation fault
               //because abs is freed in the desctructor of Foo
    Foo foo;
    foo.setAbs(test);
    foo.show();

//    delete test; //using a pointer is fine unless freed
    return 0;
}

我的担忧是:

1. 如果我不在析构函数中释放 abs 并且用户忘记释放他实现 Abstract 的对象，或者如果用户这样做 setAbs(new Test()) ，就会有泄漏。

2. 如果我在析构函数中释放 abs，如果用户在本地实例化 Test 或他使用指针并最终自行删除它，它将引发段错误。

3. Abstract abs 也是不允许的，因为它是一个抽象类

我想把 setAbs() 改成这样:

void setAbs(Abstract* a){
    abs = new Abstract(*a); //but copying like a normal class doesn't work on abstract classes
}  

我的问题是，是否有任何其他方法可以实现 setAbs() 以便复制传递的参数？

如果没有其他办法，我会让释放成为用户的工作。

Answer 1

这里的根本问题是您没有明确说明谁拥有此内存。

如果你的类拥有它，那么在你的析构函数中释放它是安全的。好吧，不是你写的方式，而是理论上。继续阅读 The Rule of Three .

如果您的类不拥有该指针，那么请不要释放它。释放不是您的，所以请使用它，不要再做任何事情。

处理内存的安全方法是隐式执行关于谁负责什么的契约。如果用户继续删除您的指针，那么告诉他们停止；这不关他们的事。您可以使用 std::unique_ptr 指针和 get() 函数来执行相同的操作。类(class)不会阻止你，怎么可能呢？它不在乎你是否射击自己的脚。 RTFM。

说到 std::unique_ptr...你为什么不使用它(或者 std::shared_ptr 如果合适的话)？这是一个已解决的问题，无需在这里提出自己的解决方案。