可能的内存泄漏？

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来自 这里

编辑:

//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的SString任何地方,它的悬挂)......因为你不存储结果,你也不能说delete好了-所以的析构函数不会被调用,反过来也SString不会调用包含对象的析构函数!

如果你试试

smart_ptr<SString> *p = new smart_ptr<SString>(new SString("but lost")); 
delete p;

相反,你会看到也为这种情况调用的析构函数.

但是,这没有明智的用途smart_ptr.smart_ptr创建的,因此,你不要需要调用delete手动; 因此,不要那样使用它们; 在你的第一个声明中使用它们!

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智能指针的好理由......