Does dynamically allocated memory for data members of a C++ class frees when class object is finalizing?

Question

I've this C++ class:

class test{

    char* p;
    SomeClass* someObject;

   test(){
      ...
      p = (char*) malloc(1000);
      someObject = new SomeClass();
      ...
   }

   ~test(){}

}

Do I need to call free(p) or delete someObject explicitly in test destructor in order to free their allocated memory or that memory will free automatically?

score 8 · Answer 1 · edited May 23 '17 at 12:04

You need to free all dynamically allocated memory in the destructor. This does not get done automatically.

Your class contains two pointers, and essentially has no control over what these point to. In fact, these could point to objects that you are not allowed to delete, for example:

struct Foo {};
struct Bar {
  Foo* f_;
  Foo(Foo* f) : f(f_) {}
};

int main() {
  Foo f;
  Bas b(&f); // b has a Foo ptr, but should it delete it?
}

So you can see that it doesn't really make sense for pointer data members to be deleted automatically.

As a general rule, if your class manages resources¹, then you should take care of copy construction and assignment; that means, you should either disable them if that makes sense for the class, or provide implementation for them because the compiler generated ones would not work. For detail discussion on this topic, see the rule of three, and extensive discussions on stackoverflow:

If you don't follow this rule, then the default copy constructor and assignment operation will make a shallow copy and you will have more than one instance having pointers to the same dynamically allocated objects, which they will all try to delete upon destruction.

You can avoid manually deleting objects created with new by using smart pointers. In your case, where the class obviously owns the dynamically allocated object,you should look at C++11's std::unique_ptr or boost::scoped_ptr

Finally, you can really avoid all memory management problems by avoiding pointers all together, unless you really need to. You could replace your char* by an std::string for example:

class test{

    std::string p;
    SomeClass someObject;
    //test() : someObject() {} // default construction is probably OK...
};

^{1. That is, it allocates and deallocates memory, or opens and closes network connection, or creates and destroy mutexes and so on.}

He needs to either disable copy-semantic or implement them manually. — Nawaz, Jul 02 '12 at 05:58
Might be worth suggesting that you should avoid manual memory management if you can, the OP's code to me smells of a blend of C and Java. — Arafangion, Jul 02 '12 at 06:05
@Arafangion I was writing about smart pointers, but you're right, I have been working under the assumption that the dynamically allocated memory is actually necessary here. — juanchopanza, Jul 02 '12 at 06:09
I suspect that the OP is also unaware of std::vector, and variables on the stack. — Arafangion, Jul 02 '12 at 06:13
@Nawaz thanks for the edits, couldn't have done it better myself! — juanchopanza, Jul 02 '12 at 06:28

score 3 · Answer 2 · edited Jul 02 '12 at 07:54

3

Yes, you have to free anything you malloc and delete everything you new.

You can also avoid that by not storing pointers in your class.

class test{
public:
    std::string   p;
    SomeClass     someObject;
};

edited Jul 02 '12 at 07:54

juanchopanza

210,243
27
363
452

answered Jul 02 '12 at 06:07

Bo Persson

86,087
31
138
198

score 1 · Answer 3 · answered Jul 02 '12 at 05:57

1

Yes, you need. If you don't want, you can use the Smart Pointer

answered Jul 02 '12 at 05:57

RolandXu

3,098
2
12
20

score 0 · Answer 4 · answered Jul 02 '12 at 05:55

Yes, you need to free them explicitly. Pointer as a data type does not have any destructor. Compiler/execution enviroment does not have any means to guess if pointer points to anything meaningfull or not. Even if the value is meaningfull, it may point to some static object for example. Or it can point to some field of a bigger object. Compiler is not doing any automatic cleanup on pointers.

jxh · Answer 5 · 2012-07-02T06:16:38.153

The memory is technically leaked if you do not reclaim it when the instance of test is destructed. You could use a smart pointer instead to avoid calling free or delete explicitly in the destructor.

struct Free { void operator () (void *p) const { free(p); } };

class test {
    std::unique_ptr<char, Free> p;
    std::unique_ptr<SomeClass> someObject;
    test () : p(static_cast<char *>(malloc(1000)),
              someObject(new SomeClass)
    { //...
    }
    ~test () {}
};

This uses the destructor of the smart pointer to perform the clean up action for you.

If test were only used as const global instances, then it is less important to implement the cleanup since the memory would not be reclaimed until the execution had ended anyway. But it is good practice to always implement the cleanup, because it would make the code correct now, and test may be used differently in the future.

Does dynamically allocated memory for data members of a C++ class frees when class object is finalizing?

5 Answers5