DoublyLinkedList from hell

[nolsen01]

I don't want to post to much of my code up, because there is a lot, but I'm not sure where to start.

My project is simply to make a Doubly Linked list in C++. I've been working on the same project for weeks because of this one error. Its quite frustrating:

1>main.obj : error LNK2019: unresolved external symbol "public: class DLNode<class std::basic_string<char,struct std::char_traits<char>,class std::allocator<char> > > * __thiscall DLNode<class std::basic_string<char,struct std::char_traits<char>,class std::allocator<char> > >::getPredecessor(void)" (?getPredecessor@?$DLNode@V?$basic_string@DU?$char_traits@D@std@@V?$allocator@D@2@@std@@@@QAEPAV1@XZ) referenced in function "public: void __thiscall DoublyLinkedList<class std::basic_string<char,struct std::char_traits<char>,class std::allocator<char> > >::addAtTail(class std::basic_string<char,struct std::char_traits<char>,class std::allocator<char> >)" (?addAtTail@?$DoublyLinkedList@V?$basic_string@DU?$char_traits@D@std@@V?$allocator@D@2@@std@@@@QAEXV?$basic_string@DU?$char_traits@D@std@@V?$allocator@D@2@@std@@@Z)
1>C:\Users\Nick\Documents\Visual Studio 2008\Projects\NewDoublyLinkedList\Debug\NewDoublyLinkedList.exe : fatal error LNK1120: 1 unresolved externals

the basic layout of the program is:

first header file contains a class (and its methods) called SLNode (stands for Singly Linked Node). It has contains a pointer to an SLNode called successor and also a reference to whatever element is being stored. (using generics)

second header file conatains a DLNode class. it contains to pointer to a DLNode called predecessor. DLNode inherits SLNode.

third header file contains a class DoublyLinkedList. It contains (among other things) a method called addAtTail, which is where this error seems to come from.


DLNode has a getPredecessor and setPredecessor method aswell as getSuccessor and setSuccessor method via inheritance through the SLNode class.

Here is some code of possible value, if you need more, let me know:

template <class E>
void DoublyLinkedList<E>::addAtTail(E theElement)
{
	DLNode<E> newNode(theElement);
	DLNode<E> *previousNode = tail.getPredecessor(); //returns a pointer

	newNode.setSuccessor(&tail);
	newNode.setPredecessor(previousNode);
	previousNode->setSuccessor(&newNode);
	tail.setPredecessor(&newNode);
}

template <class E>
DLNode<E> DLNode<E>::*getPredecessor()
{
	return this->predecessor;
}

[WingedPanther]

Is the definition for DLNode included into this file?

[nolsen01]

Here is my code:

DoublyLinkedList.h

#ifndef DOUBLYLINKEDLIST_H
#define DOUBLYLINKEDLIST_H

#include "DLNode.h"

template <class E>
class DoublyLinkedList
{
private:
	DLNode<E> *head;
	DLNode<E> *tail;
	int length;
public:
	DoublyLinkedList();
	E getElementAt(int pos);
	DLNode<E> find(int pos);
	void addAtHead(E theElement);
//	void addAtTail(E theElement);
	void add(E theElement, int p);
	E remove(int p);
};

template <class E>
DoublyLinkedList<E>::DoublyLinkedList()
{

	DLNode<E> newTailNode;
	DLNode<E> newHeadNode;
	this->tail = &newTailNode;
	this->head = &newHeadNode;
	newTailNode.setSuccessor(*tail);
	newTailNode.setPredecessor(NULL);
	newHeadNode.setPredecessor(*head);
	newHeadNode.setSuccessor(NULL);

	this->length = 0;
}

template <class E>
E DoublyLinkedList<E>::getElementAt(int pos)
{
	if (pos > this->length)
		return NULL;
	else if(pos < 0)
		return NULL;
	else if(pos == 0)
		return NULL;

	return find(pos).getElement();
}

