ist es möglich eine Klasse zu bauen, die Tupel mit beliebigen Typen und beliebiger Anzahl aufnehmen kann? Anwendungsbeispiel:

Container<int, bool, char> a;
Container<string, short> b;

a.push_back( Container<int, bool, char>::tuple( 5, true, 'a' ) );

vector< tuple< int , bool , char > >

?

Ich möchte gerne einen Container basteln, der 'ListStore' von GTK nachahmt. Im Grunde eine Liste mit beliebigen Tupel-Elementen, quasi:

ListStore<int, string, char> store;

Das wäre der Idealfall. Einfacher wäre es sicher nach dieser Methode:

ListStore< tuple<int, string, char> >;

Sofern möglich würde ich aber das tuple-Detail verbergen, da prinzipiell eh nichts anderes in Frage kommt. Mit variablen Template-Argumenten wäre das ja eigentlich ziemlich einfach, kommt aber wg. fehlendem C++11 leider nicht in Frage.

sind nicht typelists aus dem alexandrescu sowas?

Genau das, der hat doch diesen GenScatteredHierarchy Generator oder wie der heißt.

Das hatte ich sogar gelesen, konnte es aber persönlich nicht adaptieren – mangelnde Fähigkeit, denke ich.

höhöhö^^

ich hab ehrlich gesagt auch nicht ganz durchgeblickt...

Hehe, da habe ich meine Frage nicht präzise genug gestellt.
[...]
Im Grunde eine Liste mit beliebigen Tupel-Elementen, quasi:

ListStore<int, string, char> store;

Das ist nicht präziser als vorher.

Andrescus Buch kann ich nicht empfehlen. Ich hab's hier zwar auch rimliegen und fand es anfangs ganz nett, aber im Nachhinein erscheint's mir eher als überflüssig. Generisches Programmieren "policy-based design" zu nennen, fand ich jetzt auch nicht so spektakulär.

template <typename... Types>
class ListStore {
  private:
    std::vector< boost::tuple<Types...> > m_elements;
};

// ...

ListStore<int, char, string> store;

Mit variadic templates eigentlich eine einfache Geschichte, aber die kennt MSVC2010 m.W. nicht.

GCC ist sowieso der einzige, ernstzunehmende Compiler.

Naja, Intel solltest du nicht vergessen. Und Clang ist auch auf einem guten Weg, GCC vom Thron zu schubsen.

Der Intel Compiler ist nicht gratis, clang ist n Witz.

Ach, Clang ist noch jung. Die Features kommen schon nach und Clang hat den gewaltigen Vorteil dass er kein aufgeblähtes Monster mit verschwindenen Design ist. Schon mal Fehlermeldungen von Clang und GCC verglichen? Oder Geschwindigkeit beim Kompilieren? Dazu kommt noch die BSD statt GPL Lizenz + Kompatibilität zum GCC, ich denke hier entwickelt sich GCCs größter Gegner.

GCC ist sowieso der einzige, ernstzunehmende Compiler.

Definiere "ernstzunehmend"...

clang ist n Witz.

Wie aktuell sind Deine Erfahrungen mit clang? Gibt es überhaupt welche? Wenn ja, magste Deinen Satz mal erklären?

314159265358979 schrieb:

clang ist n Witz.

Gibt es überhaupt welche?

Zum Glück nicht. Ich habe sowas nicht nötig.

314159265358979 schrieb:

clang ist n Witz.

Wie aktuell sind Deine Erfahrungen mit clang? Gibt es überhaupt welche? Wenn ja, magste Deinen Satz mal erklären?

Er wollte mal mitreden, du kennst ihn ja: Große Klappe, nichts dahinter.

clangs C++11 Support ist unzureichend.

oh mein gott, ein compiler unterstützt einen nicht veröffentlichten Standard unzureichend

314159265358979 schrieb:

clangs C++11 Support ist unzureichend.

oh mein gott, ein compiler unterstützt einen nicht veröffentlichten Standard unzureichend

Der Standard ist schon lange fertig und war davor lange genug als Draft verfügbar.

@topic:

StefanBo schrieb:

Vielleicht noch einmal mit einem Beispiel:

template <typename... Types>
class ListStore {
  private:
    std::vector< boost::tuple<Types...> > m_elements;
};

// ...

ListStore<int, char, string> store;

Mit variadic templates eigentlich eine einfache Geschichte, aber die kennt MSVC2010 m.W. nicht.

Suchst du vielleicht sowas in der Art?

class NullType;

template< class A = NullType , class B = NullType , class C = NullType /*...*/ >
class ListStore;

template<>
class ListStore<>
{
//0 Parameter
};
template< class A >
class ListStore< A >
{
//1 Parameter
};
template< class A , class B >
class ListStore< A , B >
{
//2 Parameter
};
//...

clangs C++11 Support ist unzureichend.

Weil man noch den Standard von 2003 fertig implementiert. Und das über die Zeitspanne gesehen vielfach schneller als beim GCC.
Aber warts ab.

Suchst du vielleicht sowas in der Art?

Ja genau. Man könnte hier mit Boost Preprocessor mit Sicherheit eine Schleife erzeugen, die dann ausreichend Klassen erzeugt. Aber ich habe überlegt, ob das nicht eleganter geht.

In deinem Beispiel müsste ich ja jede Variante spezialisieren, das macht wenig Spaß, zumal sich die Varianten auch wirklich nur in der Anzahl und den Typen der Template-Argumente unterscheiden.