aktuell spiele ein bisschen mit Templates und tappe in die Falle, dass Templates != Generische Typen sind. Hier mal ein Beispielcode, den ich nicht zum Laufen kriege:

class Foo {
public:
    template<typename _Ty>
    _Ty get(bool b) {
        if(b)
            return this->s;
        else
            return this->i;
    }

private:
    string s;
    int i;
};

int main() {
    Foo *f = new Foo;
    // unabhängig von den Werten in den Variablen:
    f->get<string>(true);    // Fehler, da Foo::s string ist, aber Foo::i nicht!
    f->get<int>(false);      // Genau umgekehrt!
}

Den Fehler verstehe ich ja, aber habt ihr Rat, wie man das elegant mit dem Typecasting umsetzen kann? Weil ich eigentlich tatsächlich das Zurückbekommen will, was ich auch als Templateparameter angebe.

Gruß

Kannst du mal erläutern, was du mit dem Code (inhaltlich) erreichen willst - vielleicht können wir dann bessere Lösungen anbieten.

template<template<typename> class Container, typename Type>
class Table {
private:
    Container<Type> *data;
/* ... */
};

Jedoch versuche ich die einzelnen Klassen, aus denen persistente Objekte erstellt werden, weiter zu abstrahieren, dass man nicht auf Properties/Variablen zugreifen muss sondern theoretisch gesehen Calls wie den folgenden machen könnte:

userObjectOutOfATable->get<string>(User::Name);

wobei das User::Name aus einer Enumeration kommt und ich so (anstatt einen String zu übergeben) sagen kann welche Variable etc. ich gerade will. Dies möchte ich dann so beispielsweise in einem Interface IPersistentObject unterbringen, falls es denn klappen sollte und andererseits eine gute Idee ist.

Ist so klarer geworden, was ich aktuell bezwecken möchte? (Auch wenn es Komplikationen bei den Rückgabetypen gäbe, wenn der Programmieren genau aufpasst, was er macht sollte es doch egal sein xD) Gäbe es nicht eine Möglichkeit die anderen Codepfade on-the-fly zu "fake"casten? Aufruf einer Casting-Funktion die je nach Typ einfach return NULL oder so macht xD

Damit könntest du eine std::map<TypeEnum, boost::any> haben und versuchen, boost::any_cast auf die Map-Einträge anzuwenden. Im Fehlerfall (Eintrag nicht gefunden oder falscher Typ) wird ein Nullzeiger zurückgegeben.

Schau dir mal die Bibliothek Boost.Any an.

Damit könntest du eine std::map<TypeEnum, boost::any> haben und versuchen, boost::any_cast auf die Map-Einträge anzuwenden. Im Fehlerfall (Eintrag nicht gefunden oder falscher Typ) wird ein Nullzeiger zurückgegeben.

Beim einem falschen Typen wird meines wissens nach eine Exception geworfen, ein bad_any_cast oder so ähnlich.
Und wenn der Map-Eintrag nicht gefunden wird, wird der end-Iterator zurückgegeben.

Beim einem falschen Typen wird meines wissens nach eine Exception geworfen, ein bad_any_cast oder so ähnlich.

Bei Zeigern nicht, siehe hier.

314159265358979 schrieb:

Und wenn der Map-Eintrag nicht gefunden wird, wird der end-Iterator zurückgegeben.

Was niemanden daran hindert, in diesem Fall einen Nullzeiger zurückzugeben.

Danke nochmals!

Was für eine Abstraktion meinst du? Du hast wahrscheinlich eine Funktion in der Art, oder?

template <typename T>
T* GetValue(TypeEnum type);

Mit Move-Semantiken ist das Feature des nächsten Standards gemeint, mit dem man teure Kopien vermeiden kann. Will ich zum Beispiel alle Elemente aus einem std::vector in einen anderen std::vector hineinbekommen, dann wird im Normalfall der alte vector kopiert und danach gelöscht. Stattdessen könnte man die Elemente direkt in den neuen vector speichern - ohne unnötige Kopie, die sehr teuer sein kann.

Ich habe dir einmal die Zeigerbehandlung ergänzt, ich nehme nicht an, dass du die Move-Semantiken brauchst: http://ideone.com/SxdAA
Zur main: Hier wird 2 mal die selbe Adresse ausgegeben, was bedeutet, dass der Cast geglückt ist. Beim Cast auf double* wird 0 zurückgegeben, da der Typ im Objekt int* und nicht double* ist.