Link errors with my Doubly Linked List Class Template?

[MisterTams]

I keep getting Link errors when trying to run my code. I have 4 LNK2019 Errors saying that there is "unresolved external symbol". So I assume at run-time the compiler cannot find my function definitions?

*UPDATE* I just did some more research and it appears that placing the function template definitions in the .h file fixes this problem. I just tried this in Visual Studio and can confirm that it fixed my issue. Is there any easy way around this issue so that I can have a .h file and .cpp file separately for a class template declaration and its function template implementations?

Here is the main .cpp file that I use to drive my program.

#include <iostream>
#include <string>
#include "ListClass.h"
#include "DLLTemplate.h"
using namespace std;

int main()
{
	ListClass list;
	DLLTemplate<double> TemplateList;
	char choice;
	double value, position;
	string text, whichText;

	TemplateList.addAtBeginning(5.0);
	TemplateList.addInMiddle(2.0, 5.0);
	TemplateList.addAtEnd(19.0);
	TemplateList.addAtEnd(21.0);
	TemplateList.PrintForward();
        
        return 0;
}

DLLTemplate.h

#include <iostream>
#include <string>
using namespace std;

template <class T>
#ifndef DLLTEMPLATE_H
#define DLLTEMPLATE_H

class DLLTemplate
{
private:
	struct ListNode
	{
		T value;
		struct ListNode *next;
		struct ListNode *prev;
	};

	ListNode *head;
	ListNode *tail;

public:
	DLLTemplate() //Constructor
	{
		head = nullptr;
		tail = nullptr;
		//cout << "hello" << endl;
	}

	~DLLTemplate()
	{
		ListNode *NodePtr;
		ListNode *nextNode;
		NodePtr = head;

		while (NodePtr != nullptr)
		{
			nextNode = NodePtr->next;
			cout << " deleting ... " << NodePtr->value << endl;
			delete NodePtr;
			NodePtr = nextNode;
		}
	}

	//doubly linked list operations
	void addAtEnd(T);
	void addAtBeginning(T);
	void addInMiddle(T, T);
	bool checkPosition(T);
	void DeleteFirst();
	void DeleteLast();
	void DeleteValue(T);
	void PrintForward() const;
	void PrintReverse() const;
};

#endif 

Finally, the DLLTemplate.cpp with the function implementations.

#include "DLLTemplate.h"
#include <iostream>
#include <string>
using namespace std;

template <class T>
void DLLTemplate<T>::addAtEnd(T val)
{
	ListNode *newNode; //points at a new Node
	ListNode *NodePtr; // used to traverse the list

	newNode = new ListNode;
	newNode->value = val;
	newNode->next = nullptr;
	newNode->prev = tail;

	if (head == nullptr)
	{
		head = newNode;
		tail = newNode;
	}
	else
	{
		NodePtr = head;

		while (NodePtr->next != nullptr)
			NodePtr = NodePtr->next;

		NodePtr->next = newNode;
		tail->next = newNode;
		tail = newNode;
	}
}

template <class T>
void DLLTemplate<T>::addAtBeginning(T val)
{
	ListNode *newNode;

	newNode = new ListNode;
	newNode->value = val;
	newNode->next = head;
	newNode->prev = nullptr;

	if (head == nullptr)
	{
		head = newNode;
		tail = newNode;
	}
	else
	{
		head->prev = newNode;
		head = newNode;
	}
}

template <class T>
void DLLTemplate<T>::addInMiddle(T val, T position)
{
	ListNode *newNode;
	ListNode *NodePtr;

	newNode = head;

	newNode = new ListNode;
	newNode->value = val;
	newNode->next = nullptr;

	if (head == nullptr)
	{
		head = newNode;
		tail = newNode;
	}
	else if (tail->value == position)
	{
		NodePtr = head;
		newNode->prev = tail;

		while (NodePtr->next != nullptr)
		{
			NodePtr = NodePtr->next;
		}

		NodePtr->next = newNode;
		tail->next = newNode;
		tail = newNode;
	}
	else
	{
		NodePtr = head;

		while (NodePtr->next != nullptr && NodePtr->value != position)
		{
			NodePtr = NodePtr->next;
		}

		newNode->next = NodePtr->next;
		NodePtr->next = newNode;
		newNode->prev = NodePtr;
		NodePtr = NodePtr->next->next;
		NodePtr->prev = newNode;

	}
}

template <class T>
bool DLLTemplate<T>::checkPosition(T val)
{
	ListNode *NodePtr;
	NodePtr = head;
	bool found = false;

	while (NodePtr != nullptr)
	{
		if (NodePtr->value == val)
		{
			found = true;
			break;
		}
		NodePtr = NodePtr->next;
	}

	return found;
}

template <class T>
void DLLTemplate<T>::DeleteFirst()
{
	ListNode *NodePtr;

	if (head != nullptr)
	{
		NodePtr = head->next;
		delete head;
		head = NodePtr;
		head->prev = nullptr;
	}
	else
		cout << "list is empty" << endl;
}

