deleting pointers in the destructor

I know that the destructors of objects will always take care of the simple, "normal" pointers, but I know that when pointers within the classes are used to create dynamic arrays and stuff, code must be written inside the destructors to make sure these are handled properly. For example, a destructor of class Comp, should Comp contain a dynamic array made through a pointer called mem, might look like this:

Code:

---

Comp::~Comp()
{
    if (mem != NULL)
    {
          delete [] mem;
    }
}

---

It is there that I have a little bit of a blind spot. I can't quite remember how to write those destructors correctly, and I'm having difficulty simply being able to look it up. I know that it looks something like that, but I don't remember the details. Can anybody fill me in?

Thanks.

if leaving the class aside, do you know how to dynamically allocate the memory, and then free it in a simple function?

as in:

Code:

---

Comp* computer = new Comp;
delete Comp;

---

?

yes,
so in your case new goes to the constructor
and delete in the destructor

the syntax of delete is not changed.

for each new - you have to have a delete
for each new[] - delete[]
etc

bwt it is

Code:

---

delete computer;

---

you delete the allocated object, not all the class

so for instance:

Code:

---

class Comp
{
public:
    Comp(int i = 5);
    ~Comp();

private:
    int* mem;
    int** pix;
    int count;
};

Comp::Comp(int i)
: count(i)
{
    mem = new int[i];
    pix = new int*[i];
   
    for (int j = 0; j < i; j++)
    {
          pix[j] = new int[i];
    }
}

Comp::~Comp()
{
    if (mem != NULL)
    {
          delete mem;
    }

    for (int i = 0; i < count; i++)
    {
          if (pix[i] != NULL)
          {
              delete pix[i];
          }
    }
 
    if (pix != NULL)
    {
          delete pix;
    }
}

---

Is that the way it's supposed to work?

Yes, except that you can leave out the check for NULL:

Code:

---

Comp::~Comp()
{
    delete mem;

    for (int i = 0; i < count; i++)
    {
        delete pix[i];
    }

    delete pix;
}

---

Thank you much for this. Back when I remembered this somewhat, I still had a hard time grasping it. But the way you've explained it seems to helped a lot with long-term memorization and comprehension, not just short-term. Thanks.

Hold on, there's another thing. Notice:

Code:

---

    mem = new int[i];
    pix = new int*[i];
   
    for (int j = 0; j < i; j++)
    {
          pix[j] = new int[i];
    }

---

So, you use new[] for mem, pix and pix[j], thus you must use delete[] for them too:

Code:

---

Comp::~Comp()
{
    delete[] mem;

    for (int i = 0; i < count; i++)
    {
        delete[] pix[i];
    }

    delete[] pix;
}

---

Ah, thank you.

If you do it this way, you'll also need to write the copy constructor and overload the assignment operator to ensure that these operations work properly (or make them private to prevent copying/assigning).

However, if you used a standard container, such as std::vector, instead of dynamically allocated arrays, you wouldn't even need to write a destructor, because those containers manage memory automatically for you.

thanks