[C++0x] Wie heißt das Feature

[Krishty]

Eben gelesen:

C++’03:
Actor * a = templatedCast<Actor>(memory);
C++0x:
Actor * a = templatedCast(memory);

Also Auflösen von Templates gemäß der linken Seite. Ich kann’s nicht so recht glauben (so much win), darum: Kann mir jemand auf die Sprünge helfen, wie dieses Feature (oder sein Proposal) heißt?

Gruß

[CodingCat]

Hier das, was ich im aktuellen Draft zu Return Type Deduction finden konnte:

14.8.2.1 Deducing template arguments from a function call
Template argument deduction is done by comparing each function template parameter type (call it P) with the type of the corresponding argument of the call (call it A) as described below. [...]

Deducing conversion function template arguments
Template argument deduction is done by comparing the return type of the conversion function template. [...]

Damit erscheint mir dieses Feature für normale Funktionen eher unwahrscheinlich, es sei denn, der Draft hätte sich nochmal grundlegend geändert (nach Feb 2011).

Um eine der beiden redundanten Typangaben loszuwerden, bleibt wohl nur: auto a = templatedCast<Actor>(memory);

[anonym]

Ist das explizit erst seit C++0x erlaubt? Ich habe so etwas mit Templatemagie schon deutlich früher gemacht (ohne mich mit dem Standard aufzuhalten :oops: ).

Code: Alles auswählen

template<class T> class my_static_cast_t
{
private:
	T& x;
public:
	my_static_cast_t(T& x) : x(x) {}
	template<class U> operator U&() { return static_cast<U&>(x); }
};

template<class T> struct my_static_cast_t<T*>
{
private:
	T* x;
public:
	my_static_cast_t(T* x) : x(x) {}
	template<class U> operator U*() { return static_cast<U*>(x); }
};

template<class U>
my_static_cast_t<U> my_static_cast(T x) { return my_static_cast_t<T>(x); }

Code: Alles auswählen

class A {};
class B : public A {};
B b;
A& a = my_static_cast(b);
A* c = my_static_cast(&b);
char d = my_static_cast(132456789);

[CodingCat]

Nein, bei Conversion Functions ist das schon lange erlaubt. Dein Beispiel ist aber sehr unschön und in vielerlei Hinsicht sehr problematisch. Es gibt schon einen Grund, warum static_cast einen expliziten Typparameter erwartet. Zudem leidet dein Beispiel an gefährlicher undurchdachter Nutzung von Referenzen.

Das mit den Referenzen für so allgemeine Typparameter hinzubekommen ist immer schwierig, und du bist mit deinem Magic Cast leider gleich voll in die Falle gelaufen: In Zeile 4 deines Anwendungsbeispiels wird T von der Fabrikfunktion my_static_cast zu B aufgelöst, d.h. b wird als Parameter KOPIERT. In der Funktion baust du jedoch ein my_static_cast_t<B>, welches eine Referenz auf den KOPIERTEN Parameter SPEICHERT. Dieses Objekt gibst du zurück, anschließend lässt du den Compiler den impliziten Cast durchführen. Zu diesem Zeitpunkt ist der Parameter x, auf den du immer noch die Referenz gespeichert hast, welche jetzt gecastet wird, schon längst zerstört und ungültig. Schlimmer, du speicherst diese gecastete Referenz noch zur weiteren Nutzung, d.h. a ist im gesamten restlichen Programm vollkommen ungültig und führt fast sicher bei der nächsten Nutzung zum Crash.

Tatsächlich muss meiner Meinung nach eine sinnvolle Anwendung für eine Template-Conversion-Funktion erst noch gefunden werden, bisher habe ich eine solche immer nur als absolut chaosstiftend vorgefunden. Es gibt einfach praktisch keinen Anwendungfall, in dem sich ein Objekt sinnvoll in jeden beliebigen Typ casten lässt.

[Krishty]

Damit erscheint mir dieses Feature für normale Funktionen eher unwahrscheinlich, es sei denn, der Draft hätte sich nochmal grundlegend geändert (nach Feb 2011).

Schade. Aber immerhin! Dankeschön!