ich kenne mich mit Templates (noch) überhaupt nicht aus:

da ich eine externe Library Funktion aufrufe muss ich wissen welcher Typ in meinem Template liegt um abhängig davon eine andere Funktion aufzurufen.

Kann ich irgendwie überprüfen ob in meinem Template z.B ein double liegt oder
auch z.B eine eigens definierte structure?

Danke euch

template< typename T >
struct foo
{ 
    typedef T value_type;
};

Dann kannst du über foo< double >::value_type über den übergebenen Typ Infos holen.

template<typename T>
void print(const T& data)
{
  cout<<data;
}

template<>
void print(const double& data)
{
  cout<<setprecision(2)<<scientific<<data;
}

Hallo,

ich kenne mich mit Templates (noch) überhaupt nicht aus:...

Nur mal so ins Blaue geschossen: Weißt Du, dass templates zur Compilezeit umgesetzt werden ? Das ist etwas Anderes als "Polymorphie durch Vererbung", "RTTI" (RunTimeTypeInformation), typeid(), ....

Der Vorteil ist eben, dass Du "Spezialisierungen" schreiben kannst - also festlegen, wie sich Dein template für bestimmte Typen verhalten soll - und der Compiler für Dich überprüft, ob alles passt. Da bedeutet, Du stellst es nicht erst zur Laufzeit fest, sondern schon vorher.

Gleichzeitig ist es aber dann aber eben auch zur Laufzeit bereits festgelegt und nicht mehr änderbar.....

Konkretes Beispiel:

//fremdlib.h
void mach_was_mit_char(char c);
void mach_was_mit_long(long l);
void mach_was_mit_int(int i);

(fände ich zwar schlecht ein solches Design, aber hier mal als Beispiel genommen)

Dein Zeug:

//meinZeug.h
template <typename T>
struct meinZeug {
   T x;
   void mach_was(); // generelle Funktion
};

// Spezialisierungen
template <>
void meinZeug<char>::mach_was() { mach_was_mit_char(x); }

template <>
void meinZeug<long>::mach_was() { mach_was_mit_long(x); }

template <>
void meinZeug<int>::mach_was() { mach_was_mit_int(x); }

Genutzt wird's so:

