Also...

ich habe Klasse

List

template <typename T>
class List {

private:
	ListElement<HashElement<T> >* start;
	int count;

public:

	/**
	* Gibt Pointer auf das naechste Element zurueck.
	*/
	ListElement<HashElement<T> >* getStartListElement(){
		return this->start;
	}

	/**
	* fuegt ein HashElement am Ende der Liste hinzu.
	*/
	void push_back(HashElement<T>* value) {
		ListElement<HashElement<T> >* temp = new ListElement<HashElement<T> >(value, NULL);

		if (this->start == NULL){
			this->start = temp;
			this->count++;
		} else {
			ListElement<T>* temp2 = this->start;

			while( temp2->getNext() != NULL){
				temp2 = temp2->getNext();
			}

			temp2->setNext(temp);
			this->count++;
		}
	}

	/** StandardKonstruktor. */
	List() {
		this->start = NULL;
		this->count = 0;
	}

....
};

Klasse ListElement

template <class T>
class ListElement {

private:
	/** Pointer auf das naechste Element */
	ListElement* next;
	/** Pointer auf ein HashElement */
	T* data;

public:
	/** standardkonstruktor */
	ListElement(T* data, ListElement* next){
		this->data = data;
		this->next = next;
	}

	/**
	* Destruktor.
	*/
	~ListElement(){
		//delete this->next; NOOB!
		delete this->data;
	}

	/** get-Methode */
	T* getElement(){
		return this->data;
	}

	/**Gibt das naechste Element zurueck.
	* @return ListElement*/
	ListElement* getNext(){
		return this->next;
	}

	/**setzt das naechste Element*/
	void setNext(ListElement<T>* nextE){
		this->next = nextE;
	}
};

Klasse HashElement

template <typename T>
class HashElement {

public:
	/** key des Elements */
	MString&    key;
	/** wert des Elements */ //TOCKEN 
	T*         value;
	/** hashcode des Elements. wird aus dem key ausgerechnet */
	int		hashcode; 

  /**
  * Konstruktor.
  */
  HashElement(MString& key, T* value, int hashcode){
	this->key		= key;
	this->value		= value;
	this->hashcode  = hashcode;
  }
  ...

};

und wichtigste Klasse Hashtable

template <typename T>
class Hashtable {

private:

  /** Array mit Listen. */
  List<HashElement<T> >** table;

  /** Laenge des Arrays. */
  int size;

....

HashElement<T>* put(MString& key, T* value){
		if(key.length > 0){
			// ermittle hash und erstelle Element
			int hash = getHashcode(key);
			//erstelle HashElement
			HashElement<T>* element = new HashElement<T>(key,value, hash);
			// ermittle hashwert und fuege Element ein
			hash = this->getHashValue(hash);

			this->table[hash]->push_back(element);

			this->hashElementCount++;
			this->setFillingLevel();

			//pruefe ob reorganisierung der Tabelle noetig ist
			if ( this->actualFillingLevel >= this->maxFillingLevel){
				reorganize();
			}
			return element;
		} else {
			throw EmptyKeyExeption();
		}
	}

};

das alle starte ich so:

int main(){
    Hashtable<BspKlasse> map;
    BspKlasse* t = new BspKlasse("hallo");
    MString key("schluessel_1");
    map.put(key, t);
    return 0;
}

Ich bekomme dauernd Fehlermeldungen, ich glaube die Template-Syntax ist falsch...

Könnte jemand bitte helfen

Danke schon mal und freues neues! :xmas1:

template <class T>
class ListElement {
    ...
    /** Pointer auf ein HashElement */
    T* data;                               // Muss das unbedingt ein Pointer sein?
    ...
/** standardkonstruktor */                 // Nein, kein Standardkonstruktor
ListElement(T* data, ListElement* next){   // Überall doofe Zeiger
    this->data = data;                     // Keine Initialisierungsliste
    this->next = next;                     // Konsequente Verwendung von this
}
...
template <typename T>                      // Einmal class, einmal typename. Nimm lieber immer typename
class Hashtable {
  /** Array mit Listen. */
  List<HashElement<T> >** table;           // Bei dir muss auch wirklich alles ein Zeiger sein
}
int main(){
    Hashtable<BspKlasse> map;
    BspKlasse* t = new BspKlasse("hallo"); // Speicherallokation. Wo das Element wohl gelöscht wird? ...
    MString key("schluessel_1");
    map.put(key, t);
    return 0;
}                                          // ... scheinbar gar nicht
                                           // Du hast (mindestens) einen Memory Leak

Syntaxfehler kann ich keine erkennen (gib uns dafür die Ausgabe deines Compilers), aber dein Code gefällt mir überhaupt nicht.