how do i append a struct Person in c++ - c++

Question

I have a struct Person
struct Person {
string name;
int age;
Person* next;
};
and i need to make a function that appends structs after each other like a linked list. I started off by creating a pointer head which is a nullpointer in the beginning.
using namespace std;
Person* head = nullptr;
void append(Person*& list, const string& name, int age) {
auto p = new Person{name, age, nullptr}; // typ List_Node*
if (list == nullptr) {
list = p;
return;
}
auto last = list;
while (last != nullptr) {
last = last->next;
}
last = p;
}
int main() {
append(head, "First_Person", 21);
append(head, "Second_Person", 22);
// testing the result
head = head->next;
cout << "head->name outside: " << head->name << endl;
return 0;
}
Now the problem i have now is that after the first append the append() function doesn't seem to link the first person to the second person because the program crashes
head = head->next;
Question is: how do i get append() to append more than 1 Person to this linked list?

Answer 1

auto last = list;
while (last != nullptr){
last = last->next;
}
last = p;
When you get out of this loop, last is pointing at nullptr again instead of the last element of the list. You need to check last->next != nullptr instead.
Also, last = p does not do anything useful; it should be last->next = p in order to actually append p to the list.

Answer 2

Your append() is not managing the pointers correctly. Try this instead:
void append(Person*& list, const string& name, int age)
{
auto p = new Person{name, age, nullptr}; // typ List_Node*
if (list == nullptr)
{
list = p;
return;
}
auto last = list;
while (last->next != nullptr)
last = last->next;
last->next = p;
}
If you get rid of the list parameter, you can avoid having to iterate through the entire list on every append:
Person* head = nullptr;
Person* last = nullptr;
void append(const string& name, int age)
{
auto p = new Person{name, age, nullptr};
if (head == nullptr)
head = p;
if (last != nullptr)
last->next = p;
last = p;
}
int main()
{
append("First_Person", 21);
append("Second_Person", 22);
//testing the result
for(Person *p = head; p != nullptr; p = p->next)
std::cout << "name: " << p->name << std::endl;
// free the list
Person *p = head;
while (p != nullptr)
{
Person *next = p->next;
delete p;
p = next;
}
return 0;
}
That being said, you should use std::list or std::forward_list to hold your Person items and let it handle all of these details for you, eg:
#include <list> // or: #include <forward_list>
struct Person
{
string name;
int age;
};
std::list<Person> mylist; // or: std::forward_list<Person> mylist;
void append(const string& name, int age)
{
mylist.push_back(Person{name, age});
}
int main()
{
append("First_Person", 21);
append("Second_Person", 22);
//testing the result
for (auto &person: mylist)
std::cout << "name: " << person.name << std::endl;
return 0;
}

Answer 3

If you are writing this in a non-academic context, then don't reinvent the wheel, and use a standard container like vector or list.
However, assuming the point of the exercise is to learn data structures, then using a builtin container doesn't teach you much.
The problem I see is you are doing nothing but changing the "last" pointer, which doesn't actually append anything to the list. You need to first find the last node (by using the 'last' pointer to move to each node->next until you reach a node which has a null ->next pointer. Then assign that node's ->next to your new node.
Your existing code...
// Already handled empty list case before we get here...
auto last = list; // last pointer set to address list (head)
while (last != nullptr){ // while not at end of list, last points to next node
last = last->next;
}
// after loop, last will always be null, not very useful
last = p; // last points to p (the new node) which doesn't _do_ anything
Consider doing something like:
// Already handled empty list case before we get here...
auto last = list; // last pointer set to address list (head)
while (last && last->next != nullptr){ // while node->next not null, move to next node
last = last->next;
}
// at end of list, last will always point to last node
last->next = p; // link last->next to the new 'p' Person
Keep in mind if you do a lot of list append operations, it is cheaper for your list data structure to keep a head and a tail pointer, and append simply becomes
if(tail)
tail->next = p;
tail = p;
Besides that, it is cheaper to insert items at the head of a list.
p->next = head;
head = p;