Strange behaviour of linked list with struct - c++

Question

Basically I created a linked list with struct and a function to add new node to the beginning.
I added 4 nodes to the linked list and read it with a for loop. But the out put is strange
#include <iostream>
using namespace std;
struct Lin{
int val;
Lin* nex;
};
Lin ext (Lin orig, int nod) {
Lin fresh = {nod, &orig};
return fresh;
};
int main(){
Lin x;
x.val=15;
x=ext(x,25);
x=ext(x,35);
x=ext(x,45);
for (int i = 0; i < 4; i=i+1) {
cout <<x.val<< endl;
x = *x.nex;
}
}
Output is:
45
35
-72537468
892483373
Segmentation fault (core dumped)
The first 2 number is correct, but the 3rd is wrong.
Can someome explain what actually happened?

Answer 1

x is stored on the stack, and is not initialized, so x.nex is garbage (and not even NULL).
fresh is stored on the stack, too. It is initialized but unfortunately, orig is stored on the stack as well, and both live only during the call. ext returns a copy of `fresh.
The code looks like you’re more familiar with languages where everything is a reference (like JS, C#, many others). In C/C++ that’s not the case, you have to use pointers explicitly. More like:
Lin *ext (Lin *orig, int nod) {
return new Lin{nod, orig}; // Lin(nod, orig) on pre-C++11 systems
}
int main() {
Lin *x = nullptr; // NULL on pre-C++11 systems
x = ext(x, 15);
...
for (Lin *y = x; y; y = y->nex)
cout << y->val << endl
UPDATE.
I forgot to mention the list structure. It is a chain, where last node’s nex is NULL (that’s special pointer-to-nothing in C/C++; can also be spelled nullptr in modern C++).
As JHBonarius noticed I forgot to describe how to free that list (otherwise it will remain in memory till program end). It is done in a similar loop; the trick here is to save value of nxt before deleting the node
for (Lin *y = x; y; ) {
Lin *next = y->nxt;
delete y; // deletes the object `y` points to,
// so accessing `y->nxt` is not allowed anymore,
// but accessing `next` is
y = next;
}
Note that x becomes a dangling (i.e. pointing to arbitrary memory location) pointer when the first node is deleted, so it’s better to set it to NULL afterwards (as pointer can be checked for being NULL but not for being dangling; also dereferencing NULL is almost certain crash while dereferencing dangling pointer leads to obscure problems [sometimes crashes too] appearing in unrelated program parts).

Answer 2

Your problem is here:
Lin fresh = {nod, &orig};
You're grabbing the address of orig, which is declared as:
Lin ext (Lin orig, int nod) {
So orig is actually a Lin copy! It'll go out of scope when the function finishes, so you'll be left with an invalid pointer and undefined behavior.
You can avoid this by passing by reference instead of by copy:
Lin ext (Lin &orig, int nod) {
But then you're passing the same Lin object (x) every time, so &orig will be the same address every time. You'll need multiple different Lin objects with different addresses. If you want to continue avoiding dynamically allocated memory, that could look like:
int main(){
Lin x;
x.val = 15;
x.nex = nullptr; // Don't forget to null your tail's next!
Lin x2 = ext(x,25);
Lin x3 = ext(x2,35);
Lin x4 = ext(x3,45);
for (Lin i = x4; i.nex; i = *i.nex) {
cout << i.val << endl;
}
}

Answer 3

Lin ext (Lin orig, int nod) {
Lin fresh = {nod, &orig};
return fresh;
};
This - Lin orig is passed as a COPY of the original data, taking a reference to this will at some point mess up the memory as your are referencing the memory address of a temporary variable.
I would pass in a pointer myself
such that:
#include <iostream>
#include <string>
struct Lin
{
int val;
Lin* nex;
Lin(int value = 0, Lin *next = NULL)
: val(value)
, nex(next)
{}
};
Lin* ext(Lin *orig, int nod)
{
return new Lin(nod, orig);
};
int main()
{
Lin *pi_x = new Lin(15);
pi_x = ext( pi_x, 25 );
pi_x = ext( pi_x, 35 );
pi_x = ext( pi_x, 45 );
std::cout << "List:" << std::endl;
for(Lin *lin = pi_x; lin != NULL; lin = lin->nex )
{
std::cout << lin->val << std::endl;
}
std::cout << "------" << std::endl;
return 0;
}
Last but not least - you are looping though pointers - memory adresses.
The linked list is modelled by having a null pointer as being the terminating element (next is null)
The struct you are creating should atleast start with a memory assignment of some sort such that you dont have random adresses set in the pointer of Lin and you should also guarantee that you dont dereference a nullpointer (ie. *x.nex)
--
I redid my implementation - as comments correctly state the variable was stack allocated and the same address was used for the 'node factory' method.
Now by calling 'new' the memory is dynamically allocated (heap) and using a pointer will just update the memory address when using the assignment operator instead of copying the contents of the struct as before with the stack allocated memory.
doing a for loop with NULL check for termination can be a risky thing - and as comments suggest if the data does not adhere to the rules expected there is a risk for infinite loops.
Results of running the revised code
List:
45
35
25
15
------
With respect to the memory leaks it is possible to change the implementation to use smart pointers which can be found in ´<memory>´
And then swap any raw Lin pointers with
#include <memory>
std::shared_ptr<Lin> ptr;
ptr = std::make_shared<Lin>(0, NULL);
// Getting raw pointer from smart_pointer
Lin *raw = ptr.get();