Allocate and Delete memory for pointers in a struct C++

Question

Given the following struct declaration:

struct Student

{

   char *     name;
   int  *     test;
   float      gpa;

};

int main() {

Student *newObject = new Student;

newObject->name = new char[10];
newObject->test = new int;

return 0;
}

My question is how do I destroy the created dynamic variables ? I tried delete newObject->name; and delete newObject->test;but it doesn't seem to work because it shows me the same addresses as before delete . Is it just enought to delete the object by using delete newObject; newObject = nullptr;?

Always match `new` -> `delete` and `new[]` -> `delete[]`. `delete`ing something will not magically set the pointer to null, you will have to do it yourself if it's important to your program. Side note: don't use `new` and `delete`. — user657267, Feb 13 '15 at 09:43
What user657267 probably meant in his sidenote is that, unless you're a c++ student, you should prefer using C++11 facilities, such as `std::unique_ptr` and `std::shared_ptr`, or, of course, stack allocation. — Giulio Franco, Feb 13 '15 at 09:45

Sebastian Kuczyński · Answer 1 · 2015-02-13T10:06:37.967

If you're using C++, you should use constructors, and destructors inside your structure(unless you REALLY need to have POD type structure).

struct Student
{
    Student(){
        name = new char[10];
        test = new int;
    }
    ~Student(){
        delete[] name;
        delete test;
    }
    char *     name;
    int  *     test;
    float      gpa;

};

int main() {
    Student *newObject = new Student;
    delete newObject;
    return 0;
}

Deletes on pointers inside struct will be called automatically when you use delete on newObject.

Keep in mind that using delete, does not delete any data! It just frees the used memory-says something like "Hey, I'm not using this part of memory anymore", so it can be used by some other data. You must always use delete, when you finished using some pointer, or you'll get memory leak.

score 3 · Accepted Answer · answered Feb 13 '15 at 09:49

It would have to be

delete[] newObject->name;
delete newObject->test;
delete newObject;

because name was allocated with new[] while the other two were allocated with new. Neither delete nor delete[] changes the pointer value, though, it just invalidates what the pointer used to point to.

However, doing it this way is rather terribad. In the case of the object itself and the int, there is no reason to use dynamic allocation at all, and for name there's a class in the standard library called std::string that does the memory management for you. It would be best to replace the code with

#include <string>

struct Student {
  std::string name;
  int         test;
  float       gpa;
};

int main() {
  Student newObject;

  // do stuff, for example
  newObject.name = "John Doe";
  newObject.test = 123;
  newObject.gpa  = 3.1415926;

  // no manual cleanup necessary; it happens automatically when
  // newObject goes out of scope.
  return 0;
}

Thank you . I am C++ student and I have to use cstrings and dynamic allocation for learning purposes. So I do 'cout << newObject; ' before and after 'delete newObject' and I get totally different values of memory addresses , but when I do it for 'delete newObject->test;' the values stay the same . Why ? — ReeSSult, Feb 13 '15 at 10:18
Assuming that you mean, for example, that `newObject->test` changes after `delete newObject`, a number of things can have happened -- **`newObject->test` is not a valid thing to use after `newObject` is `delete`d, and you cannot depend on it having any value.** Among the things that could result in such a visible change: if you're working with Visual Studio, the debug heap's deallocation routine overwrites the deallocated memory with `0xfeeefeee` to make it recognizable. Let me stress again that this is not dependable, and that code like that could crash or do any number of other things. — Wintermute, Feb 13 '15 at 10:32

score 2 · Answer 3 · answered Feb 13 '15 at 09:59

The short answer is that you do need to use delete or delete [] (as appropriate) on each member pointer. As remyabel commented, delete does not change the value of the pointer, it simply deallocates the memory that that pointer was referring to.

// delete dynamically constructed members
delete newObject->test;
delete[] newObject->name;

The implementation of new may allocate memory in ways that are different for arrays of items than for single items, so it is important when deleting that you use delete [] for the former and delete for the later.

A more idiomatic way of handling clean-up is to perform these deletes in the destructor of the struct Student. The members are allocated and constructed, or initialized with null pointers at construction for safety (delete on a null pointer does nothing.)

struct Student
{
    char *   name;
    int  *   test;
    float    gpa;

    Student(): name(0), test(0), gpa(0.0f) {}

    ~Student() {
        delete[] name;
        delete test;
    }
};

delete newObject will then in turn delete the allocated members correctly, provided they were indeed allocated with new[] and new.

Because the destructor cannot guarantee that the members were indeed allocated this way, it is in turn best to pass the responsibility for allocating the members to member functions or constructors of the structure as well.

score 1 · Answer 4 · answered Feb 13 '15 at 09:48

1

As said in comments, delete just frees the memory, it doesn't change the address pointed by the pointer. If you don't want to allocate / free the memory by yourself, prefer smart pointers.

answered Feb 13 '15 at 09:48

vincentp

1,433
9
12

Allocate and Delete memory for pointers in a struct C++

4 Answers4