C++ Pointer Variable Memory Leaking Clarification

Question

Suppose we have the following C++ code:

while(condition)
{
   Node* temp = SomeNode->next;
   //...
}

destructor()
{
     //delete Nodes;
}

And here temp is a local pointer variable and CurrentNode is a public class property. The public nodes and relevent nodes get freed in the destructor. But what happens to all the local scoped pointer variables. A pointer data type consumes some memory, for example 4 bytes or more (depending on the memory space), just for the address. Here, The temp local variable is not initialized with 'new' and is just a pointer to some other nodes, based on this, Is temp local variable made on the stack or on the heap? Does this local variable get destructed automatically soon after exiting the block or is it dynamic memory and yet needs using of delete. I saw some codes somewhere that did not use delete to free up local pointers that were not made with new. And I want to make sure if he missed freeing up the variables or there is some other story about it that I do not know. Thanks.

Please note that although you make reference to CurrentNode in your question, CurrentNode is not shown in your code sample. — Sabuncu
– Sabuncu, Commented Jul 20, 2013 at 14:23

Joseph Pla · Accepted Answer · 2013-07-20 14:23:21Z

4

The temp variable is a pointer that is pushed onto the stack. It gets released after it falls out of scope which is your "While" statement.

answered Jul 20, 2013 at 14:23

Joseph Pla

1,5981 gold badge10 silver badges21 bronze badges

Sign up to request clarification or add additional context in comments.

Comments

Joel · Accepted Answer · 2013-07-20 14:24:56Z

2

If the variable isn't allocated with new (or some other function that is documented to return something that is allocated on the heap, like malloc, make_shared, or whatever), then it has automatic storage.

When the containing scope exits, the variable is destroyed. This is an extremely important concept if you're working in C++, as it forms the fundamental basis for how memory management and other resource management should be done. Search for RAII for more details.

answered Jul 20, 2013 at 14:24

Joel

1,1456 silver badges9 bronze badges

1 Comment

Joel Over a year ago

A bit of a nitpick of my own answer, but just to be clear make_shared technically returns something that will be automatically destroyed but it's wrapped around something that isn't. That wrapping happens so that the lifetime of the non-automatic thing is tied to the lifetime of the automatic thing.

Thomas Russell · Accepted Answer · 2013-07-20 14:26:07Z

The variable temp is a pointer to a Node object. Depending on your system it will most likely be a single integer storing a memory offset.

When you make a pointer like this it is allocated on the stack and reclaimed at the end of the scope:

{ // Enter Scope
    Object* pObj; // A local variable created on the stack
} // pObj is reclaimed as would any other local variable.

The problem with memory leaks comes when you dynamically allocate memory (using new or new[]) and assign a pointer to the memory address and don't delete (or delete[]) the memory before the pointer goes out of scope and is reclaimed (at which point you have no way of deallocating the allocated memory).

{ // Enter Scope
    Object* pObj = new Object; // Local pointer to an Object in the heap
} // pObj is reclaimed but the Object which it was pointed to is not. 
  // We have a memory leak.

As to whether you need to delete (or delete[]) the temp variable, that all depends on the implementation of the Node::next function and the "contract" that you have when calling it.

Alan Stokes · Accepted Answer · 2013-07-20 14:27:19Z

1

The pointer temp is on the stack; the Node it points to is on the heap.

All local variables are destroyed automatically when you exit the containing block. For pointers and other simple things (ints, bools) this destruction doesn't need to do anything apart from reclaim the stack space. For variables of class type the destructors will run, allowing them to do any extra cleanup needed.

Also notice that if you did delete temp; you'd be asking for the memory pointed to by temp to be freed; temp itself would still exist and you could assign a new value to it later.

answered Jul 20, 2013 at 14:27

Alan Stokes

19k3 gold badges49 silver badges69 bronze badges

Comments

Juniar · Accepted Answer · 2013-07-20 17:10:19Z

1

The concept of memory management is to delete memory that you have allocated with new, alloc or malloc otherwise there will be some memory leak. Apparently the only way to manage memory allocated is to delete. This, however can be done in the destructor. Which, means only class variable gets deleted. So there is no way to delete local variables that are defined within a function. As they only exist within their scope.

When handling local variables, some technics are required i.e you can use class variables inside a function that will eventually get deleted or you can declare a pointer that will only be pointing to some memory address without actually allocating it some memory.

answered Jul 20, 2013 at 17:10

Juniar

1,4271 gold badge17 silver badges24 bronze badges

Collectives™ on Stack Overflow

C++ Pointer Variable Memory Leaking Clarification

5 Answers 5

Comments

1 Comment

Comments

Comments

Comments

Your Answer

Hot Network Questions

Collectives™ on Stack Overflow

5 Answers 5

Comments

1 Comment

Comments

Comments

Comments

Your Answer

Sign up or log in

Post as a guest

Related