undefined reference general errors - c++

Question

I'm supposed to implement the functionality of a stack and I was given the main.cpp file and was left to write the other files, namely StackofNodes.hpp & .h. These depend on two other files Node.hpp & .h. When I try to build the program I get errors on the main.cpp file that was given to me. This are:
obj/Debug/main.o||In function `main':|
|6|undefined reference to `StackOfNodees<int>::StackOfNodees()'|
|12|undefined reference to `StackOfNodees<int>::push(int)'|
|17|undefined reference to `StackOfNodees<int>::size() const'|
|24|undefined reference to `StackOfNodees<int>::pop()'|
main.cpp
#include <iostream> //std::cout std::cin
#include "StackOfNodees.h" //StackOfNodes
int main()
{
StackOfNodees<int> myStack; //Create an empty stack
int sizeOfStack; //int we'll use later to store the size of the stack
//push some numbers onto the stack
for(int i = 1; i <= 10; i++)
{
myStack.push( i * 5 );
}
//Store the size of the stack before popping anything
sizeOfStack = myStack.size();
std::cout << "There are " << sizeOfStack << " items on the stack" << std::endl;
//Think about why we don't use i<myStack.size()
for(int i = 0; i < sizeOfStack; i++)
{
std::cout << "Popping the top: " << myStack.pop() << std::endl;
}
/* while(!myStack.isEmpty()) is another valid way to pop all the contents of the stack */
}
StackOfNodees.hpp
#ifndef STACKOFNODEES_HPP_INCLUDED
#define STACKOFNODEES_HPP_INCLUDED
StackOfNodees::StackOfNodees()
{
m_top=nullptr;
m_size=0;
}
bool StackOfNodees::isEmpty() const
{
if (m_size==0)
{
return true;
}
return false;
}
int StackOfNodees::size() const
{
return m_size;
}
void StackOfNodees::push(int value)
{
Node* Node1 = new Node;
Node1 -> m_previous = m_top;
m_top=Node1;
Node1 -> m_value = value;
++m_size;
}
int StackOfNodees::pop()
{
// initialize
int returnval = 0;
if (!isEmpty())
{
// fetch the value from the top one
returnval = m_top -> m_value;
Node* temp = m_top;
//move m_top down to previous box.
m_top = m_top -> m_previous;
//delete the popped one
delete temp;
m_size--;
}
else
{
// you may want to throw an exception here for popping a empty stack
}
return returnval;
}
#endif // STACKOFNODEES_HPP_INCLUDED
Node.h
#ifndef NODE_H_INCLUDED
#define NODE_H_INCLUDED
template<typename T>
Node<T>::Node()
{
Node.setPrevious(nullptr);
Node.setValue();
}
//initiation of getters
template<typename T>
T Node::getValue()
{
return m_value;
}//end getValue
template<typename int>
int Node::getPrevious()
{
return m_previous;
}//end getPrevious
//initiation of setters
template<typename void>
void Node::setValue(T value)
{
m_value = value;
}//end setValue
template<typename void>
void Node::setPrevious(Node<T>* previous)
{
Node<T>* previous = m_previous;
}//end setPrevious
StackOfNodees.h
#ifndef STACKOFNODEES_H_INCLUDED
#define STACKOFNODEES_H_INCLUDED
#include "Node.h"
template<typename T>
class StackOfNodees
{
private:
Node<T>* m_top;
int m_size;
public:
StackOfNodees();
bool isEmpty() const;
int size() const;
void push(T value);
T pop();
};
#endif // STACKOFNODEES_H_INCLUDED
Any help would be much appreciated. Thanks!

Answer 1

You do not have methods of template class StackOfNodees defined.
You need to have
template<typename T>
StackOfNodees<T>::StackOfNodees()
{
m_top=nullptr;
m_size=0;
}
Rather than
StackOfNodees::StackOfNodees()
{
m_top=nullptr;
m_size=0;
}
Change all definitions and move them into StackOfNodees.h file from .hpp. You do not need an extra .hpp file.
Example:
// File a.h
template<typename T>
class A
{
public:
A();
// the rest of the class ....
};
template<typename T>
A<T>::A()
{
// ...
}
file app.cpp
#include "a.h"
void main()
{
A<int> a;
...
}
An extra .hpp file makes code less readable as it breaks reading flow. If you are still required to split your code in that manner then you need to include .hpp into .h file with #include "StackOfNodes.hpp" instruction in the bottom of .h file (a rather unconventional approach).

Answer 2

When you are writing a template class, you must provide definition of the template class in the same file where the declaration itself lies, so that the compiler can instantiate the actual class when compiling.
In this specific case, put the definitions in StackOfNodees.hpp back to the template class declaration in the file StackOfNodees.h after changing this int specific one to general type T one. This is a simple tutorial about the format of a template class.