Fehler:Klasse besitzt keine Konstruktoren-obwohl diese definiert wurden

[Luke*Tal]

Also im Großen und Ganzen geht es bei meinem Projekt um eine Verkehrsimulation.
Es gibt Verkehrobjekte(Wege,PKW´s ect) die Abgefertigt werden sollen.
Ein Weg erhält somit eine Liste von auf ihr fahrenden Fahrzeugen und soll diese nach und nach abfertigen. Da beim löschen von der Liste Probleme auftreten können sollen diese durch ein spezielle Klasse (LazyListe) ausgeschlossen werden.
Aktionen, die die Liste selbst verändern, werden in einer Liste mit Schreibaktionen gespeichert und nach abfertigung aller anderen Objekte nacheinander ausgeführt.

LazyListe enthält 2 Listen:
- Liste mit Fahrzeugobjekten
- Liste mit Schreibaktionen (eingene Klasse LazyAktion mit Unterklassen)

In der Unterklasse LazyErase (welche von LazyAktion erbt) tritt bei mir nun ein Fehler auf.

Fehlermeldung:
Fehler 1 error C2955: "LazyErase": Für die Verwendung der template-Klasse ist eine template-Argumentliste erforderlich.
Fehler 2 error C2514: 'LazyErase': Klasse besitzt keine Konstruktoren

Hier die Klasse LazyAktion:

template <class T>
class LazyAktion
{
   public:
      LazyAktion( list<T>* ptLazyListe )
                   : p_ptLazyListe( ptLazyListe ) {}
      virtual ~LazyAktion() {}
      virtual void vAusfuehren() = 0;
   protected:
      list<T>*	p_ptLazyListe;	// Zeiger auf p_ListeObjekte
};

Hier die Klasse LazyAktion

template <class T>
class LazyErase : public LazyAktion<T>
{
   // typedef fuer iterator
   typedef typename list<T>::iterator iterator;
   //keine Ahnung warum dieser Iterator definiert wird aber ist in der 
   //Vorlage von der Uni
   typedef typename list<T>::const_iterator const_iterator;

   public:
      LazyErase( iterator itObjekt, list<T>* eineListe)
                      : LazyAktion<T>(eineListe)
                      , p_itObjekt(itObjekt) {}
      virtual ~LazyErase() {}
      void vAusfuehren() { p_ptLazyListe->erase(p_itObjekt); }
   private:
      iterator	p_itObjekt;	// bei erase Iterator speichern
};

main sieht wie folgt aus (nur als Funktionstest gedacht)

LazyListe<int> zahlen;
//Liste wird mit Zufallszahlen gefüllt
(...)
//alle größer 5 löschen
LazyListe<int>::iterator it;
for(it=zahlen.begin();it!=zahlen.end();it++)
{
	if((*it)>5)
	{
		zahlen.erase(it);
	}
}

Konstruktor ist doch definiert.
Habe nun schon sehr lange auf diese Zeilen geschaut und brauche nun Rat von außerhalb da ich den Fehler einfach nicht finde.

Ich danke schonmal für jeden Tipp.

Gruß Lukas

[Luke*Tal]

Hier noch die LazyListe falls es weiter hilft:

#ifndef __LazyListe_h
#define __LazyListe_h

#include <list>
#include "LazyAktion.h"

template <class T>
class LazyListe
{
   public:
      // typedef fuer iterator
      typedef typename list<T>::iterator iterator;
      typedef typename list<T>::const_iterator const_iterator; 

      // Konstruktor / Destruktor
      LazyListe() { bChanged = false; }
      virtual ~LazyListe()
      {
         if (bChanged)
         {
            // ggf. noch anstehende Aktionen löschen
            do
            {
               delete *(p_ListeAktionen.begin());
               p_ListeAktionen.pop_front();
            }
            while (p_ListeAktionen.size() > 0);
         }
      }

      // Lesefunktionen
      const_iterator begin() const {return p_ListeObjekte.begin();}
      const_iterator end() const {return p_ListeObjekte.end();}
      iterator begin() {return p_ListeObjekte.begin();}
	  iterator end() {return p_ListeObjekte.end();}
      bool empty() const {return p_ListeObjekte.empty();}

      // Schreibfunktionen
      void push_back( const T einObjekt )
      {
      p_ListeAktionen.push_back(new LazyPushBack<T>(einObjekt,&p_ListeObjekte));
      bChanged = true;
      return;
      }

      void push_front( const T einObjekt )
      {
      p_ListeAktionen.push_back(new LazyPushFront<T>(einObjekt,&p_ListeObjekte));
      bChanged = true;
      return;
      }

      void erase(iterator itObjekt)
      {
		  p_ListeAktionen.push_back(new LazyErase(itObjekt,&p_ListeObjekte));
		  bChanged = true;
		  return;
      }

      // Änderungen auf Objektliste übertragen
      void vAktualisieren()
      {
         list <LazyAktion<T>*>::const_iterator itL;

         if ( bChanged )
         {
	         // ausstehende Aktionen durchfuehren
	         for (itL=p_ListeAktionen.begin();itL != p_ListeAktionen.end();itL++)
	         {
	         // Aktion ausführen
		         (*itL)->vAusfuehren();
             //Zeiger auf Action-Element löschen
				 delete (*itL);
	         }
	         // Liste der Aktionen leeren
            p_ListeAktionen.clear();

	         bChanged = false;
         }
      }

   private:
      list<T>					p_ListeObjekte;
      list<LazyAktion<T>*>		p_ListeAktionen;
      bool						bChanged;
};

#endif

[manni66]

Es muss beim Aufruf des Konstruktors LazyErase<irgend ein Typ> heissen

[Luke*Tal]

danke. hatte es einfach nicht mehr gesehn...
problem hat sich damit erledigt

[wxSkip]

Der const_iterator ist dafür da, dass du über eine konstante Liste iterieren kannst (und entsprechend nicht die Werte, auf die der Iterator zeigt, ändern kannst).