typeid und templates

Flow_cplus

Hi

Ich weis nicht wie ich das machen soll:

Ich moechte in einer function einer template classe code abhaenig vom type ausfuehren indem ich mit typeid teste ob der von der gewuenschten classe ist:

template <class Type> class  ClassName
 {
...
 public: void DoSomething(Type * Data)
  {
  if(typeid(Data) == typeid(ClassWantedToBe*)) ...;

  }
 }

Das funktioniert auch so, ABER jetzt ist die ClassWantedToBe auch ein template, so funtioniert es mit

...
if(typeid(Data) == typeid(ClassWantedToBe<SpecialType>*)) ...;
...

Jetzt mein Problem: ich moechte den selben test machen, aber ohne zu wissen wie das tempalte ClassWantedToBe benutzt wurde. Ich will testen ob Data von type ClassWantedToBe ist unabhaening vom SpecialType, meint:

if(typeid(Data) == typeid(ClassWantedToBe<??>*))...

ich moechte true wenn Data von dem template ClassWantedToBe kommt egal mit welchem type das template benuzt wurde. (also ist mir egal was ?? ist, hauptsache irgendein type von ClassWantedToBe<..> ) Wie geht das?

Vielen Dank fuer Hinweise

Gruesse

Mathias

Verpasse der Klasse ClassWantedToBe eine Funktion z.B. GetType () und frage diese anstelle der Klassen-ID ab.

Ansonsten ist das hier:

if(typeid(Data) == typeid(ClassWantedToBe*))

nicht so schön. Man sollte solche Ausnahmebehandlungen soweit wie möglich vermeiden. Wenn dein Template mit der Schnittstelle von Type arbeiten soll, dann sollte sie auch nur diese verwenden.
Sowas löst man besser mit einer virtuellen Funktion in Type. Diese in der Funktion ClassWantedToBe ueberschreiben und im Template aufrufen. Dann verhält sich dein Template in Abhängigkeit vom wirklichen Objekttyp anders.

groovemaster

Bist du darauf angewiesen, dies mit Laufzeitinformationen zu machen? Ansonsten gibt es in C++ bessere Möglichkeiten, zB das Strategy Pattern.

#include <iostream>

template <class T>
class foo
{
};

// Spezialisierungen für diverse T's deiner Klasse
template <class T>
struct A_strategy;

template <>
struct A_strategy<int>
{
	static void apply()
	{
		std::cout << "ein int" << std::endl;
	}
};

template <>
struct A_strategy<foo<int> >
{
	static void apply()
	{
		std::cout << "ein foo<int>" << std::endl;
	}
};

template <class T>
struct A_strategy<foo<T> >
{
	static void apply()
	{
		std::cout << "ein foo<T>" << std::endl;
	}
};

// deine Klasse
template <class T>
class A
{
public:
	void do_something(T* data)
	{
		A_strategy<T>::apply();
	}
};

int main()
{
	A<int> a;
	a.do_something(0);
	A<foo<int> > b;
	b.do_something(0);
	A<foo<char> > c;
	c.do_something(0);
	return 0;
}

Des Problems Lösung hier heisst Spezialisierung, imo die vernünftigste Vorgehensweise, wenn du mit Templates arbeitest.