Why is the output of this code always the same?

Question

Why am I getting the same output in the following for loop in c++.

node* nn =  (struct node*)malloc(sizeof(struct node));      
for(int i=0;i<10;i++)
{

    node* n =  (struct node*)malloc(sizeof(struct node)); 
    cout<<&n<<endl;
    nn->next = n;
    nn =n;
}

Answer 1

Because your n variable is local to the loop body, it is created at the beginning of each iteration, and destroyed at the end of each iteration.

Evidently the compiler decided to reuse the same storage for every incarnation of n, which is why all of them have the same memory address.

Note that &n is the address of n, not its contents. You don't even have to initialize it. Your call to malloc is irrelevant.

If you want to see the value of n, you need to remove the &.

Answer 2

You're outputting &n which is the address of n not the content of n which is probably what you wanted.

NB: The question was edited following my answer, but the same problem remains.

Try this:

#include <iostream>
#include <cstdlib>

struct node {
    node* next;
};

int main() {
    node* nn =  (struct node*)malloc(sizeof(struct node));      
    nn->next=nullptr;//Initialise so we can clean up nicely...
    for(int i=0;i<10;i++)
    {

        node* n =  (struct node*)malloc(sizeof(struct node)); 
        n->next=nullptr;//Initialise so we can clean up nicely...
        std::cout<<&n<<"=="<<n<<std::endl;
        nn->next = n;
        nn =n;
    }
    //Clean up after ourselves. Not relevant to the question but good practice.
    while(nn!=nullptr){
        node*n=nn;
        free(nn);
        nn=n;
    }
    return 0;
}

Typical output:

0x7ffda1be2058==0x55ffb0b9fc20
0x7ffda1be2058==0x55ffb0ba0c50
0x7ffda1be2058==0x55ffb0ba0c70
0x7ffda1be2058==0x55ffb0ba0c90
0x7ffda1be2058==0x55ffb0ba0cb0
0x7ffda1be2058==0x55ffb0ba0cd0
0x7ffda1be2058==0x55ffb0ba0cf0
0x7ffda1be2058==0x55ffb0ba0d10
0x7ffda1be2058==0x55ffb0ba0d30
0x7ffda1be2058==0x55ffb0ba0d50

The actual output may vary and in principle a compiler isn't required to store n at the same address each iteration. I know of no compiler that doesn't. Anyone?

NB: Using malloc() in C++ is very rarely recommended. The direct substitute for malloc() and free() is new and delete. In practice use std::unique_ptr<> or other self managing construct.

Answer 3

This is only an addition to melpomene's answer, responding to the comments:

How do I create n nodes? Use of vectors is prohibited, so I am creating a linked linked list of n nodes, but the problem is I am unable to create n nodes in a loop.

Actually, your code was less incorrect than you thought, solely you missed one important point:

nn->next = n;

With this instruction, you lost the last reference to what nn pointed to originally and you won't ever be able to re-gain it again...

What you yet need is a second pointer to the element created initially, so you don't lose your list head and thus the rest of the list any more:

node* nn = new node(); // this is the C++ way...
node* head = nn; // now you have a second pointer to the head... 

for(int i=0;i<10;i++)
/* [...] */

Now you can access all the nodes you created via the head pointer (as long as you do not move it away from...).

Get rid of the loop and simply use struct *n = malloc (sizeof *n * 10); – David C. Rankin

Another variant: creating 10 elements directly... Assuming node looks like this:

struct node
{
    Data data;
    node* next;
};

Then you get 10 elements of Data simply by

Data* allData = new Data[10]; // again using the C++ way...

The C++ aproach has another advantage: the elements in the array are already initialised as the default constructor gets called (for primitive data types, see here).