Template Funktion - Defintion der Typen, ohne dass sie in den Parametern auftauchen

SeppJ

Doch, das ist richtig! Dein Beispiel läuft, zumindest nachdem man int main() und so ergänzt hat.

Bring bitte mal ein vollständiges Minimalbeispiel, welches den Fehler zeigt, aber ansonsten compilierbar ist. Und die genaue Fehlermeldung.

Nexus

Benutze bitte [cpp]-Tags (erste weisse Schaltfläche).
Schreibe ein komplettes Minimalbeispiel ohne Kompilierfehler, die nichts mit dem Problem zu tun haben, hin.
Poste die exakte Fehlermeldung des Compilers.

Nur so können wir sicher sein, dass die Vereinfachung nicht das Problem ist, und können auf Spekulationen verzichten.

Roger!

Hab das Problem gelöst. Ihr habt recht. Ich habs weg-minimalisiert.

Vielen Dank trotzdem und bis zur nächsten Frage.

Beste Grüße,
Oliver

Wenn du bool vewenden möchtest, dann muss der erste Typ ein typename
sein und keine class

template <typename T1 , class T2> 
void dieFunktion(T1 wert) 
{ 
T2 a = new T2(wert); 
}

Gruß,
CSpille

theta

CSpille schrieb:

...

Das ist nicht korrekt wenn ich mich richtig erinnere.
class und typename sind in diesem Kontext gleichwertig und austauschbar.

Simon

Oh...

Nehm alles zurück...

theta schrieb:

CSpille schrieb:

...

Das ist nicht korrekt wenn ich mich richtig erinnere.
class und typename sind in diesem Kontext gleichwertig und austauschbar.

Simon

Ehrlich gesagt bin ich jetzt etwas verwirrt...
Unter welcher Bedingung sind sie denn austauschbar?

Bisher habe ich für einfache Datentypen immer typename genommen.
Kann das evtl. sogar einen Nachteil haben?

unskilled

CSpille schrieb:

theta schrieb:

CSpille schrieb:

...

Das ist nicht korrekt wenn ich mich richtig erinnere.
class und typename sind in diesem Kontext gleichwertig und austauschbar.

Simon

Ehrlich gesagt bin ich jetzt etwas verwirrt...
Unter welcher Bedingung sind sie denn austauschbar?

Bisher habe ich für einfache Datentypen immer typename genommen.
Kann das evtl. sogar einen Nachteil haben?

nein, in dem kontext ist es vollkommen egal.
der einzige unterschied, den es gibt ist hier ganz gut beschrieben:
http://www.informit.com/articles/article.aspx?p=376878

bb

Olli85 schrieb:

Es besteht folgende (minimierte) Problematik:
---------------------------------------------------------------------------
Die Template-Funktion:
...
template <class T1 , class T2>
void dieFunktion(T1 wert)
{
T2 a = new T2(wert);
}

Der ausführende Code (z.B. mit bool)
...
dieFunktion< bool , KlasseX > ( true );

(Läuft nicht)
---------------------------------------------------------------------------
Normalerweise kann man sich die spitzen Klammern ja sparen, wenn durch die Parameter der Funktion klar ist, um welche Typen es sich handelt.

Die Fragestellung ist also: Wie ist bitte der Syntax um Template Platzhalter zu verwenden, die nicht durch einen Parameter der Funktion definiert werden?

Ich verstehe die Frage nicht ganz. Ich vermute, du willst das "bool" nicht mitangeben, da der Compiler sich das selbst über den Parameter true herleiten soll. Dann sortierst Du einfach die Template-Parameter um:

template <class T2, class T1>  // <--- geändert
void dieFunktion(T1 wert)
{
    T2 * a = new T2(wert);
    // ^ 
    // new liefert einen Zeiger
}

...
dieFunktion<KlasseX> ( true );  // <--- geändert

Gruß,
kk

DocShoe

Du kannst ein eigenes Type Promotion basteln, was den Rückgabetyp aus dem Eingabetyp herleitet:

// Default Template liefert Rückgabetyp T für den Eingabetyp Typ T zurück
template<typename T>
struct TypePromotion
{
   typedef T value_type;
};

// spezialisiertes Template liefert Rückgabetyp double für den Eingabetyp float zurück
template<>
struct TypePromotion<float>
{
   typedef double value_type;
};

template<typename T>
typename TypePromotion<T>::value_type* function( T value )
{
   return new typename TypePromotion<T>::value_type( value );
}

int main()
{
   // Spezialisierung benutzen: float -> double
   double* x = function( 1.0f );

   // Default Template benuzten: int -> int
   int*  y = function( 1 );

   // Compiler Fehler: keine Typ Promotion von double nach int möglich
   int*  z = function( 1.0 );
}

Ob das den Aufwand wert ist weiß ich nicht...