How to manually destroy member variables?

Question

I have a basic question on destructors.

Suppose I have the following class

class A
{
public:

int z;
int* ptr;

A(){z=5 ; ptr = new int[3]; } ;
~A() {delete[] ptr;};

}

Now destructors are supposed to destroy an instantiation of an object. The destructor above does exactly that, in freeing the dynamically alloctaed memory allocated by new.

But what about the variable z? How should I manually destroy it / free the memory allocated by z? Does it get destroyed automatically when the class goes out of scope?

`z` will be automatically cleaned up. You had to delete `ptr` because it's heap-allocated, but `z` isn't allocated on the heap. — wkl, Jan 11 '12 at 19:23
You're ignoring the [Rule of Three](http://stackoverflow.com/q/4172722/500104) here, just as a reminder. :) — Xeo, Jan 11 '12 at 19:24
Also, using a `std::vector` instead of an array would obviate having to define a destructor, as well as the Rule of Three issue. — Fred Larson, Jan 11 '12 at 19:29

Jason · Accepted Answer · 2012-01-12T16:54:44.790

5

It gets "destroyed" automatically, although since in your example int z is a POD-type, there is no explicit destructor ... the memory is simply reclaimed. Otherwise, if there was a destructor for the object, it would be called to properly clean-up the resources of that non-static data member after the body of the destructor for the main class A had completed, but not exited.

edited Jan 12 '12 at 16:54

answered Jan 11 '12 at 19:23

Jason

31,834
7
59
78

Xeo · Answer 2 · 2012-01-11T19:52:48.997

4

z is automatically destroyed. This happens for every "automatic" variable. Even for pointers like int*, float*, some_class*, etc. However, when raw pointers are destroyed, they are not automatically deleted. That's how smart pointers behave.

Because of that property, one should always use smart pointers to express ownership semantics. They also don't need any special mentioning in the copy / move constructor / assignment operator, most of the time you don't even need to write them when using smart pointers, as they do all that's needed by themselves.

edited Jan 11 '12 at 19:52

answered Jan 11 '12 at 19:26

Xeo

129,499
52
291
397

1

pointers like `int *ptr` have automatic storage duration as well, and do get automatically destroyed. It's just that destroying a pointer doesn't call `delete` on the pointer. – bames53 Jan 11 '12 at 19:30

score 2 · Answer 3 · answered Jan 11 '12 at 19:26

Destroying an object will destroy all the member variables of that object too. You only need to delete the pointer because destroying a pointer doesn't do anything - in particular it doesn't destroy the object that the pointer points to or free its memory.

score 0 · Answer 4 · answered Jan 11 '12 at 19:23

0

It does, in fact, get automatically destroyed when the class goes out of scope. A very good way to guess if that's the case is that there's no * after its declaration.

answered Jan 11 '12 at 19:23

sblom

26,911
4
71
95

score 0 · Answer 5 · answered Jan 11 '12 at 19:27

For PODS (plain old data types) like ints, floats and so on, they are automatically destroyed. If you have objects as data members (e.g. std::string aStr;), their destructors will be automatically called. You only have to manually handle memory freeing (like above) or any other manual object or data cleanup (like closing files, freeing resources and so on).

How to manually destroy member variables?

5 Answers5

Linked