class Interface
{
public:
  virtual void run( ) = 0; 
}

class Base
: public Interface
{
public:
  void run( ); 
  void setup( ... );
  void calc( ... );
}

class Handler
{
public:
  std::vector< Base* >::iterator getIterator( ) const;

private:
  std::vector< Base* > m_vector;
}

Über die getIterator( ) Methode kann der User nun über die Base* Instanzen iterieren und was sinnvolles damit machen. Da ich dem User aber eigentlich nur das Interface anbieten möchte würde ich mir folgende Klasse vorstellen:

class Handler
{
public:
  std::vector< Interface* >::iterator getIterator( ) const;

private:
  std::vector< Base* > m_vector;
}

Da beide Vectoren unterschiedliche Template Typen verwenden passt das natürlich so nicht zusammen...

Deshalb meine Frage:
Wie würdet ihr dieses Problem lösen ? Ich steh gerade auf dem Schlauch

Wobei Athars Vorschlag natürlich besser ist, sollte das möglich sein (falls dein Codebeispiel keine relevanten Details weglässt, trifft dies zu).

class Handler
{
public:
  std::vector< Base* >::iterator getIterator( ) const;

  void calc( )
  {
    std::for_each( m_vector.begin( ), m_vector.end( ). functorToCallCalc );
  }

private:
  std::vector< Base* > m_vector;
}

Somit ist es leider nicht moeglich im Vector direkt Interface Zeiger zu speicher. Ich habe nun den Vorschlag von Nexus aufgegriffen und einen eigenen Iterator implementiert:

template <class Vector, class ValueType = Vector::value_type> class TIteratorVector
	{
	public:
		TIteratorVector( typename Vector::iterator& beginIterator, typename Vector::iterator& endIterator );

		// Iterator auf den Anfang setzen.
		void begin( );

		// Iterator auf das Ende setzen.
		void end( );

		// Iterator inkrementieren.
		void operator++( );

		// Iterator dekrementieren.
		void operator--( );

		// Pruefen ob der Anfang erreicht wurde.
		bool getBeginReached( ) const;

		// Pruefen ob das Ende erreicht wurde.
		bool getEndReached( ) const;

		// Das aktuelle Element zurueckgeben.
		typename ValueType getElement( );

	private:
		// Begin Iterator.
		typename Vector::iterator m_beginIterator;

		// End Iterator.
		typename Vector::iterator m_endIterator;

		// Aktueller iterator.
		typename Vector::iterator m_currentIterator;
	};

In der getElement( ) Methode kann ich mir auch den Cast sparen:

template <class Vector, class ValueType> typename ValueType TConstIteratorVector<Vector, ValueType>::getElement( )
{
	// Das Element zurueckgeben.
	return *m_currentConstIterator;
}

Ich habe nun den Vorschlag von Nexus aufgegriffen und einen eigenen Iterator implementiert:

template <class Vector, class ValueType = Vector::value_type> class TIteratorVector
	{
	public:
		TIteratorVector( typename Vector::iterator& beginIterator, typename Vector::iterator& endIterator );

		// Iterator auf den Anfang setzen.
		void begin( );

		// Iterator auf das Ende setzen.
		void end( );

		// Iterator inkrementieren.
		void operator++( );

		// Iterator dekrementieren.
		void operator--( );

		// Pruefen ob der Anfang erreicht wurde.
		bool getBeginReached( ) const;

		// Pruefen ob das Ende erreicht wurde.
		bool getEndReached( ) const;

		// Das aktuelle Element zurueckgeben.
		typename ValueType getElement( );

	private:
		// Begin Iterator.
		typename Vector::iterator m_beginIterator;
		
		// End Iterator.
		typename Vector::iterator m_endIterator;

		// Aktueller iterator.
		typename Vector::iterator m_currentIterator;
	};

Abgesehen von den Operatoren ++ und -- hat deine Klasse nichts mehr mit einem Iterator gemeinsam (aber selbst diese haben wegen void als Rückgabetyp eine ungewöhnliche Semantik). Ein Iterator ist eine Abstraktion eines Zeigers und weiss nichts über die Sequenz, also auch nichts über deren Beginn und Ende. Du packst zu viel Funktionalität in eine Klasse und schränkst dich damit zu stark ein. Die STL trennt Container, Algorithmen und Iteratoren absichtlich, um die Generizität und Modularität zu erhöhen. Ich rate dir dasselbe, wobei du nur einen Iterator implementieren musst. Orientiere dich doch an meinem verlinkten Beispiel.

Die Methoden begin() , end() , getBeginReached() , getEndReached() und getElement() würde ich weglassen, dafür operator* , operator-> , operator++(int) , operator--(int) , operator== und operator!= anbieten, also eine intuitive Iterator-Schnittstelle, wie man sie von der STL kennt.

Übrigens ist Base ein ziemlich schlecht gewählter Name für die abgeleitete Klasse.