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?

Beste Grüße,
Oliver

Einen Fehler kann man sogar sofort sehen:

T2 a = new T2(wert);

Dies kann nur in Ausnahmenfällen funktionieren, da new einen T2* zurückgibt, welcher im Allgemeinen nicht kompatibel zu einem T2 sein wird. Das sollte dir dein Compiler aber auch eigentlich sagen, wenn das Template instanziert wird (und das wird es in deinem Beispiel).

ru,
cirion

(Vielen Dank für die schnellen Reaktionen übrigens)

Ich mache nochmal ein Beispiel, evtl. wird deutlicher was ich meine.

-- Beispiel 1 - läuft ------------------------------

Die Funktion:

template <class T1>
void dieFunktion(T1 wert)
{
//Mache irgendwas mit wert
}

Aufruf der Funktion:

dieFunktion(IrgendEinWert);
******************************************************
Hier ist alles ohne Probleme! T1 wird definiert durch die Übergabe des Parameters der Funktion.
Alternativ hätte ich die Funktion auch wie folgt aufrufen können (z.B. für bool):

dieFunktion<bool>(IrgendeinBoolscherWert).

Das läuft auch!

-- Beispiel 2 - läuft nicht --------------------------

Die Funktion:

template <class T1, class T2>
void dieFunktion(T1 wert)
{
//Mache irgendwas mit (T1)wert und irgendwas mit dem Typ T2
}

Aufruf der Funktion:
dieFunktion(IrgendEinWert); // DAS GEHT JA NICHT MEHR! Weil T2 damit nicht definiert ist.

Also mache ich den Aufruf wie folgt (z.B. für bool):

dieFunktion < bool , IrgendeineKlasse > (IrgendEinWertBoolscherWert);

------------------------------------------------------

Der Compiler bemängelt hier, dass er keine Übereinstimmung finden kann. D.h. ich mache wohl irgendwas falsch.

Ich versuchs nochmal Konkret : Ich muss einen Template Parameter entsprechend erzeugen können ohne, dass er als Übergabeparamter in einer Funktion steht.

ru,
cirion

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

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

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

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

Gruß,
CSpille

...

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

Simon

Nehm alles zurück...

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?

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

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

// 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...