A question about memory leaks

#include <QList>
class MyType{
//This has some data开发者_运维百科 in it....
};

QList<MyType> f()
{
     QList<MyType> list;
     for(int i = 0; i<10; i++ )
     {
              MyType* item = new MyType();
              list << *item;
     }
     return list;
}

QList<MyType> temp_var = f();

When temp_var goes out of the scope and destroys, what happens to the items that we created and add to this list? Is there going to be any memory leaks?

Thank you.

Yes, there will be a memory leak. As a general rule, you must have one delete for each new in your program.

In your specific case, the faulty logic happens much earlier than temp_var's destruction. You allocate the items, and then store a copy of those items in the list. You should immediately destroy the original, no-longer-useful items.

Your for loop could be :

 for(int i = 0; i<10; i++ )
 {
          MyType* item = new MyType(); // get me an item.
          list << *item;  // put copy of item in list
          delete item; // destroy my item
 }

When expressed that way, it is obvious that we shouldn't use new at all!

for(int i = 0; i < 10; i++)
{
    MyType item;
    list << item;
}

This version won't leak, assuming that MyType doesn't have any memory-management bugs of its own.

QList<MyType*> f() // List of POINTERS
{
     QList<MyType*> list;
     for(int i = 0; i<10; i++ )
     {
              MyType* item = new MyType();
              list << item;  // Storing a POINTER
     }
     return list;
}

Then, yes, you would have had precisely the memory leak you expected. QList does not automatically provide delete on pointer types.

I don't see any point of using new in your code, as you're not storing the pointers in the list, rather copies of the object created with new, and you're not deleteing it. So yeah, there is memory-leak in the function itself.

Seeing that QList is not a list of pointers, I can say that you shouldn't use new in your code:

QList<MyType> f()
{
     QList<MyType> list; //note : its not a list of MyType*
     for(int i = 0; i<10; i++ )
     {
              MyType item; //automatic variable
              list << item;
     }
     return list; 
}

When a QList gets destroyed / goes out of scope, it destroys its content with it. In your case, the content is made of copies of your objects (built from the implicit copy-constructor), not the objects themselves. The memory will leak in each iteration of the for-loop since the original object created by new MyType() will lose its pointer, but will remain allocated.

There certainly will be a leak if it you don't delete all of those items you created with new MyType()!

In the destructor for QList you need to go through the list and call delete on each of those items.