GCC und (nicht-variadische) Template-Rekursion

TdZ

Hallo,

könnte mir vielleicht jemand erklären, wieso das hier:

template<typename T>
static std::string decompose()
{
        if(boost::is_pointer<T>())
            return decompose<VM, boost::remove_pointer<T> >();
        if(boost::is_const<T>())
            return decompose<VM, boost::remove_const<T> >();
        if(boost::is_reference<T>())
            return decompose<VM, boost::remove_reference<T> >();
        return "Nix mehr zu machen.";
}

meinen Compiler in einer Endlosschleife arbeiten lässt? Ich denke mal, das hat was mit der Deduktion der remove_* Templates von Boost zu tun, bin damit aber nicht genug vertraut, als dass ich jetzt mehr als eine vage Ahnung habe.

Wär toll, wenn Ihr mir weiterhelfen könntet!

Edit: Ach so, vielleicht noch allgemein zur Erklärung, was das da oben machen soll... Man gibt einen beliebigen Typen als Template-Parameter an und die Funktion soll dann alle Qualifier und andere Dekorationen entfernen. Aus 'volatile const int*&' soll einfach nur 'int' werden z.B.

Also probierst du ein boost::decay zu schreiben?

Deinen Code ist übrigens etwas seltsam, was ist VM wieso gibst du einen string zurück?

TdZ

decay kannte ich noch gar nicht, dank Dir für den Tip! Allerdings ist das nicht ganz das, was ich suche. Ich habe mittlerweile den Fehler gefunden: Die Reihenfolge der Qualifier war nicht ganz richtig, dann braucht man gar keine Rekursion. So funktioniert es jetzt erstmal:

template<class VM, typename T>
    static String fullName()
    {
        typedef typename boost::decay<typename boost::remove_all_extents<typename boost::remove_const<typename boost::remove_pointer<typename boost::remove_reference<T>::type>::type>::type>::type>::type DecomposedType;

        String name = TypeInfo::name<VM, DecomposedType >();

        bool isPointer = boost::is_pointer<typename boost::remove_reference<T>::type>();
        bool isConst = boost::is_const<typename boost::remove_pointer<typename boost::remove_reference<T>::type>::type>();
        bool isReference = boost::is_reference<T>();

        if(!TypeInfo::isValid<VM,DecomposedType>())
            return "";

        return TypeInfo::combined<VM>(name, isConst, isReference, isPointer);
    }

Das VM und der Funktionsname waren irrelevant, daher bin ich nicht weiter drauf eingegangen. Das hier ist jetzt die Funktion direkt aus dem Quellcode. Mega umständlich und funktioniert nur für recht primitive Typen. Egal, das reicht mir erstmal.

VM ist ein Template Parameter für die Virtual Machine, das gehört nämlich zu einem Binding-Utility für meine Script-Engine.

Danke nochmal, dass Du mich auf die richtige Fährte gebracht hast