Class and pointer to pointer

[GaPe]

Hi!

I have a few questions about ** (pointer to pointer).

Let's say I have a class named Activity.

I would code it like this ...

int tableLength = 3; // 2 from before and 1 new
Activity **newTable = new Activity*[tableLength]; // 3 activities in newTable => is this correct?
// now add old activities into a new table
for (int i = 0; i < tableLength - 1; i++)
{
  Activity *act = getActivity(i); // getActivity(i) returns Activity*
  memmove(newTable[i], act, sizeof(Activity*)); // is this correct?
  // is this correct =>> newTable[i] = act;?
  delete []act; // is this correct?
  act = NULL;
}
// and add a new one
memmove(newTable[tableLength - 1], act, sizeof(Activity*)); // is this correct?
// some code where I use the newTable

// and than free - is this correct?
for (int i = 0; i < tableLength; i++)
{
  delete []newTable[i];
  newTable[i] = NULL;
}
delete []newTable;
newTable = NULL;

So, please take a look at the code and tell me what am I doing wrong.

Thanks!

[Kenki]

The = operator should work just fine. Which delete operator to use depends on which new operator you allocated with, ie if you allocated with new [], then free with delete [].

The only obvious error I can see after a quick look is that you assign the value of a freed 'act' to 'newTable[tableLength - 1]', right under the first for loop. I'm not sure what it is you want to do there, but I'm quite certain it does not involve assigning a pointer you're going to use to invalid memory...

[edit] Another thing, if you use the assignment operator, you should not delete the 'act' pointer, because the 'newTable[something]' pointer will be pointing to the same memory, which will be freed when you free the table, anyaway.[/edit]

[7stud]

Activity **newTable = new Activity*[tableLength]; // 3 activities in newTable => is this correct?

I may just be a semanic quibble, but no it is not right. The only thing in newTable is the address in memory where an array is located. newTable is said "to point" to that array. The array contains 3 Activity pointers, which means that each of them can be made to point to an Activity object (or an array of Activity objects).

Activity *act = getActivity(i); // getActivity(i) returns Activity*

Is getActivity() a function? Or, is it a method of a class? If it's a method of a class it has to be called using an object of that class--unless it is a static method, which means you would call it with the class name.

memmove(newTable[i], act, sizeof(Activity*)); // is this correct?

Couldn't say...I've never heard of a memmove() function, which means if it exists, it's probably a C function.

// is this correct =>> newTable[i] = act;?

Yes, assuming act is of type Activity*. newTable is a pointer to an array of Activity pointers, and you can use array notation with a pointer to an array to access the elements of the array. That means:

newTable[0]
newTable[1]
newTable[2]

are all of type Activity* and can be assigned an Activity*.

delete []act; // is this correct?

It doesn't look like it, but you can't tell from the code whether the pointer assigned to 'act' points to memory that was dynamically allocated with new. The brackets are for deleting a pointer that points to an array. If instead, a pointer points to a single element, then you just use delete.

If you have a pointer to an array of pointers, and each of the pointers in the array points to dynamically allocated memory, first use a for loop to delete the memory pointed to by each of the pointers in the array using delete. Then, after the loop has finished, delete the pointer to the array using delete [].

[GaPe]

Thanks for the replies!

"The array contains 3 Activity pointers ..."
That's what I meant. So that's cool.

for (int i = 0; i < tableLength - 1; i++)
{
  Activity *act = someClass->getActivity(i);
  newTable[i] = act;
  delete []act;
  act = NULL;
}

In this method "getActivity" I use new function. So I have to free that act variable after I'm done with her, right? Or the someClass destructor deals with that?

[homeyg]

for (int i = 0; i < tableLength - 1; i++)
{
  Activity *act = someClass->getActivity(i);
  newTable[i] = act;
  delete []act;
  act = NULL;
}

In this method "getActivity" I use new function. So I have to free that act variable after I'm done with her, right? Or the someClass destructor deals with that?

This is wrong because if you free the memory that act points to, you are also freeing the same memory that you just assigned to newTable[i]. When you try to use newTable later it will cause problems.

I would recomend doing this:

for (int i = 0; i < tableLength; i++)
{
  newTable[i] = getActivity(i); //have getActivity() return a pointer to dynamically allocated Activity 
  //or it could even return a pointer to a dynamically allocated array
}

Now when you are done with that memory, you can do this.

for (int i = 0; i < tableLength; i++)
{
  delete newTable[i];
}

delete [] newTable;