C++ Programming - References - Discussion

The reference is stored in a stack while the object is allocated in the heap. Instances or references of a value type are stored in the stack.

A reference variable is the "alias name" to the existing data type variable.

#include<iostream>
using namespace std;
class abc
{
int i = 10;
int &j = i;
int &g = i;
cout<<"size is"<<sizeof(class abc)<<endl;

};

Output will be 12. So it gets space in stack.

Reference type stored in heap not stack.

A reference is stored on heap because dynamically allocation is stored in heap and reference create at run time. So yes its 100% right.

Stack is used to store local variable basically.

Its true that reference is stored in stack.

Cause reference just point or refer to any local variable.

And any local variable has stack memory.

So Indirectly reference is stored in stack.

How can we say that, A reference is stored on stack. . ?
I think, Reference has no memory. It just an another name of variable.
Can anyone tell me. . ?

Reference is also a variable declared in a function. That should be stored in stack.

Reference like a restricted pointer.

Reference can be stored on the stack or on the heap.
It is up to you in C++.

Example:
#include <stdlib.h>
#include <string>
#include <vector>

struct LinkedNode
{
LinkedNode(const std::string & val)
: value(val)
, next(*this)
{
}
LinkedNode(const std::string & val, LinkedNode & nextn)
: value(val)
, next(nextn)
{
}
bool islast() const
{
return (this == &next);
}
std::string value;
/**
* THIS REFERENCE CAN BE STORED ON THE HEAP OR ON THE STACK
**/
LinkedNode & next;
};

int main(int argc, char * argv[])
{
{
/***
* on stack
***/
LinkedNode n5("last node");
LinkedNode n4("node 4", n5);
LinkedNode n3("node 3", n4);
LinkedNode n2("node 2", n3);
LinkedNode n1("first", n2);
printf("%s\n", n5.islast() ? "true" : "false");
printf("%s\n", n1.islast() ? "true" : "false");
}
{
/***
* on heap
***/
LinkedNode * n5 = new LinkedNode("last node");
LinkedNode * n4 = new LinkedNode("node 4", *n5);
LinkedNode * n3 = new LinkedNode("node 4", *n4);
LinkedNode * n2 = new LinkedNode("node 4", *n3);
LinkedNode * n1 = new LinkedNode("first", *n2);
printf("%s\n", n5->islast() ? "true" : "false");
printf("%s\n", n1->islast() ? "true" : "false");
}
return 0;
}

If you see the memory management in c, local variables, function return addresses and formal arguments are stored in stack section.

So, reference is nothing but the address that's stored in stack section.