Ich weiß der Titel is grausam, aber ich wusste nicht, wie ich es besser formulieren sollte! Mein Problem ist folgendes:

template <typename chtype> class Logger {
private:
std::ostream& m_strm;
//..
public
Logger(std::ostream&);
//..
};

Eine Instanz dieser Klasse will ich jetzt also mit einem beliebigen Stream initialisieren ... folgendes hab ich schon probiert:

Logger<std::clog::value_type> test(std::clog);
Logger<typename std::clog::value_type> test(std::clog);

Wie teile ich dem Logger mit, welchen char_type er verwenden soll, oder lässt sich das irgendwie implizit machen? Hier häng ich fest!

MfG

dürfte das richtige sein (clog ist per Standard ein ostream).

Aber eigentlich kannst du sogar davon ausgehen, daß der value_type als char vordefiniert ist.

PS: Wenn du schon auf Basis des Charakter-Typs spezialisierst, würde ich eher direkt basic_ostream<> verwenden:

template<typename ch>
class Logger
{
  basic_ostream<ch>& m_strm;
public:
  Logger(basic_ostream<ch>& the_strm);
};

Mein Fehler, in der Implementation von Logger verwende ich auch basic_ostream<>, nur falsch wiedergegeben...

Also ich habe jetzt folgender maßen versucht, ein Objekt zu instanzieren:

#include <ostream>
#include <iostream>

#include "logger.hpp"

int main(int argc, char *argv[])
{
    MM::Logger<std::clog::value_type> test(std::clog);
    system("PAUSE");
    return EXIT_SUCCESS;
}

[quote="MinGW 3.4.2"]
main.cpp: In function int main(int, char**)': main.cpp:8: error:std::clog' is not a class or namespace
main.cpp:8: error: value_type' undeclared (first use this function) main.cpp:8: error: (Each undeclared identifier is reported only once for each function it appears in.) main.cpp:8: error: template argument 1 is invalid main.cpp:8: error: invalid type in declaration before '(' token main.cpp:8: error: invalid conversion from \void*' to `int'
[/code]

MfG

PS: ich bin nicht sicher, ob das geht, aber was ist mit "Loggerstd::clog.value_type"?

Du darfst den Operator :: nicht auf ein Objekt, sondern auf einen Klassennamen anwenden - und clog ist vom Typ "ostream".

PS: ich bin nicht sicher, ob das geht, aber was ist mit "Loggerstd::clog.value_type"?

Nee das geht nicht.

EDIT:

aber dafür geht:

template<typename ostream_type >
class Logger
{
  typedef typename ostream_type::char_type ch_type;
  basic_ostream<ch_type>& m_strm;
public:
  Logger(basic_ostream<ch_type>& the_strm):m_strm(the_strm){}
};

int main()
{
   Logger<ostream> logger(clog);
}

mhmm, ist nicht unbedingt das, was ich mir vorgestellt hab, aber wenn soweit funktioniert...

Wie wendet man dann eigentlich solche typedefs in Klassen sinvoll an?? Ich meine wenn ich einen Container mit einem beliebigen Elementtyp habe, dann wäre es doch äußert sinnvoll wenn man folgendes machen kann:

container<element_typ> test;
test::element_type elemet = test[n];

Und wenn ich mir meine C++ Referenz so anschaue, dann war das obige Beispiel genau der Anwendungssinn, den ich vermutet hatte;

MfG

Ich arbeite gerade an einem kleinen Parser der bis jetzt aus den Klassen Lexer, Parser und Logger besteht. Dazu gehören 3 Streams ... ein Input -, ein Output und ein Logstream. Lexer und Parser hängen vom char_type des Inputstreams ab, der char_type des Logstreams wird Lexer als Parameter mitgegeben und dann von Parser (wird mit einem Lexer - Objekt initialisiert) übernommen. Desweiteren kann der char_type des Outputstreams als Parameter für Parser übergeben werden. So hatte ich mir das vorgestellt, aber wie setze ich das template - mäßig am besten um?

MfG

template<typename CharType>
class Logger
{
  basic_ostream<CharType>& m_strm;
public:
  Logger(basic_ostream<CharType>& the_strm):m_strm(the_strm){}
};

int main()
{
   Logger<ostream::char_type> logger(clog);
}