Question

I have two examples I have a question about. Let me explain via some code:

Question 1:

QStringList qsl(); // Create a list and store something in it
qsl << "foo";
QString test = "this is a test"; 
qsl = test.split(" ", QString::SkipEmptyParts); // Memory Leak?

What happens when I re-assign the qsl variable what happens to “foo” and the original data allocated on the first line?

Question 2:

class Foo
{
     QStringList mylist;
     void MyFunc(QStringList& mylist)
     {
           this->m_mylist = mylist;

     }

     void AddString(QString str)
     {
         mylist << str;
     }



}

int main()
{
    Foo f;
    QStringList *qsl = new QStringList();
    f.MyFunc(*qsl);
    delete qsl;
    f.AddString("this is a test"); // Segfault?
}

Here I’m passing a list by reference to a class which is then stored in said class. I then delete the original object.

It basically all comes down to what happens when you assign a QObject to a QObject. I assume a copy of the object is made, even if the object was passed in via reference (not via pointer of course, that would just be a pointer copy).

I also assume that something like QStringList performs a deepcopy…is this correct?

Answer 1

Assigning to a QStringList variable works the same as assigning to any other variable in C++. For objects, the assignment operator of the object on the left is called to copy the content of the object on the right into the object on the left. Usually this does just a memberwise assignment:

struct A {
  int x;
  QString y;

  A& operator=(const A &other) {
    // do the assignment:
    x = other.x;
    y = other.y;

    return *this;
  }
};

The object on the left of the assignment “adapts itself” to contain the same things as the object on the right. There is no new object allocated, just the existing one is modified.

If the class is more complicated and for example contains pointers to dynamically allocated data (like it is probably is the case for QStringList), the assignment operator might be more complicated to implement. But this is an implementation detail of the QStringList class and you should not have to worry about that. The QStringList object on the left of the assignment will be modified to be equal to the object on the right.

In Question 2 you assign an object to a member variable, which causes the object in the member variable to be modified so that it contains the same things as the object that is assigned to it. That this other object later is deleted doesn’t matter to the member variable.

Semantically this is the same as when assigning simple integers:

int i, j;
i = j;

The memory where i is stored is modified, so that it contains the same value as j. What happens to j later on doesn’t matter to the value of i.