Question

我对这个概念不熟悉所以不要对我这么难。为什么这段代码不会产生析构函数调用？类的名称是不言自明的。 SString将在~SString（）中打印一条消息。它只打印一个析构函数消息。

int main(int argc, TCHAR* argv[])
{
smart_ptr<SString> smt(new SString("not lost"));
 new smart_ptr<SString>(new SString("but lost")); 
return 0;
}

这是内存泄漏吗？ impl。 for smart_ptr来自here

编辑：

//copy ctor
    smart_ptr(const smart_ptr<T>& ptrCopy) 
    {
        m_AutoPtr = new T(ptrCopy.get());
    }
    //overloading = operator
    smart_ptr<T>& operator=(smart_ptr<T>& ptrCopy) 
    {
        if(m_AutoPtr)
            delete m_AutoPtr;
        m_AutoPtr = new T(*ptrCopy.get());
        return *this;
    }

Answer 1

通过new smart_ptr<SString>(new SString("but lost"));，您将创建一个新的，动态分配的智能指针。您不会将分配结果（指向shared_ptr的指针）存储到任何地方，它悬空...因为您不存储结果，所以您也无法调用{ {1}}因为它 - 因此它的析构函数不会被调用，反过来也不会调用所包含对象的SString析构函数！

如果您尝试

delete

相反，您将看到针对此案例调用的析构函数。

但是，SString没有合理使用。创建了smart_ptr<SString> *p = new smart_ptr<SString>(new SString("but lost")); delete p;，以便不需要手动调用smart_ptr;因此，不要那样使用它们;在你的第一个声明中使用它们！

Answer 2

智能指针的意思是你应该只有自动智能指针对象：

{
    smart_ptr<Foo> p(new Foo);
}
// bye bye Foo

然而，你的第二行创建了一个动态智能指针，它的生命永无止境！因此，它永远不会有机会摧毁它负责的对象。

您必须手动删除智能指针本身，以便它可以反过来清理对象：

auto sp = new smart_ptr<Foo>(new Foo);
//                           ^^^^^^^
//        ^^^^^^^^^^^^^^           +------< dynamic Foo, handled by the SP
//                     |
//                     +---------------< dynamic smart pointer, handled by YOU

delete sp;

Answer 3

是的，智能点本身已泄露。（以及它所引用的任何内容）。

我想不出new智能指针的好理由......

Answer 4

是的，这是一个内存泄漏，你正在泄漏第二个智能指针及其内容。

原因是第一个智能指针是在堆栈上创建的，因此它的生命周期范围限定在它声明的块中，之后它将被自动销毁。

第二个是在堆上创建的，这意味着它将一直存在，直到你用delete销毁它，此时将调用它的析构函数（并且使用它SString的析构函数保持）。

可能的内存泄漏？

4 个答案: