ich habe eine kleine doppelt verkettete Liste für mich geschrieben, welche einwandfrei funktionierte als normale Klasse. Anschließend habe ich sie zu einer Template gemacht und erst hat die IDE (VC++.NET2003) einen Teil der Memberfunktions-Implementierungen nicht mehr gefunden (, nach längerer, erfolgloser Fehlersuche habe ich das dann ignoriert,) und beim Linken hat sich der Linker beschwert, dass er die (alle) Memberfunktionen (incl. Ctor und Dtor) nicht findet ( - über jede benutzte Funktion einzeln, aber auch nur über die benuzten).

Weiß jemand was ich falsch gemacht habe und wie ich es korrigieren kann?
Den Quelltext schicke ich freundlichen Helfern gerne auf Anfrage per eMail.

mfG PGroe

Müsste in der FAQ erklärt werden.

Ponto schrieb:

Pack die Funktionen von der .cpp Datei in die .hpp Datei.

Hat aber leider nicht geholfen.

Ponto schrieb:

Müsste in der FAQ erklärt werden.

Ich hab danach gesucht, aber nichts gefunden.

mfG PGroe

glaskugel verlegt

Solltest du auf jeden Fall wieder finden!

camper schrieb:

code posten!

Gern! Wollte ich ursprünglich per eMail schicken, da er ein bisschen umfangreicher ist.

DataList.hpp

#ifndef DATALIST_HEAD
#define DATALIST_HEAD

#include "DataNode.hpp"

template<class T>
class DataList
{
public:
	DataList();
	DataList(const T * const Array, int ArraySize);
	DataList(const DataList & rhs);
	~DataList();
	void Clear();
	int GetLength() const {return MyLength;}
	DataList & operator=(const DataList & rhs);
	DataList & operator+=(const DataList & rhs);
	DataList & operator+=(const DNode<T> & rhs);
	DataList & operator+=(const T & rhs);
	int push_front(const T &);
	T pop_front();
	int push_back(const T &);
	T pop_back();
	void Insert(const T & rhs, int Position = 0);
	T Remove(int Position = 0);
	const T & operator[](int ID) const;
	T & operator[](int ID);

	T * ToArray(int & ArraySize) const;

private:
	DNode<T> * GetNode(int Position) const;

	DNode<T> * dnFirst;
	DNode<T> * dnLast;
	int MyLength;
};

#endif

#ifdef DATALIST_CODE
#define DATALIST_CODE

#include "stdafx.hpp"

template<class T>
DataList<T>::DataList() : dnFirst(0), dnLast(0), MyLength(0)
{
}

template<class T>
DataList<T>::DataList(const T * const Array, int Size) : dnFirst(0), dnLast(0), MyLength(0)
{
	for (int i = 0; i < Size; i++)
		this->push_back(Array[i]);
}

template<class T>
DataList<T>::DataList(const DataList & rhs) : dnFirst(0), dnLast(0)
{
	*this = rhs;
}

template<class T>
DataList<T>::~DataList()
{
	this->Clear();
}

template<class T>
void DataList<T>::Clear()
{
	if (! this->MyLength) return;
	DNode<T> * dnAct = 0;
	DNode<T> * dnANext = dnFirst;
	while (dnANext)
	{
		dnAct = dnANext;
		dnANext = dnAct->dnNext;
		delete dnAct;
	}
	this->MyLength = 0;
}

template<class T>
DataList<T> & DataList<T>::operator= (const DataList & rhs)
{
	if (this == &rhs) return *this;
	this->Clear();
	for (int i = 0; i < rhs.MyLength; i++)
		this->push_back(rhs[i]);
	return *this;
}

template<class T>
DataList<T> & DataList<T>::operator+= (const DataList & rhs)
{
	for (int i = 0; i < rhs.MyLength; i++)
		this->push_back(rhs[i]);
	return *this;
}

template<class T>
DataList<T> & DataList<T>::operator+= (const DNode<T> & rhs)
{
	this->push_back(*(rhs.MyData));
	return *this;
}

template<class T>
DataList<T> & DataList<T>::operator+= (const T & rhs)
{
	this->push_back(rhs);
	return *this;
}

template<class T>
int DataList<T>::push_front(const T & rhs)
{
	this->dnFirst = (this->dnFirst->dnPrev = new DNode<T>(new T(rhs), 0, this->dnFirst));
	if (! this->MyLength) this->dnLast = this->dnFirst;
	this->MyLength++;
	return 0;
}

template<class T>
T DataList<T>::pop_front()
{
	if (! this->MyLength) throw YouMayNotDoThis_Error();
	T TempVal(*(this->dnFirst->MyData));
	DNode<T> * NodeToDelete = this->dnFirst;
	(this->dnFirst = this->dnFirst->dnNext)->dnPrev = 0;
	delete NodeToDelete;
	this->MyLength--;
	return TempVal;
}

template<class T>
int DataList<T>::push_back(const T & rhs)
{
	this->dnLast = (this->dnLast->dnNext = new DNode<T>(new T(rhs), this->dnLast, 0));
	if (! this->MyLength) this->dnFirst = this->dnLast;
	return this->MyLength++;
}

