相关疑难解决方法(0)

我对大多数OO理论有了深刻的理解,但让我困惑的一件事是虚拟析构函数.

我认为无论什么以及链中的每个对象,析构函数总是会被调用.

你什么时候打算让它们成为虚拟的？为什么？

在最近实施零规则主题下的超载期刊中,作者描述了我们如何避免编写五个操作符规则,因为编写它们的原因是:

1. 资源管理
2. 多态删除

这两个都可以通过使用智能指针来处理.

在这里,我对第二部分特别感兴趣.

请考虑以下代码段:

class Base
{
public:
    virtual void Fun() = 0;
};


class Derived : public Base
{
public:

    ~Derived()
    {
        cout << "Derived::~Derived\n";
    }

    void Fun()
    {
        cout << "Derived::Fun\n";
    }
};


int main()
{
    shared_ptr<Base> pB = make_shared<Derived>();
    pB->Fun();
}

在这种情况下,正如文章的作者解释的那样,我们通过使用共享指针获得多态删除,这确实有效.

但是,如果我shared_ptr用a 替换unique_ptr,我不再能够观察到多态删除.

现在我的问题是,为什么这两种行为有所不同？为什么不shared_ptr照顾多态删除unique_ptr？

例如,我的一本书中的代码如下:

class HasPtr {
public:
    HasPtr(const HasPtr& h): ps(new std::string(*h.ps)), i(h.i) { }
    HasPtr(const std::string &s = std::string()): ps(new std::string(s)), i(0) { }
    HasPtr& operator=(const HasPtr&);
    ~HasPtr() { delete ps; }
private:
    std::string *ps;
    int i;
};

HasPtr& HasPtr::operator=(const HasPtr &rhs){
    auto newp = new string(*rhs.ps); // copy the underlying string
    delete ps; // free the old memory
    ps = newp; // copy data from rhs into this object
    i = rhs.i;
    return *this; // return this object
}

看起来像运营商的内部=可能只是: …