Question

考虑以下课程：

struct MyClass {
    int mId;
    MyClass(int id): mId(id) {}
   ~MyClass() { std::cout << "deleting: " << mId << std::endl; }
};

用法：

std::shared_ptr<MyClass> p(new MyClass(0));
MyClass& m = *p;
m = MyClass(2);

结果是：

deleting: 2
deleting: 2

请帮助我理解：

为什么有两个MyClass(2)个对象（在析构函数日志中做出假设）
这是内存泄漏吗？ MyClass(0)不应泄漏吗？

谢谢。

Answer 1

没有内存泄漏。这段代码：

m = MyClass(2);

创建一个MyClass类型的临时对象，使用m的（默认生成的）复制赋值运算符将其复制到MyClass，然后进行破坏。最终，p超出范围，其析构函数会销毁MyClass实例作为点（绑定到m的实例）。

如果我们明确地拼写出所有隐式调用，就会发生这种情况：

// std::shared_ptr<MyClass> p(new MyClass(0));
tmp1.MyClass(0);
p.shared_ptr(&tmp1);

// MyClass& m = *p;
p.operator* ();

// m = MyClass(2);
tmp2.MyClass(2);
m.operator= (tmp2);
tmp2.~MyClass();

// p goes out of scope
p.~shared_ptr();
tmp1.~MyClass();

Answer 2

这样做可以更清晰地了解创造破坏：

struct MyClass {
    int mId;
    MyClass(int id): mId(id) {std::cout << "Creating: " << this << "(" << mId << ")\n";}
   ~MyClass()                {std::cout << "Deleting: " << this << "(" << mId << ")\n";}
    MyClass(MyClass const& c)
                             {std::cout << "Copy:     " << this << "(" << mId << ")\n"
                                           "    From: " << &c   << "(" << c.mId << ")\n";
                              mId=c.mId;
                             }
    MyClass& operator=(MyClass const& c)
                             {std::cout << "Assign:   " << this << "(" << mId << ")\n"
                                           "    From: " << &c   << "(" << c.mId << ")\n";
                              mId=c.mId;
                             }
};

当我跑步时，我得到：

Creating: 0x7fc741c000e0(0)
Creating: 0x7fff50ac38c0(2)
Assign:   0x7fc741c000e0(0)
    From: 0x7fff50ac38c0(2)
Deleting: 0x7fff50ac38c0(2)
Deleting: 0x7fc741c000e0(2)

分配解除引用的shared_ptr

2 个答案: