blocks|key|682545|text|在创建object2时，您正在创建使用new创建的对象的副本，但是您也丢失了(从未分配的)指针(因此以后无法删除它)。为了避免这种情况，您必须将object2作为引用。|type|unstyled|depth|inlineStyleRanges|offset|length|style|CODE|entityRanges|data|682546|entityMap^0|3|7|20|7|0^^$0|@$1|2|3|4|5|6|7|H|8|@$9|I|A|J|B|C]|$9|K|A|L|B|C]]|D|@]|E|$]]|$1|F|3|-4|5|6|7|M|8|@]|D|@]|E|$]]]|G|$]]

When creating <code>object2</code> you're creating a copy of the object you created with new, but you're also losing the (never assigned) pointer (so there's no way to delete it later on). To avoid this, you'd have to make <code>object2</code> a reference.

blocks|key|466625|text|这行代码马上就会泄露出来：|type|unstyled|depth|inlineStyleRanges|entityRanges|data|466626|B+object2+=+*(new+B());|code-block|syntax|javascript|466627|在这里，您将在堆上创建一个新的B对象，然后在堆栈上创建一个副本。在堆上分配的那个不能再被访问，因此发生了泄漏。|offset|length|style|CODE|466628|这行代码不会立即泄漏：|466629|A+*object1+=+new+A();|466630|但是，如果你从来不使用deleted+object1，就会有漏洞。|466631|entityMap^0|0|0|F|1|0|0|0|B|6|J|7|0^^$0|@$1|2|3|4|5|6|7|U|8|@]|9|@]|A|$]]|$1|B|3|C|5|D|7|V|8|@]|9|@]|A|$E|F]]|$1|G|3|H|5|6|7|W|8|@$I|X|J|Y|K|L]]|9|@]|A|$]]|$1|M|3|N|5|6|7|Z|8|@]|9|@]|A|$]]|$1|O|3|P|5|D|7|10|8|@]|9|@]|A|$E|F]]|$1|Q|3|R|5|6|7|11|8|@$I|12|J|13|K|L]|$I|14|J|15|K|L]]|9|@]|A|$]]|$1|S|3|-4|5|6|7|16|8|@]|9|@]|A|$]]]|T|$]]

It's this line that is immediately leaking:

<pre><code>B object2 = *(new B());
</code></pre>

Here you are creating a new <code>B</code> object on the heap, then creating a copy on the stack. The one that has been allocated on the heap can no longer be accessed and hence the leak.

This line is not immediately leaky:

<pre><code>A *object1 = new A();
</code></pre>

There would be a leak if you never <code>delete</code>d <code>object1</code> though.

blocks|key|682717|text|那么，如果您在某些时候没有通过将指向内存的指针传递给delete操作符来释放使用new操作符分配的内存，则会造成内存泄漏。|type|unstyled|depth|inlineStyleRanges|offset|length|style|CODE|entityRanges|data|682718|在上面的两种情况下：|682719|A+*object1+=+new+A();|code-block|syntax|javascript|682720|这里您没有使用delete来释放内存，所以如果您的object1指针超出了作用域，您将会有一个内存泄漏，因为您将丢失指针，因此不能对其使用delete操作符。|682721|还有这里|682722|B+object2+=+*(new+B());|682723|您正在丢弃由new+B()返回的指针，因此永远不能将该指针传递给delete以释放内存。因此发生了另一次内存泄漏。|682724|entityMap^0|Q|6|14|3|0|0|0|7|6|P|7|1X|6|0|0|0|6|7|W|6|0^^$0|@$1|2|3|4|5|6|7|W|8|@$9|X|A|Y|B|C]|$9|Z|A|10|B|C]]|D|@]|E|$]]|$1|F|3|G|5|6|7|11|8|@]|D|@]|E|$]]|$1|H|3|I|5|J|7|12|8|@]|D|@]|E|$K|L]]|$1|M|3|N|5|6|7|13|8|@$9|14|A|15|B|C]|$9|16|A|17|B|C]|$9|18|A|19|B|C]]|D|@]|E|$]]|$1|O|3|P|5|6|7|1A|8|@]|D|@]|E|$]]|$1|Q|3|R|5|J|7|1B|8|@]|D|@]|E|$K|L]]|$1|S|3|T|5|6|7|1C|8|@$9|1D|A|1E|B|C]|$9|1F|A|1G|B|C]]|D|@]|E|$]]|$1|U|3|-4|5|6|7|1H|8|@]|D|@]|E|$]]]|V|$]]

Well, you create a memory leak if you don't at some point free the memory you've allocated using the <code>new</code> operator by passing a pointer to that memory to the <code>delete</code> operator. 

In your two cases above: 

<pre><code>A *object1 = new A();
</code></pre>

Here you aren't using <code>delete</code> to free the memory, so if and when your <code>object1</code> pointer goes out of scope, you'll have a memory leak, because you'll have lost the pointer and so can't use the <code>delete</code> operator on it.

And here

<pre><code>B object2 = *(new B());
</code></pre>

you are discarding the pointer returned by <code>new B()</code>, and so can never pass that pointer to <code>delete</code> for the memory to be freed. Hence another memory leak.

blocks|key|466813|text|B+object2+=+*(new+B());|type|code-block|depth|inlineStyleRanges|entityRanges|data|syntax|javascript|466814|这条线是泄漏的原因。让我们把这个拆分一下..|unstyled|466815|object2是一个B类型的变量，存储在地址1(是的，我在这里选择任意的数字)。在右边，你请求一个新的B，或者一个指向B类型对象的指针。程序很乐意给你这个，并将你的新B赋值给地址2，还在地址3中创建了一个指针。现在，访问地址2中数据的唯一方法是通过地址3中的指针。接下来，使用*解除对指针的引用，以获得指针所指向的数据(地址2中的数据)。这将有效地创建该数据的副本，并将其分配给地址1中分配的object2。请记住，它是副本，而不是原始数据。|offset|length|style|CODE|466816|现在，问题来了：|466817|实际上，您从未将该指针存储在任何您可以使用它的地方！一旦这个赋值完成，指针(你用来访问address2的address3中的内存)就超出了你的作用域并且超出了你的能力范围！您不能再对它调用delete，因此不能清除address2中的内存。剩下的是address1中来自address2的数据的一个副本。两个相同的东西存在于记忆中。一个是您可以访问的，另一个是您不能访问的(因为您丢失了它的路径)。这就是为什么这是一个内存泄漏。|466818|我建议你从你的C#背景出发，阅读大量关于C%2B%2B中指针是如何工作的知识。它们是一个高级主题，可能需要一些时间才能掌握，但它们的使用对您来说将是无价的。|466819|entityMap^0|0|0|3U|1|0|0|0|0^^$0|@$1|2|3|4|5|6|7|U|8|@]|9|@]|A|$B|C]]|$1|D|3|E|5|F|7|V|8|@]|9|@]|A|$]]|$1|G|3|H|5|F|7|W|8|@$I|X|J|Y|K|L]]|9|@]|A|$]]|$1|M|3|N|5|F|7|Z|8|@]|9|@]|A|$]]|$1|O|3|P|5|F|7|10|8|@]|9|@]|A|$]]|$1|Q|3|R|5|F|7|11|8|@]|9|@]|A|$]]|$1|S|3|-4|5|F|7|12|8|@]|9|@]|A|$]]]|T|$]]

<pre><code>B object2 = *(new B());
</code></pre>

This line is the cause of the leak. Let's pick this apart a bit..

object2 is a variable of type B, stored at say address 1 (Yes, I'm picking arbitrary numbers here). On the right side, you've asked for a new B, or a pointer to an object of type B. The program gladly gives this to you and assigns your new B to address 2 and also creates a pointer in address 3. Now, the only way to access the data in address 2 is via the pointer in address 3. Next, you dereferenced the pointer using <code>*</code> to get the data that the pointer is pointing to (the data in address 2). This effectively creates a copy of that data and assigns it to object2, assigned in address 1. Remember, it's a COPY, not the original.

Now, here's the problem:

You never actually stored that pointer anywhere you can use it! Once this assignment is finished, the pointer (memory in address3, which you used to access address2) is out of scope and beyond your reach! You can no longer call delete on it and therefore cannot clean up the memory in address2. What you are left with is a copy of the data from address2 in address1. Two of the same things sitting in memory. One you can access, the other you can't (because you lost the path to it). That's why this is a memory leak.

I would suggest coming from your C# background that you read up a lot on how pointers in C++ work. They are an advanced topic and can take some time to grasp, but their use will be invaluable to you.

blocks|key|466891|text|如果这能让事情变得更简单，那么可以把计算机内存想象成一家酒店，而程序就是客户，他们会在需要的时候租用房间。|type|unstyled|depth|inlineStyleRanges|entityRanges|data|466892|这家旅馆的运作方式是，你订一间房，然后告诉行李员你什么时候离开。|466893|如果你预定了一个房间，没有告诉行李员就离开了，行李员会认为这个房间还在使用，不会让其他人使用它。在这种情况下，有一个房间漏水。|466894|如果你的程序分配内存而不删除它(它只是停止使用它)，那么计算机就认为内存仍在使用中，不允许其他任何人使用它。这是一个内存泄漏。|466895|这不是一个确切的类比，但它可能会有所帮助。|466896|entityMap^0|0|0|0|0|0^^$0|@$1|2|3|4|5|6|7|L|8|@]|9|@]|A|$]]|$1|B|3|C|5|6|7|M|8|@]|9|@]|A|$]]|$1|D|3|E|5|6|7|N|8|@]|9|@]|A|$]]|$1|F|3|G|5|6|7|O|8|@]|9|@]|A|$]]|$1|H|3|I|5|6|7|P|8|@]|9|@]|A|$]]|$1|J|3|-4|5|6|7|Q|8|@]|9|@]|A|$]]]|K|$]]

If it makes it easier, think of computer memory as being like a hotel and programs are customers who hire rooms when they need them.

The way this hotel works is that you book a room and tell the porter when you are leaving.

If you program books a room and leaves without telling the porter the porter will think that the room is still is use and will not let anyone else use it. In this case there is a room leak.

If your program allocates memory and does not delete it (it merely stops using it) then the computer thinks that the memory is still in use and will not allow anyone else to use it. This is a memory leak.

This is not an exact analogy but it might help.

I learned C# first, and now I'm starting with C++. As I understand, operator <code>new</code> in C++ is not similar to the one in C#.

Can you explain the reason of the memory leak in this sample code?

<pre><code>class A { ... };
struct B { ... };

A *object1 = new A();
B object2 = *(new B());
</code></pre>

Why does the use of 'new' cause memory leaks?

我首先学习了C#，现在我从C++开始。据我所知，C++中的运算符new与C#中的运算符不同。你能解释一下这个示例代码中内存泄漏的原因吗？class A { ... };struct B { ... };A *object1 = new A();B object2 = *(new B());

问为什么使用'new‘会导致内存泄漏？
EN

社区

活动

资源

关于

腾讯云开发者

热门产品

热门推荐

更多推荐

问为什么使用'new‘会导致内存泄漏？EN

社区

活动

资源

关于

腾讯云开发者

热门产品

热门推荐

更多推荐

问为什么使用'new‘会导致内存泄漏？
EN