template template und Zeiger Parameter

[kaiserludi]

Ich habe folgendes Template:

Code: Alles auswählen

template<typename EType> struct NestedInfos{};

Dazu habe ich folgende template template Spezialisierung dafür:

Code: Alles auswählen

template<template<typename, typename> class EType, typename ENestedKeyType, typename ENestedValueType> struct NestedInfos<EType<ENestedKeyType, ENestedValueType> >{};

Wenn ich nun etwas wie NestedInfos<Dictionary<int, int> > schreibe, dann wird auch wie gewünscht das Template Template aufgerufen.
Bei NestedInfos<Dictionary<int, int>*> hingegen wird statt dem Template Template die template<typename EType> Version aufgerufen.

Lege ich nun eine explizite Spezialisierung für Zeigertypen für das Template Template an, so wie hier:

Code: Alles auswählen

template<template<typename, typename> class EType, typename ENestedKeyType, typename ENestedValueType> struct NestedInfos<EType<ENestedKeyType, ENestedValueType>*>{};

dann wird im NestedInfos<Dictionary<int, int>*> Fall diese auch benutzt.

Warum muss ich denn hier explizit für Zeiger spezialisieren, damit für einen Template mit korrekter Anzahl Templateparrameter als Parameter auch eine Template Tempalte Version genutzt wird?
In Abwesenheit der Zeigerspezialisierung sollte doch das verbliebene Template Template klar am besten passen?

[CodingCat]

Nein im Gegenteil, die Template-Template-Version kann für Zeiger überhaupt nicht passen. T und T* sind grundverschiedene Typen, das eine ist ein beliebiger Wertetyp, das andere ein Zeiger auf denselben. Nur weil es eine Spezialisierung für T gibt, kann der Compiler nicht einfach den Zeiger in T* verschlucken und so tun, als wäre nur ein T übergeben worden. Abhilfe kann folgendes schaffen:

Code: Alles auswählen

template <
    typename EType,
    typename = typename std::remove_pointer<EType>::type >
struct NestedInfos { ... };

template <
    typename EType,
    template<typename, typename> class ETemplate, typename ENestedKeyType, typename ENestedValueType >
struct NestedInfos< EType, ETemplate<ENestedKeyType, ENestedValueType> > { ... };

Ich werde das Gefühl nicht los, dass du da eine undurchdringliche Template-Hölle aufbaust. ;)

[kaiserludi]

Ja, mit deiner Modifikation funktioniert das ganze auch ohne Pointerspezialisierung :)

Ich werde das Gefühl nicht los, dass du da eine undurchdringliche Template-Hölle aufbaust. ;)

*diabolisches Lachen* Wer ich? Aber nein, ich bin ganz lieb. :mrgreen:

Im Ernst: Solange ich durch den Code durchsteige, tust du das mit deinem Teplateverständnis sogar ohne Einarbeitung.

Die ganzen Templates sind auch alle schön in der Implementation versteckt und dienen vor allem dazu, die API dafür umso einfach verständlich zu halten.

Hier mal ein Beispiel für ein Hashtable mit einem Dictionary<Dictionary<int, int*> > als Value:

Code: Alles auswählen

Hashtable ev;
Dictionary<int, Dictionary<int, int*>*> outerDic;
Dictionary<int, int*> innerDic;
int test = 3;
innerDic.put(2, &test, 1);
outerDic.put(1, &innerDic, 1);
ev.put(L"dic", outerDic);

Viel durchdringlicher kann man diesen Templatehimmel doch gar nicht mehr gestalten ;)

[dot]

Was ich mich bisher in jedem deiner Threads, wo es um das ging, gefragt hab: Warum speichert das Dictionary Pointer auf Dictionaries und nicht einfach direkt Dictionaries!?

[kaiserludi]

Man kann auch direkt Dictionaries speichern, aber eben auch (optional multidimensionale) CArrays von Dictionaries per Pointer auf das erste Element.
Es gibt quasi folgende 3 Möglichkeiten:

Code: Alles auswählen

dic.put(key, myDic);
dic.put(key, mySingleDimensionalDicArray, arraySize);
di.cput(key, myMutidimensionalDicArray, array1DHoldingTheArraySizesForAllDimenions);

[CodingCat]

Yo dawg, we herd you like dictionaries, so we put a multi-dimensional array of dictionaries in yo dictionary so you can look up while you look up. :lol:

[kaiserludi]

Du lachst, aber der Grund, warum wir das einbauen, ist, dass immer wieder Kunden danach fragen.