template <class T>
void DLLTemplate<T>::DeleteLast()
{
	ListNode *NodePtr;
	if (tail != nullptr)
	{
		NodePtr = tail->prev;
		delete tail;
		tail = NodePtr;
		tail->next = nullptr;
	}
	else
		cout << "list is empty" << endl;
}

template <class T>
void DLLTemplate<T>::DeleteValue(T val)
{

	bool found = false;
	found = checkPosition(val);

	if (found == true)
	{
		ListNode *NodePtr;
		ListNode *prevPtr = nullptr;

		if (head != nullptr)
		{
			if (head->value == val)
			{
				NodePtr = head->next;
				delete head;
				head = NodePtr;
				head->prev = nullptr;
			}
			else if (tail->value == val)
			{
				NodePtr = tail->prev;
				delete tail;
				tail = NodePtr;
				tail->next = nullptr;
			}
			else
			{
				NodePtr = head;

				while (NodePtr != nullptr && NodePtr->value != val)
				{
					prevPtr = NodePtr;
					NodePtr = NodePtr->next;
				}
				if (NodePtr != nullptr)
				{
					prevPtr->next = NodePtr->next;
					delete NodePtr;
					NodePtr = prevPtr->next;
					NodePtr->prev = prevPtr;
				}
			}
		}
	}
	else if (found == false && head == nullptr)
		cout << "list is empty" << endl;
	else if (found == false && head != nullptr)
		cout << "The value: " << val << " was not found in this list..." << endl;
}

template <class T>
void DLLTemplate<T>::PrintForward() const
{
	ListNode *NodePtr;

	NodePtr = head;
	cout << "Printing Forward..." << endl;
	while (NodePtr != nullptr)
	{
		cout << "value: " << NodePtr->value << endl;
		NodePtr = NodePtr->next;
	}
	cout << "-------------" << endl;
	cout << "Head: " << head->value << endl;
	cout << "Tail: " << tail->value << endl;
	cout << endl;
}

template <class T>
void DLLTemplate<T>::PrintReverse() const
{
	ListNode *NodePtr;

	NodePtr = tail;
	cout << "Printing In Reverse..." << endl;
	while (NodePtr != nullptr)
	{
		cout << "value: " << NodePtr->value << endl;
		NodePtr = NodePtr->prev;
	}
	cout << "-------------" << endl;
	cout << "Head: " << head->value << endl;
	cout << "Tail: " << tail->value << endl;
	cout << endl;
}

So the question is, how can I fix these link errors? I was under the impression that everything in the code is correct.
]

[MisterTams]

When I use the a non class template object like the list that I created, I don't have any problems. Only when using a class template do I get the link errors.
Example... this code below will compile just fine.

#include <iostream>
#include <string>
#include "ListClass.h"
#include "DLLTemplate.h"
using namespace std;

int main()
{
	ListClass list;
	DLLTemplate<double> TemplateList;
	char choice;
	double value, position;
	string text, whichText;

	list.addAtBeginning(5.0);
	list.addInMiddle(2.0, 5.0);
	list.addAtEnd(19.0);
	list.addAtEnd(21.0);
	list.PrintForward();

        return 0;
}

[dhayden]

Is there any easy way around this issue so that I can have a .h file and .cpp file separately for a class template declaration and its function template implementations?

The compiler has to know the implementation code at compile time so it can instantiate the template. To separate the declaration from the code, put the code in a DLLTemplate.i and add #include "DLLTemplate.i" at the bottom of DLLTemplate.h.

[JLBorges]

> Is there any easy way around this issue so that I can have a .h file and .cpp file separately
> for a class template declaration and its function template implementations?

Yes, provided that you know before hand all the template arguments for which the template needs to be instantiated in the program.

An explicit instantiation declaration (an extern template) skips implicit instantiation step: the code that would otherwise cause an implicit instantiation instead uses the explicit instantiation definition provided elsewhere (resulting in link errors if no such instantiation exists). This can be used to reduce compilation times by explicitly declaring a template instantiation in all but one of the source files using it, and explicitly defining it in the remaining file.

http://en.cppreference.com/w/cpp/language/class_template

[globaltourist]

As @dhayden said you can put the code in a #include "DLLTemplate.i" and include it at the buttom of the .h file or you could do it as a .cpp that it included at the end of a .h although both should generally be avoided (perfectly you should never include a .cpp in a .h file), but as an example:

templated_code.h:
--------------------

#ifndef TEMPLATED_CODE_H
#define TEMPLATED_CODE_H

//your class declaration with its template goes here

#include "templated_code.cpp"

#endif 

templated_code.cpp:
----------------------

#include templated_code.h

//implementation goes here 

OR you have another option:
in your .cpp file simply add at the end of the file:
template class DLLTemplate<double>;
however it will only work when you make a double list, if you would want to use an int list you should add:
template class DLLTemplate<int>;
to the end of the file (just change to the type you want to use insode of the <>).