template <class E>
DLNode<E> DoublyLinkedList<E>::find(int pos)
{
	DLNode<E> cursor = head.returnSuccessor();

	int i = 0;
	while(i != pos)
	{
		cursor = cursor.getSuccessor();
		i++;
	}

	return cursor;
}

template <class E>
void DoublyLinkedList<E>::addAtHead(E theElement)
{
	DLNode<E> newNode(theElement, (DLNode<E> *)head->getSuccessor(), head);
	DLNode<E> *node2 = (DLNode<E> *)head->getSuccessor();
	node2->setPredecessor(newNode);
	head->setSuccessor(newNode);
}

/*
template <class E>
void DoublyLinkedList<E>::addAtTail(E theElement)
{
	DLNode<E> newNode(theElement);
	//DLNode<E> previousNode; 
	//previousNode.setEqualTo(tail.getPredecessor());

	newNode.setSuccessor(this->tail);
	newNode.setPredecessor(this->tail->getPredecessor());
	tail->getPredecessor()->setSuccessor(&newNode);
	tail->setPredecessor(&newNode);
}
*/


#endif

SLNode.h

#ifndef _SLNODE_H
#define _SLNODE_H

template <class E>
class SLNode
{
private:
	E element;
	SLNode<E> *successor;
public:
	SLNode();
	SLNode(E theElement);
	SLNode(E theElement, SLNode<E> theSuccessor);
	E getElement();
	void setElement(E newElement);
	SLNode<E> *getSuccessor();
	void setSuccessor(SLNode<E> newSuccessor);
	//SLNode<E> &operator = (SLNode<E> node);
};

template <class E>
SLNode<E>::SLNode()
{
	this->successor = NULL;
	this->element = NULL;
}

template <class E>
SLNode<E>::SLNode(E theElement)
{
	this->successor = NULL;
	this->element = theElement;
}


template <class E>
SLNode<E>::SLNode(E theElement, SLNode<E> theSuccessor)
{
	this->element = theElement;
	this->successor = &theSuccessor;
}

template <class E>
E SLNode<E>::getElement()
{
	return this->element;
}

template <class E>
void SLNode<E>::setElement(E newElement)
{
	this->element = newElement;
}

template <class E>
SLNode<E> *SLNode<E>::getSuccessor()
{
	return this->successor;
}

template <class E>
void SLNode<E>::setSuccessor(SLNode<E> newSuccessor)
{
		this->successor = &newSuccessor;
}


#endif

DLNode.h:

#ifndef _DLNODE_H
#define _DLNODE_H
#include "SLNode.h"

template <class E>

class DLNode : public SLNode<E>
{
private:
	DLNode<E> *predecessor;
public:
	DLNode();
	DLNode(E &theElement);
	DLNode(E theElement, DLNode<E>	*theSuccessor, DLNode<E> *thePredecessor);
	DLNode<E> *getPredecessor();
	void setPredecessor(DLNode<E> newSuccessor);
	//void setEqualTo(DLNode<E> *newNode);
};

template <class E>
DLNode<E>::DLNode():SLNode()
{
	this->setPredecessor(NULL);
}

template <class E>
DLNode<E>::DLNode(E &theElement):SLNode(theElement)
{
	this->setPredecessor(NULL);
}

template <class E>
DLNode<E>::DLNode(E theElement, DLNode<E> *theSuccessor, DLNode<E> *thePredecessor)
{
	this->setSuccessor(*theSuccessor);
	this->setElement(theElement);
	this->setPredecessor(*thePredecessor);
	
}

template <class E>
DLNode<E> *DLNode<E>::getPredecessor()
{
	return this->predecessor;
}

template <class E>
void DLNode<E>::setPredecessor(DLNode<E> newPredecessor)
{
	this->predecessor = &newPredecessor;
}

#endif

I've changed quite a bit since I've posted the original problem. Originally, I was going to create an addAtTail() method but even my professor can't seem to figure this one out so I tried instead to just write an addAtHead() method and worry about it later. I'm still running into problems.