Confused about C++ memory deallocation

Question

So in C++ if I create an object useing new I should always deallocate it using delete
For example

Segment::Segment(float length) { segmentLength = length; angle = 0.0f; x = Rand::randFloat(1.0f, 1.5f); y = Rand::randFloat(1.0f, 1.5f); vx = Rand::randFloat(0.0f, 1.0f); vy = Rand::randFloat(0.0f, 1.0f); prevX = Rand::randFloat(0.0f, 1.0f); prevX = Rand::randFloat(0.0f, 1.0f); };

And lets say I use it like this in another class such as,

this._segmentObject = Segment(2.0f); this._segmentPointer = new Segment(2.0f);

In the destructor of that class, I know I should call delete on the this._segmentPointer, however how do I make sure memory is deallocated for the other one?

mmmmmmmm · Accepted Answer · 2011-07-20 19:22:20Z

however how do I make sure memory is deallocated for the other one?

It is automatically. This is why this type of storage is called automatic. Automatic storage is released at the end of the storage’s life cycle, and the objects’ destructors called.

The object life-cycle ends when the program control leaves the scope where the object has been allocated.

Evan Teran · Accepted Answer · 2011-07-20 19:04:30Z

Things not allocated with new, new[] or the malloc family should be destructed and "freed" when the object goes out of scope.

Often this simply means that that the code has reached the end of the block it was declared it or that the object that it was in was destructed (one way or another).

To see this in action, you can do something like this:

struct C { C() { std::cout << "C()" << std::endl; } ~C() { std::cout << "~C()" << std::endl; } }; struct B { B() { std::cout << "B()" << std::endl; } ~B() { std::cout << "~B()" << std::endl; } private: C c_; }; struct A { A() { std::cout << "A()" << std::endl; } ~A() { std::cout << "~A()" << std::endl; } }; int main() { B *b = new B; // prints "B()", also constructs the member c_ printing "C()" { // starts a new block A a; // prints "A()"; } // end of block and a's scope, prints "~A()" delete b; // prints "~B()", also destructs member c_, printing "~C()" }

Note: that if we did not do delete b, the "~B()" and "~C()" would never print. Likewise, if c_ were a pointer allocated with new, it would need to be delete'd in order to print "~C()"

antlersoft · Accepted Answer · 2011-07-20 19:01:00Z

The memory for this._segmentObject is part of the memory of the containing object, and will be released when the containing object is destroyed.

this._segmentObject is assigned from a temporary object that is created on the stack and deleted when it goes out of scope.

piotr · Accepted Answer · 2011-07-20 19:01:11Z

Not only that, You should only allocate with new and deallocate with delete in Constructors or Destructors, otherwise your program can leak if an exception is thrown.

Jason · Accepted Answer · 2011-07-20 19:23:45Z

The destructors for all class-type member objects are called at the time of the destruction of the primary class. So your this object, which is allocated on the stack, will have it's destructor called when it goes out-of-scope. At that time, any class-type member objects of your this object will have their own destructors called in addition to the destructor for your this object which will call delete on the member pointer.

For instance, take the following code sample:

#include <iostream> using namespace std; class A { public: A() {} ~A() { cout << "Destructor for class A called" << endl; } }; class B { private: A a; public: B() {} ~B() { cout << "Destructor for class B called" << endl; } }; int main() { B b; return 0; }

When run, the output becomes the following:

Destructor for class B called Destructor for class A called

So you can see that when b, which is allocated on the stack, goes out-of-scope at the end of main, the destrutor for class B is called, which in-turn, after executing the body of the destructor function, calls the destructors for any of its class-type member data objects, which in this case would mean the destructor for class A. Therefore in your case, the pointer would have delete called on it in the destructor for your this class, and then the destructor for _segmentObject would be called after the destructor for this had completed execution of the body of its destructor. Then once all the destructors for the non-static data-member objects had been called, the destructor for this then returns.

Max · Accepted Answer · 2011-07-20 18:58:45Z

0

The _segmentObject is allocated automatically on the stack. The object destructor will be called automatically when the variable gets out of scope.

answered Jul 20, 2011 at 18:58

Max

3,1903 gold badges25 silver badges24 bronze badges

2 Comments

Konrad Rudolph Over a year ago

“The _segmentObject is allocated automatically on the stack” – this is wrong. It may well be allocates on the heap (inside another object for instance). That is irrelevant, however.

Novikov Over a year ago

It is not allocated on the stack

Peter K. · Accepted Answer · 2011-07-20 19:23:12Z

As others have said, you don't need to explicitly do anything to reclaim the memory used by this._segmentObject. As soon as it goes out of scope, the memory will be reclaimed.

It's not clear why you would use Segment in both ways. You should try to ensure you use the Resource Acquisition Is Initialization idiom, as it removes much of the need for checking new / delete pairs. That is, just use the this._segmentObject version, not the pointer.

Your application may not allow it, though.

Collectives™ on Stack Overflow

Confused about C++ memory deallocation

7 Answers 7

Comments

Comments

Comments

Comments

Comments

2 Comments

Comments

Hot Network Questions

Collectives™ on Stack Overflow

7 Answers 7

Comments

Comments

Comments

Comments

Comments

2 Comments

Comments

Related