How to delete an object inside of a class declared with "new" alongside the class

Question

Suppose we want to create a class / struct which contains an object, and repeatedly replace a pointer to an object of that class / struct with a new instance of it.

struct foo {
    int a[128];
};

int main() {
    foo* bar;

    for(int i = 0; i < 120000; i++) {
        delete bar;
        bar = new foo();
    }

    return 0;
}

This program works, as far as I can tell, and successfully frees up the memory used by 'a' at the deletion of 'foo' (Task Manager tells me it uses about 14.5 MB of RAM). But instead of declaring it this way, let's say we need a dynamic object instead:

struct FOO {
    int* A;
    FOO() {
        A = new int[128];
    }
};

int main() {
    FOO* BAR;

    for(int i = 0; i < 120000; i++) {
        delete BAR;
        BAR = new FOO();
    }

    return 0;
}

In this case, the program does not seem to successfully free up the memory stored at 'A' (Task Manager tells me this uses about 78.1 MB of RAM). Why does the call to delete BAR fail to free the memory at 'A', and how can this code be reconfigured so that that can be done?

This link might help: https://en.cppreference.com/w/cpp/language/destructor — GeminiDakota, Nov 18 '18 at 04:39
"This program works". You are being overly optimistic. The code has undefined behaviour from using an uninitialised `bar`. Crank up your compiler warning level, and treat warnings as errors. — n. m. could be an AI, Nov 18 '18 at 04:48
*Task Manager tells me this uses about 78.1 MB of RAM* -- You cannot determine memory leaks by looking at Task Manager. You determine memory leaks by looking at your code and determining the code is leaking memory. — PaulMcKenzie, Nov 18 '18 at 04:57

score -1 · Answer 1 · answered Nov 18 '18 at 04:44

-1

What you are missing is destructor in Foo struct. See this variant :

struct FOO {
int* A;
FOO() {
    A = new int[128];
}
~FOO()
{
    delete A[];
}
};

int main() {
FOO* BAR;

for(int i = 0; i < 120000; i++) {
    delete BAR;
    BAR = new FOO();
}

return 0;
}

The destructor of FOO should now take care of deleting the memory created dynamically in the constructor.

answered Nov 18 '18 at 04:44

anangupadhyaya

118
8

I think you mean `delete[] A;`? – Galik Nov 18 '18 at 04:46
Correct, sorry for typo and thanks @Galik for pointing it out! – anangupadhyaya Nov 18 '18 at 04:47

score -1 · Accepted Answer · answered Nov 18 '18 at 04:45

You need to implement the destructor to free the memory allocated inside constructor. However, memory allocation inside constructor is a bad idea and there are better alternatives to it.
Also, since you are dealing with pointers, please make sure you are checking memory allocation result and properly assigning NULL as and when required along with checking if it is safe to delete the pointer
Note1: since you have used new to allocate array, you have to use delete[] rather than delete.
Note2: You also started deleting the BAR even before allocating.
It should look at least something like this:

    struct FOO {
    int* A;
    FOO() {
        A = new int[128];
    }
    ~FOO() {
         if(A) delete[] A; // use delete[] instead of delete for an array
         A = nullptr;
    }
};

int main() {
    FOO* BAR;
    BAR = new FOO();
    for(int i = 0; i < 120000; i++) {
        if( BAR) {
            delete BAR;
            BAR = nullptr;
        }
        BAR = new FOO();
    }

    return 0;
}

How to delete an object inside of a class declared with "new" alongside the class

2 Answers2