int main() {
   meinZeug<char> c;
   c.machwas(); // funktioniert ! Ruft meinZeug<char>::mach_was() -> mach_was_mit_char() auf

   meinZeug<int> i; 
   i.mach_was(); // funktioniert ! Ruft meinZeug<int>::mach_was() -> mach_was_mit_int() auf

   meinZeug<double> d; // ist erlaubt !! Solange nicht mach_was() aufgerufen wird

   meinZeug<string> s;
   s.mach_was(); // FEHLER -> meinZeug<string>::mach_was() wird nicht gefunden

...

Ergo: Du brauchst gar nicht zu prüfen/wissen, "welchen Typ mein template hat", sondern sagst, wie es sich für die von Dir gewünschten Typen verhalten soll und der Compiler wird Dir schon sagen, wenn ein "ungewünschter Typ" verwendet wurde.

Gruß,

Simon2.

Hallo,

ich kenne mich mit Templates (noch) überhaupt nicht aus:

da ich eine externe Library Funktion aufrufe muss ich wissen welcher Typ in meinem Template liegt um abhängig davon eine andere Funktion aufzurufen.

Kann ich irgendwie überprüfen ob in meinem Template z.B ein double liegt oder
auch z.B eine eigens definierte structure?

Danke euch

http://c-plusplus.net/forum/viewtopic-var-p-is-1323449.html

...
http://c-plusplus.net/forum/viewtopic-var-p-is-1323449.html

Ist der hier nicht ein wenig oversized ?
Ich glaube, der Link führt zu einer Diskussion von Problemen, die Mati noch gar nicht hat. Es geht im (wenn ich ihn recht verstanden habe) um das "Herausfinden eines konkreten Typs" und weniger um "Typeigenschaften".

Nichtsdestotrotz ein interessanter Thread.

Gruß,

Simon2.

KasF schrieb:

...
http://c-plusplus.net/forum/viewtopic-var-p-is-1323449.html

Ist der hier nicht ein wenig oversized ?
Ich glaube, der Link führt zu einer Diskussion von Problemen, die Mati noch gar nicht hat. Es geht im (wenn ich ihn recht verstanden habe) um das "Herausfinden eines konkreten Typs" und weniger um "Typeigenschaften".

Mati schrieb:

Kann ich irgendwie überprüfen ob in meinem Template z.B ein double liegt oder
auch z.B eine eigens definierte structure?

Für sein double reicht doch ein einfaches:

template<class T>
struct IsDouble {

    enum { result = false };
};

template<>
struct IsDouble<double> {

    enum { result = true };
};

template<class T>
void myfunc(t val) 
{
   if(isDouble<T>::result) { }
   else ...
}

Für sein eigenes struct ein:

struct MyStructType { };

struct MyStruct {
   typename MyStructType type;
};

template<class T>
void myfunc(T val) 
{
   if(typeId(typename T::type) == typeID(MyStructType) ) { }
   else ...
}

//oder um typeId zu vermeiden entsprechend überladen und anhand des Types die //richtige Funktion auswählen lassen.

Was ist daran oversized ?

ich meinte nicht unbedingt, dass die dort vorgestellten Ansätze oversized sind, sondern der Thread an sich.

Die von Dir angegebene "Lösung" ist IMO allerdings trotzdem "oversized", weil ich glaube, dass Mati ein typisches "Anfängerproblem" hier hat: Er möchte Problem A lösen, stellt sich Lösung X vor und hat bei der Umsetzung Problem B.
Nun fragt er nach einer Lösung für B, dabei gibt es eine viel bessere Lösung für A.

Ist lustigerweise ja eigentlich der typische Werdegang bei Threads mit dem Titel "Wie bekomme ich den Typ raus ?"
In den allerseltensten Fällen ist eine Typbestimmung wirklich die geeigente Lösung...

Gruß,

Simon2.

Ja schon möglich. Warten wir eben ab was Mati genau will.

Naja, er schrieb halt:

Mati schrieb:

...
da ich eine externe Library Funktion aufrufe muss ich wissen welcher Typ in meinem Template liegt um abhängig davon eine andere Funktion aufzurufen....

... und da scheint mir eine Spezialisierung das bessere Mittel zu sein.

Gruß,

Simon2.

Also vielleicht sollte ich genauer werden:

struct complex{
     int r;
     ind i;
};

lib_fkt1(double* arr);
lib_fkt2(complex arr2)

//Und jetzt habe ich ein template array 
//welches je nach input entweder aus nur double werten besteht oder eben
//aus complex structs-elementen.

//Und da die lib-funktionen jetzt eben je nach input anders aufgerufen werden //müssen dachte ich ich teste auf den typ um dann mit if / else zu verzweigen.

Ich würde in diesem Fall sowas vorziehen:

lib_fkt(double* arr)
{
   lib_fkt1(arr);
}

lib_fkt(complex* arr)
{
   lib_fkt2(arr);
}

//....
T array[20];
lib_fkt(array);

Edit: Achja Simon hattest recht

Danke euch für eure rege Hilfe!

Also vielleicht sollte ich genauer werden:

struct complex{
     int r;
     ind i;
};

lib_fkt1(double* arr);
lib_fkt2(complex arr2)

//Und jetzt habe ich ein template array 
//welches je nach input entweder aus nur double werten besteht oder eben
//aus complex structs-elementen.

//Und da die lib-funktionen jetzt eben je nach input anders aufgerufen werden //müssen dachte ich ich teste auf den typ um dann mit if / else zu verzweigen.

(BTW: lib_fkt1/2 sollten auch return types haben )
(BTW2: ich gehe mal davon aus, dass bei lib_fkt2(complex) ein '*' fehlt)

Da kannst Du doch prima mein voriges Beispiel drauf anwenden:

template <typename T>
struct meinArray {
   T arr[10];
   void lib_fkt();
};

template <>
void meinArray<double>lib_fkt() { lib_fkt1(arr); }

template <>
void meinArray<complex>lib_fkt() { lib_fkt2(arr); }

Wenn die lib overloading nutzen würde (sprich: lib_fkt1/2 denselben Namen hätten), könnte man sich das Ganze sparen:

void lib_fkt(double* arr);
void lib_fkt(complex* arr);

template <typename T>
struct meinArray {
   T arr[10];
};

int main() {
   meinArray<double> d;
   lib_fkt(d.arr);

   meinArray<complex> c;
   lib_fkt(c.arr);

   ...

Gruß,

Simon2.

P.S.: KasFs Variante, die unterschiede in eigenen Overloads zu verstecken, ist aber auch gut.

void lib_fun1(lala* l);
void lib_fun2(int* i);

inline void lib_fun(lala* l)
{
    return lib_fun1(l);
}

inline void lib_fun(int* i)
{
    return lib_fun2(i);
}

// und nu einfach lib_fun(T*) verwenden...

@Simon2: man kann sich die Overloads auch selbst basteln, ...

Meinst Du so wie KasF es oben schon gezeigt hat ?
Meine "Spezialisierungsvariante" habe ich noch gezeigt, weil diese Technik sie vorhier angesprochen wurde und ich davon ausging, dass Mati evtl. noch komplexere Dinge in seiner/m Klasse/ntemplate abbilden will als nur das Array.

Außerdem ist Spezialisierung eine schöne Technik, die man ruhig mal gesehen haben darf, wenn man mit templates anfängt und rumprobiert.

Gruß,

Simon2.