Difference between using and not using new pointer - c++

Question

Please refer the code given here:
This code is a part of stack implementation in C++:
Code 1:
void Stack::pop()
{
if (top != 0) {
node* temp = top;
top = top -> link;
delete temp;
}
}
Code 2:
void Stack::pop()
{
if (top != 0) {
node* temp = new node;
temp = top;
top = top -> link;
delete temp;
}
}
In first example, I didn't use new, while I did use it in second one. On running, both give same output with the complete program, which can be found below:
#include <iostream>
using namespace std;
struct node {
string name;
node* link;
};
class Stack
{
node* top;
public:
Stack();
void push(string s);
void pop();
void display();
~Stack(){}
};
Stack::Stack() {
top = 0;
}
void Stack::push(string s)
{
node* temp = new node;
temp -> name = s;
temp -> link = top;
top = temp;
}
void Stack::pop() // Function in question
{
if (top != 0) {
node* temp = new node;
temp = top;
top = top -> link;
delete temp;
}
}
void Stack::display()
{
node* temp = new node;
temp = top;
while (temp != 0)
{
cout << temp -> name << "\n";
temp = temp -> link;
}
}
int main() {
Stack s;
s.push("Ra");
s.push("Sa");
s.push("Ga");
s.pop();
s.display();
}
What is the difference in using and not using new pointer here?
Also does the memory automatically free itself or do I have to do it in destructor? If so, how to do it?

Answer 1

There's memory leak in the 2nd code snippet, even though it looks working well. new node is meaningless for node* temp = new node;, because temp is assigned to top at once. Then the original memory address created by new node is lost and couldn't be deleted again.
Also does the memory automatically free itself or do I have to do it in destructor?
Each object newed has to be deleted by yourself. Consider about smart pointers, they will manage such things for you.

Answer 2

In these lines:
node* temp = new node;
temp = top;
you allocate new node, store it in temp variable and ton the next variable store in the same variable another pointer. So that new node is lost and newer used. node* temp = new node; has no effect other than leaking memory.
Also does the memory automatically free itself or do I have to do it
in destructor?
No. Memory is not freed automatically. And you nearly never actually call object destructor manually.
If so, how to do it?
The old way is to use delete. But im modern C++ you should not use naked owning pointers and really should consider using std::unique_ptr.

Answer 3

While using new/allocating the memory, you are causing a memory leak.
node* temp = new node;
temp = top; //temp is now pointing to a new memory location.
//Thus the memory allocated by in the previous code line gets leaked
Code1 is the correct way to do it. Code 2 causes memory leak.
You have to delete the memory that you allocate using the delete operator in the destructor.
Stack::~Stack()
{
while(NULL != top)
{
node* temp = top;
top = top->link;
delete temp;
}
}
A smart pointer Solution. You will need c++11 compiler for the following code to compile/work.
#include <iostream>
#include <memory>
using namespace std;
struct node {
string name;
std::unique_ptr<node> link;
};
typedef std::unique_ptr<node> node_ptr;
class Stack
{
node_ptr top;
public:
Stack();
void push(string s);
void pop();
void display();
~Stack(){}
};
Stack::Stack() {
}
void Stack::push(string s)
{
auto temp = std::make_unique<node>();
temp -> name = s;
temp -> link = top;
top = temp;
}
void Stack::pop()
{
if (top != null) {
top = top -> link;
}
}
void Stack::display() const
{
node* temp = top.get();
while (temp != 0)
{
cout << temp -> name << "\n";
temp = (temp -> link).get();
}
}
int main() {
Stack s;
s.push("Ra");
s.push("Sa");
s.push("Ga");
s.pop();
s.display();
}