Passing linked list from array by reference - c++

Question

My problem is that when trying to add to linked lists within an array it would seem to not work and I'm almost totally ignorant as to why this is. First I declare the object move as seen below:
struct move {
move(int startX, int startY, int endX, int endY)
{
this->startX = startX;
this->startY = startY;
this->endX = endX;
this->endY = endY;
this->next = nullptr;
}
move()
{
next = nullptr;
this->startX = -1;
}
int startX;
int startY;
int endX;
int endY;
move* next;
};
I then declare 2 arrays, one which contains 100 linked lists of the moveobject and another which contains pointers to elements in each of the linked lists in the first array. As seen below:
move possibleMoves[100];
move * endOfLists[100];
I then initialise these arrays as seen below:
for (int i = 0; i < 100; i++) {
possibleMoves[i] = move();
endOfLists[i] = &possibleMoves[i];
}
Moving onto the function itself which adds to one of the linked lists within the possibleMoves array I prototype it as such:
void listAdd(move * list, move * object, int width);
I call it as such:
if (possibleMoves[0].startX == -1) {
possibleMoves[0] = *(new move(x, y, x + xOffset, y + yOffset));
}else {
listAdd(endOfLists[width], new move(x, y, x + xOffset, y + yOffset), width);
}
And the function is declared as such:
void listAdd(move * list, move * object, int width) {
int count = 0;
while (list->next != nullptr){
count++;
list = (*list).next;
}
std::cout << "\nCount: " << count << std::endl;
list->next = object;
endOfLists[width] = list->next;
}
Count always outputs as '0'.
Here is a link to all the code (https://pastebin.com/E5g58N6L) it's not pretty. The listAdd procedure is called on lines 188, 197 and 444. Here is the MCVE:
#include<stdio.h>
#include <stdlib.h>
#include<math.h>
#include<iostream>
struct move {
move(int startX, int startY, int endX, int endY)
{
this->startX = startX;
this->startY = startY;
this->endX = endX;
this->endY = endY;
this->next = nullptr;
}
move()
{
next = nullptr;
this->startX = -1;
}
int startX;
int startY;
int endX;
int endY;
move* next;
};
void listAdd(move * list, move * object, int width);
move possibleMoves[100];
move * endOfLists[100];
int main() {
int x = 0;
int y = 0;
int xOffset = 1;
int yOffset = 1;
int width = 0;
for (int i = 0; i < 100; i++) {
possibleMoves[i] = move();
endOfLists[i] = &possibleMoves[i];
}
if (possibleMoves[0].startX == -1) {
possibleMoves[0] = *(new move(x, y, x + xOffset, y + yOffset));
}else {
listAdd(endOfLists[width], new move(x, y, x + xOffset, y + yOffset), width);
}
void listAdd(move * list, move * object, int width) {
int count = 0;
while (list->next != nullptr)
{
count++;
list = (*list).next; //Go down the list until it reaches an item with nothing next.
}
std::cout << "\nCount: " << count << std::endl;
list->next = object;
endOfLists[width] = list->next;
}

Answer 1

NM the full code. You don't tell us what the initial width is, but assuming it's valid (that is -1<width<100), it doesn't matter. Look at what happens here (end of add function):
list->next = object;
At this point list is endOfLists[width]. Now, you properly set the next to the new object, so far so good.
But what now?
endOfLists[width] = list->next;
So the "head" pointer, saved in the global (why?) is bypassing what it originally pointed to (who has a proper next!) and points directly to a descendant, the new object with NULL next. I'm guessing this wasn't what you want:
Leaking memory 0 - at first static allocation, but this can quickly be dynamic if you call this function the way you did a lot.
The head pointer is still, at the end of the function, an object with NULL next. A new one indeed, but the next is still NULL - so the next call will perform the same actions.
Basically you're swapping the head pointers, while leaking memories. You want to either:
Set the object next first: object->next=endOfLists[width], and set the second line to let endOfLists[width]=object, kind of reversing the list.
Delete the second line, and leave the original head.
Also:
I can't see a good reason for globals
Why is the add function not a move method?
You need to make sure you delete all those new objects.
EDIT
I saw your addition - the first call will always return 0, since all initial objects have NULL nexts, even if you fix your code. You need two calls to the same index (width) at least twice to start testing this.
Graphical addendum
At the beginning we have 100 objects, stored in an array, all looking like this:
head->list->NULL
list here is the object pointed to by endOfLists at some index, and we call that pointer head. Now, we want to add the new object. We enter the addition function, with the first argument endOfLists[width], so this will be our list argument in the function itself.
We immediately skip the while (since our next is already NULL). Getting to the first line above, we now connect our head to the new object:
list->object->NULL
So in the array we have:
head->list->object->NULL
Again, head is the pointer stored in endOfLists[width]. Now we tell endOfLists[width] to swap the head to a different one, setting it equal to list->next, which is object. So how does our memory look like?
head->object->NULL
list->^
Both head (the array cell) and list point to object, and nothing points to list. There we go leaking. Next time we call the function with the updated cell, we will repeat the process, leaking object:
head-> object2->NULL
list->object->^
and so forth.