Undefined reference to 'Inventory::insertEnd(Node*, int)' - c++

Question

I’m getting an “undefined reference to” error when trying to build/compile my program:
obj\Debug\main.o||In function main':|
C:\Users\user1\Desktop\Project5Example\main.cpp|13|undefined reference toInventory::insertEnd(Node*, int)'|
...
||error: ld returned 1 exit status|
||=== Build failed: 4 error(s), 0 warning(s) (0 minute(s), 1 second(s)) ===|
I’m quite new to c++. What am I doing wrong? and how can I fix it?
I feel is has to do with my head node? But can’t really figure out how what it is.
The error happens on main.cpp line head = inventory1.insertEnd(head, 8);
Here is my code:
Inventory.h
#ifndef INVENTORY_H
#define INVENTORY_H
#include <cstdlib>
#include <fstream>
#include <iomanip>
#include <iostream>
#include <string>
using namespace std;
struct Node
{
int data;
Node* next;
};
class Inventory
{
public:
// Default Constructor
Inventory();
// MODIFICATION MEMBER FUNCTIONS
Node *newNode(int data);
Node* insertEnd(Node* head, int data);
private:
// Data members
Node *head;
Node *trailer;
};
#endif // INVENTORY_H
Inventory.cpp
#include "Inventory.h"
#include <cstdlib>
#include <fstream>
#include <iomanip>
#include <iostream>
#include <string>
#include <bits/stdc++.h>
using namespace std;
Inventory::Inventory()
{
// Set the header and trailer to NULL
head = NULL;
trailer = NULL;
}
// Allocates a new node with given data
Node *newNode(int data)
{
Node *new_node = new Node;
new_node->data = data;
new_node->next = NULL;
return new_node;
}
// Function to insert a new node at the
// end of linked list using recursion.
Node* insertEnd(Node* head, int data)
{
// If linked list is empty, create a
// new node (Assuming newNode() allocates
// a new node with given data)
if (head == NULL)
return newNode(data);
// If we have not reached end, keep traversing
// recursively.
else
head->next = insertEnd(head->next, data);
return head;
}
main.cpp
#include <iostream>
#include "Inventory.h"
using namespace std;
int main()
{
// Create an inventory list
Inventory inventory1;
Node* head = NULL;
head = inventory1.insertEnd(head, 8);
head = inventory1.insertEnd(head, 11);
head = inventory1.insertEnd(head, 20);
return 0;
}

Answer 1

For starters the structure Node should be a private member of the class Inventory. Correspondingly the class Inventory should not contain public member functions that have the return type Node *. So for example this member function
Node *newNode(int data);
should be removed. In turn this public member function
Node* insertEnd(Node* head, int data);
should be declared like
void insertEnd( int data );
If it is required (but it is not required) the function could call a private static member function declared like
static Node* insertEnd(Node* head, int data);
As you declared a two-sided singly-linked list then it does not make sense to define the function insertEnd as a recursive function because there is no recursion. A new node ia appended to the node that you named like trailer though it would be better to name it like tail.
Moreover in the definitions of the functions newNode and insertEnd you forgot to specify name of the class Inventory like
Node * Inventory::newNode(int data)
{
//...
}
Node * Inventory::insertEnd(Node* head, int data)
{
//...
}
And this part in main
Inventory inventory1;
Node* head = NULL;
head = inventory1.insertEnd(head, 8);
head = inventory1.insertEnd(head, 11);
head = inventory1.insertEnd(head, 20);
does not make sense. The object inventory1 already contains the data member head (and trailer) that should be updated for the object.
The class can be defined for example the following way as it is shown in the demonstrative program below.
#include <iostream>
class Inventory
{
public:
Inventory() = default;
Inventory( const Inventory & ) = delete;
Inventory & operator =( const Inventory & ) = delete;
~Inventory();
void insertEnd( int data );
void clear();
friend std::ostream & operator <<( std::ostream &, const Inventory & );
private:
struct Node
{
int data;
Node *next;
} *head = nullptr, *tail = nullptr;
};
Inventory::~Inventory()
{
clear();
}
void Inventory::insertEnd( int data )
{
Node *node = new Node { data, nullptr };
if ( tail == nullptr )
{
head = tail = node;
}
else
{
tail = tail->next = node;
}
}
void Inventory::clear()
{
while ( head != nullptr )
{
Node *node = head;
head = head->next;
delete node;
}
tail = head;
}
std::ostream & operator <<( std::ostream &os, const Inventory &inventory )
{
for ( Inventory::Node *node = inventory.head; node != nullptr; node = node->next )
{
os << node->data << " -> ";
}
return os << "null";
}
int main()
{
Inventory inventory;
for ( const auto &data : { 0, 1, 2, 3, 4, 5, 6, 7, 8, 9 } )
{
inventory.insertEnd( data );
}
std::cout << inventory << '\n';
return 0;
}
The program output is
0 -> 1 -> 2 -> 3 -> 4 -> 5 -> 6 -> 7 -> 8 -> 9 -> null