ich arbeite gerade das Buch "Modernes C++ Design" von Alexandrescu und die dazugehörige Bibliothek "Loki" durch und bin da gerade in Abschnitt 2.7 bzw. in "TypeManip.h" auf ein für mich nicht ganz verständliches Konstrukt gestoßen.

Es geht darum, die Vererbbarkeit bzw. Umwandelbarkeit eines Typs U in einen Typ T zur Kompile-Zeit zu bestimmen. Dazu definiert er eine Vorlagenklasse "Conversion"

template<class T, class U>
class Conversion
{
private:
	typedef char Small;
	class Big { char dummy[2]; };
	static Small Test( U );
	static Big Test( ... );
	static T MakeT();

public:
	enum { exists = sizeof( Test( MakeT() ) ) == sizeof( Small )};
	enum { sameType = false };
};

template<class T>
class Conversion<T, T>
{
public:
	enum { exists = 1, sameType = 1 };
};

Um die Implementierung zu Verstecken definiert er nun in o. g. header folgende Strukturen:

template <class T, class U>
struct SuperSubclass
{
  enum { value = (Conversion<const volatile U*, const volatile T*>::exists &&
                  !Conversion<const volatile T*, const volatile void*>::sameType) };
};

template<class T,class U>
struct SuperSubclassStrict
{
  enum { value = (Conversion<const volatile U*, const volatile T*>::exists &&
                 !Conversion<const volatile T*, const volatile void*>::sameType &&
                 !Conversion<const volatile T*, const volatile U*>::sameType) };
};

So wie ich die Beschreibung im Buch verstanden habe soll der Kompiler beim kompilieren Feststellen ob eine Umwandlung möglich ist oder nicht und der bei der Optimierung den Überschüssigen Code entfernen um das Programm "schlank" zu halten.

Soweit, so gut. Was mich nun irritiert ist das Schlüsselwort volatile in den Template parametern. Unterbindet nicht dieses Schlüsselwort derartige Optimierungen da es dem Kompieler einen Hinweis gibt, das die als volatile gekennzeichneten Variablen evt. von ausen geändert werden?

Kann mir bitte jemand einen Hinweis geben, wo ich gerade meinen Denkfehler habe?

Herzlichen Dank im Voraus.

Viele Grüße
Knecht

Wenn ich das richtig ueberschaut habe testest du damit nur ob fuer U und T ohne Qualifier Conversion<T,U>::exitst true ergibt. Du definierst ja keine Variabeln.

Ja. Aber ich dachte wenn ich zur Zeit des Kompilierens zwei Typen U und T an eine der Strukturen übergebe, z. B.

bool possible = SuperSubclass<U, T>::value;

dann könnte ja der Kompiler den Ausdruck in der struct auswerten und direkt der variable possible zuweisen. Mit dem Schlüsselwort volatile kann er das nicht und muss den Ausdruck zur Laufzeit Auswerten, da volatile angibt dass sich die Variablen von aussen ändern können. Oder irre ich mich da?

Viele Grüße
Knecht

Achja ausserdem werden ja templates IMMER zur Compilezeit instanziert und enums enthalten IMMER Konstanten, also MUSS es zur Compilezeit feststehen, sonst wird der Compiler schlecht gestimmt.

Würde man auf die c-v-Qualifizierung verzichten, würde ein SuperSubclass<Base, volatile Derived>::value (oder SuperSubclass<Base, const Derived>::value) 0 liefern - was kein sonderlich intuitives Ergebnis wäre.

Edit:
Zu Spät!!!
Ich ziehe die Frage "Aber für was brauche ich dan die "volatile"s?" zurück.

@Entenwickler und HumeSikkins:Danke für die Erklärung.