Klassenkonstruktor von Klasse innerhalb einer Klasse wird nicht erkannt?

Hier das problem:

template<class T> class List
{
        [...]
	private:

		class Node
		{
			public:
				Node(T *e);
         [...]

Implementierung

template<class T> List<T>::Node::Node(T *e)
{
}

Beim compilieren gibt es keinen Fehler.
Wenn der Konstruktor nun von meiner List aufgerufen wird erhalte ich die Meldung das ein nicht aufgelöstes symbol vorliegt.

Definiere ich ihn aber gleichzeitig innerhalb der Klasse

Node(T *e){};

Gibts nen Fehler und er sagt mir das das hier

template<class T> List<T>::Node::Node(T *e)
{
}

Schon in der Klasse definiert wurde.

Wo ist denn da der Fehler?

Jover

Hast du den Konstruktor inline Implementiert?

Alles ist so implementiert wie hier reinkopiert, habs eben mit inline probiert aber das ändert nichts (oder ich hab einen fehler gemacht )

HumeSikkins

krisenalarm schrieb:

Wenn der Konstruktor nun von meiner List aufgerufen wird erhalte ich die Meldung das ein nicht aufgelöstes symbol vorliegt.

Definiere ich ihn aber gleichzeitig innerhalb der Klasse
Node(T *e){};
Gibts nen Fehler und er sagt mir das das hier
template<class T> List<T>::Node::Node(T *e)
{
}
Schon in der Klasse definiert wurde.

Entweder oder. Entweder du implementierst den Ctor in der Klassendefinition oder außerhalb, aber nicht beides gleichzeitig.
Also entweder:

template<class T> 
class List
{
private:
    class Node
    {
        public:
            Node(T *e) {...}
    };
};

oder:

template<class T> 
class List
{
private:
    class Node
    {
        public:
            Node(T *e);
    };
};

// ebenfalls im Header
template <class T>
List<T>::Node::Node(T* e) {...}

genau so hab ichs ja gemacht.

Mit der Variante in der Klasse und außerhalb gleichzeitig wollte ich nur darauf hinweisen das mein konstruktor scheinbar erkannt wird aber dann doch als externes symbol aufgeführt wird.

Genau wie du den Konstruktor geschrieben hast habe ich ihn implementiert. Natürlich in der Headerdatei. Aber ich bekomme immer ein "nicht aufgelöstes symbol". Bei jedem Konstruktor der Klasse Node

Damit ihr mein Problem versteht:

#ifndef list_h
#define list_h

template<class T> class List
{
	public:
		List();
		List(T *e);

		T* operator[](unsigned int pos);

		void Add(T *e);

		T* GetFirst(){ return(first->element); };
		T* GetLast() { return(last->element);  };

		unsigned int GetSize(){ return(size); };

	private:

		class Node
		{
			public:
				Node(T *e){	prev	= NULL;
							next	= NULL;
							element = e;};

				Node(T *e, Node *previous){	previous->next = this;

											prev	= previous;
											next    = NULL;
											element = e;};

				Node* GoPrev(){ return(prev); };
				Node* GoNext(){ return(next); };

	//		private:
				Node *prev, *next;
				T *element;

		};

		Node *first, *last;
		unsigned int size;
};

//-----------------------------------------------------------------------------------------//

template<class T> List<T>::List()
{
	size  =    0;
	first = last = NULL;
}

//-----------------------------------------------------------------------------------------//

template<class T> List<T>::List(T *e)
{
	size = 1;
	last = first = new Node(e);
}

//-----------------------------------------------------------------------------------------//

template<class T> T* List<T>::operator[](unsigned int pos)
{
	if(pos < size)
	{
		Node *tmp = first;

		for(int i=0; i<pos; ++i)
			tmp = tmp->GoNext();

		return(tmp->element);
	}
	else
		return(NULL);
}

//-----------------------------------------------------------------------------------------//

template<class T> void List<T>::Add(T *e)
{
	if(first == NULL)
	{
		first = new Node(e);
		last  = first;
	}
	else
		last = new Node(e, last);

	++size;
}

//-----------------------------------------------------------------------------------------//

/* Implementation der Klasse Node */

//-----------------------------------------------------------------------------------------//

/*
template<class T> List<T>::Node::Node(T *e)
{
	prev	= NULL;
	next	= NULL;
	element = e;
}
*/

//-----------------------------------------------------------------------------------------//

/*
template<class T> List<T>::Node::Node(T *e, Node *previous)
{
	previous->next = this;

	prev	= previous;
	next    = NULL;
	element = e;
}
*/

//-----------------------------------------------------------------------------------------//

#endif

Ganz unten sind die Konstruktoren die nicht funktionieren.
Ihr könnt euch ja eine Headerdatei erstellen und das ausprobiere, die implementation in der Klasse entfernen und dann die Kommentare wegnehmen.