Hab grad ne Wissenslücke, und bevor ich mir nen Wolf schreib..

Also ich möchte von streambuf erben, im Header <streambuf> find ich dann folgendes:

namespace std {
template<class Elem, class Tr = char_traits<Elem> >
    class basic_streambuf;
typedef basic_streambuf<char, char_traits<char> >
    streambuf;
typedef basic_streambuf<wchar_t,
    char_traits<wchar_t> > wstreambuf;
}  // namespace std

template <class Elem, class Tr = char_traits<Elem> >
    class basic_streambuf {
public:
    typedef Elem char_type;
    typedef Tr traits_type;
    typedef typename traits_type::int_type int_type;
    typedef typename traits_type::pos_type pos_type;
    typedef typename traits_type::off_type off_type;

//und dann der ganze Klassenrumpf;

Nun wollt ich meine eigene streambuf Klasse auch flexibel halten und möglichst mit verschiedenen Widgets instanzieren. Meine Idee drum:

template< typename WidgetT,
        typename charT,typename Tr = char_traits<charT> >
class Qt_basic_streambuf;

Und für Widgets, die dann zB keine setText Methode haben spezialisieren. Aber wie mach ich nun die typedefs für char und wchar_t Unterscheidung?

template< typename WidgetT, typename charT,
              typename Tr = char_traits<charT> >
    class Qt_basic_streambuf;
    typedef Qt_basic_streambuf< ???, char,    char_traits<char> >    Qt_streambuf;
    typedef Qt_basic_streambuf< ???, wchar_t, char_traits<wchar_t> > Qt_wstreambuf;

Ehrlich gesagt weiss ich gar nicht viel über Qt und wide chars, und ob das so überhaupt nötig ist?

Btw: An die Experten, die char_traits könnte man doch mit template template parametern instanzieren oder?

Danke im voraus

template <typename WidgetT>
class Qt_streambuf : public Qt_basic_streambuf<WidgetT, char>
{
public:
    // Beispiel:
    Qt_streambuf (int i) : Qt_basic_streambuf<WidgetT, char> (i)
    {}
    // ... entsprechend die anderen nichttrivialen Konstruktoren
};

// und das gleiche nochmal für Qt_wstreambuf

Entweder warten, bis C++0x kommt (keine gute Idee, wohl zu zeitintensiv ;)) oder durch ableiten und gegebenenfalls Konstruktoren "weiterleiten":

Oder mit einer Metafunktion:

template <typename WidgetT>
struct Qt_streambuf {
    typedef typename Qt_basic_streambuf<WidgetT, char> result;
};

// und "instanzieren" per:

typedef Qt_streambuf<QtButton>::result MyQtStreambufButton;

Da hier ja grad die Experten anwesend sind wollt ich die Frage nochmal aufgreifen

ich schrieb:

..die char_traits könnte man doch mit template template parametern instanzieren oder?

In etwa so?

template< typename WidgetT,
        typename charT, template <typename> class char_traits >
class Qt_basic_streambuf
{
...

Sorry für die seltsamen Fragen, ich versuch grad die "höheren Ebenen" von C++ zu verstehen

ich verstehe nicht ganz, was Du damit meinst. Die char_traits sind doch bereits mit Template-Parametern instanziert.

basic_streambuf< char, char_traits<wchar_t> > mixedmodestreambuf;

Und das wird wohl ziemlich seltsame Ergebnisse liefern.

Ok, blödes Beispiel, aber ich mein vom Prinzip her.

Ansonsten kann man diesen Parameter evtl. auch einfach vollkommen weglassen.

template <typename CharT> basic_streambuf {
    typedef typenameme char_traits<CharT> char_traits;
    // ...
};

Naja, auf jedenfall besten Dank, mein stream funktioniert jetzt.

C++0x steht für ein Erscheinen vor 2010 ... ziemlich optimistisch

Natürlich könntest du Template-Templateparameter verwenden, aber dann kannst du nur noch Templates als Traits benutzen (was nicht immer praktisch ist).

btw:
Woher wisst ihr das alles eigentlich? Lernt man das in der Ausbildung (Studium?) oder in Seminaren oder habt ihr das alles aus Büchern zusammen gelesen?
Ich kratz mir das so aus allen möglichen Artikeln und Newsgroups zusammen, bin halt Autodidaktin, aber es ist schwierig zu verstehen wann was praktisch ist.

Ahja boost hat da was? cool. Heisst das bei erscheinen des 0x Standards müsst ich nur die Namespace Prefixes ändern? Das wär ja was.

AFAIK wird concept-checking in C++0x Compiler-seitig unterstützt. Ich denke, das schaut dann etwas anders aus. Aber ich bin mir ziemlich sicher, dass die Boost-Leute da wieder wrappen, was nur geht (so wie auch bei Boost.Typeof).

kathi89 schrieb:

btw:
Woher wisst ihr das alles eigentlich? Lernt man das in der Ausbildung (Studium?) oder in Seminaren oder habt ihr das alles aus Büchern zusammen gelesen?
Ich kratz mir das so aus allen möglichen Artikeln und Newsgroups zusammen, bin halt Autodidaktin, aber es ist schwierig zu verstehen wann was praktisch ist.

Ein paar gute Bücher als Grundlage und ansonsten auch was man so liest plus etwas Praxis. Also in meinem Studium (das ich erst zu diesem Wintersemester angefangen habe) lern ich sowas nicht.

Bye

Oder mit einer Metafunktion:

template <typename WidgetT>
struct Qt_streambuf {
    typedef typename Qt_basic_streambuf<WidgetT, char> result;
};

Das typename gehört dort allerdings nicht hin.

Konrad Rudolph schrieb:

Oder mit einer Metafunktion:

template <typename WidgetT>
struct Qt_streambuf {
    typedef typename Qt_basic_streambuf<WidgetT, char> result;
};

Das typename gehört dort allerdings nicht hin.

Ja, stimmt natürlich.