template<class T>
T DataList<T>::pop_back()
{
	if (! this->MyLength) throw YouMayNotDoThis_Error();
	T TempVal(*(this->dnFirst->MyData));
	DNode<T> * NodeToDelete = this->dnLast;
	(this->dnLast = this->dnLast->dnPrev)->dnNext = 0;
	delete NodeToDelete;
	this->MyLength--;
	return TempVal;
}

template<class T>
void DataList<T>::Insert(const T & rhs, int Pos)
{
	DNode<T> * NextNode = this->GetNode(Pos);
	if (!NextNode) return;
	NextNode->dnPrev = (NextNode->dnPrev->dnNext = new DNode<T>(new T(rhs), NextNode->dnPrev, NextNode));
	this->MyLength++;
}

template<class T>
T DataList<T>::Remove(int Pos)
{
	DNode<T> * NodeToDelete = this->GetNode(Pos);
	if (!NodeToDelete) throw YouMayNotDoThis_Error();
	T TempVal(*(NodeToDelete->MyData));
	(NodeToDelete->dnNext->dnPrev = NodeToDelete->dnPrev)->dnNext = NodeToDelete->dnNext;
	delete NodeToDelete;
	this->MyLength--;
	return TempVal;
}

template<class T>
const T & DataList<T>::operator[](int ID) const
{
	DNode<T> * RetNode = GetNode(ID);
	if (!RetNode) throw YouMayNotDoThis_Error();
	return *(RetNode->MyData);
}

template<class T>
T & DataList<T>::operator[](int ID)
{
	DNode<T> * RetNode = GetNode(ID);
	if (!RetNode) throw YouMayNotDoThis_Error();
	return *(RetNode->MyData);
}

template<class T>
T * DataList<T>::ToArray(int & Size) const
{
	if (! this->MyLength) throw YouMayNotDoThis_Error();
	T * RetValue = new T[this->MyLength];
	DNode<T> * dnAct = this->dnFirst;
	for (int i = 0; i < this->MyLength; i++)
	{
		RetValue[i] = *(dnAct->MyData);
		dnAct = dnAct->dnNext;
	}
	Size = this->MyLength;
	return RetValue;
}

template<class T>
DNode<T> * DataList<T>::GetNode(int Position) const
{
	if (Position < 0) return 0;
	if (Position < (this->MyLength / 2))
	{
		DNode<T> * ActNode = this->dnFirst;
		for (int i = 0; i < Position; i++)
			ActNode = ActNode->dnNext;
		return ActNode;
	}
	if (Position < this->MyLength)
	{
		DNode<T> * ActNode = this->dnLast;
		for (int i = (this->MyLength - 1); i > Position; i--)
			ActNode = ActNode->dnPrev;
		return ActNode;
	}
	return 0;
}

#endif

DataNode.hpp

#ifndef DATANODE_HEAD
#define DATANODE_HEAD

template<class T>
class DataList;

template<class T>
class DNode
{
	friend class DataList<T>;

public:
	DNode();
	DNode(T Data, DNode * const Prev = 0, DNode * const Next = 0);
	DNode(T * const, DNode * const Prev = 0, DNode * const Next = 0);
	DNode(const DNode &);
	~DNode();

	DNode * GetPrev() {return dnPrev;}
	DNode * GetNext() {return dnNext;}
	T * GetData() {return MyData;}

private:
	DNode<T> * dnPrev;
	DNode<T> * dnNext;
	T * MyData;
};

#endif

#ifndef DATANODE_CODE
#define DATANODE_CODE

#include "stdafx.hpp"

template<class T>
DNode<T>::DNode() : dnPrev(0), dnNext(0), MyData(0)
{
}

template<class T>
DNode<T>::DNode(T MyNewData, DNode * const dnNewPrev, DNode * const dnNewNext) : dnPrev(dnNewPrev), dnNext(dnNewNext)
{
	MyData = new T(MyNewData);
}

template<class T>
DNode<T>::DNode(T * const MyNewData, DNode * const dnNewPrev, DNode * const dnNewNext) : dnPrev(dnNewPrev), dnNext(dnNewNext), MyData(MyNewData)
{
}

template<class T>
DNode<T>::DNode(const DNode & rhs) : dnPrev(rhs.dnPrev), dnNext(rhs.dnNext)
{
	*MyData = *(rhs.MyData);
}

template<class T>
DNode<T>::~DNode()
{
	delete MyData;
	dnPrev = 0;
	dnNext = 0;
}

#endif

#ifdef DATALIST_CODE
#define DATALIST_CODE

Wenn das nicht gerade ein Tippfehler ist (und ich nehme nicht an Du tippst dermassen viel Code ab), denke mal drüber nach ob der Compiler jemals die zweite Zeile o.g. Auszugs erreicht

(Da fehlt ein n im ifdef)

Das hatte ich völlig übersehen!

Jetzt funktionierts!