ich bin recht neu in C++ und hab noch viel zu lernen.
Ich will eine Logger Klasse schreiben und wundere mich gerade, das es in C++ scheinbar nicht einfach ist die Ausgabe gleichzeitig auf den Bildschirm und/oder in eine Datei zu leiten.

Kann mich jemand auf den richtigen Weg führen?

Edit: Google hilft teilweise.
Es geht wohl über den streambuf, dessen overflow und sync modifiziert werden. Dort werden die Logziele eingetragen. Jedoch hab ich das Problem, das ich ja erst beim Aufruf des Loggers weiß, wohin geloggt werden soll.

Eine andere Variante:

[/code]
#include <iostream>
#include <fstream>
#include <vector>
#include <algorithm>
#include <functional>

class ComposeStream: public std::ostream
{
struct ComposeBuffer: public std::streambuf
{
void addBuffer(std::streambuf* buf)
{
bufs.push_back(buf);
}
virtual int overflow(int c)
{
std::for_each(bufs.begin(),bufs.end(),std::bind2nd(std::mem_fun(&std::streambuf::sputc),c));
return c;
}

private:
std::vectorstd::streambuf* bufs;

};
ComposeBuffer myBuffer;
public:
ComposeStream()
:std::ostream(NULL)
{
std::ostream::rdbuf(&myBuffer);
}
void linkStream(std::ostream& out)
{
out.flush();
myBuffer.addBuffer(out.rdbuf());
}
};
int main()
{
ComposeStream out;
out.linkStream(std::cout);
out << "1. To std::cout\n";

out.linkStream(std::clog);
out << "2. To: std::cout and std::clog\n";

std::ofstream file("Plop");
out.linkStream(file);
out << "3. To all three locations\n";
}
[/code]

Diese Variante compiliert und funktioniert. Gibt es wirklich keinen einfacheren Weg?

Ich will eine Logger Klasse schreiben und wundere mich gerade, das es in C++ scheinbar nicht einfach ist die Ausgabe gleichzeitig auf den Bildschirm und/oder in eine Datei zu leiten.

Kann mich jemand auf den richtigen Weg führen?

Wo genau ist denn dein Problem? Du verwendest dafür einfach nur cout und einen ofstream.

Als Unixer gibt man häufig überhaupt nur auf die Standardausgabe aus und verwendet ggf. außerhalb des Programms noch man: tee(1).

void logger::log(string msg)
{
  std::clog << msg;
  file << msg;
}

Du könntest auch diverse ebenen tiefer gehen und dir einen eigenen streambuf schreiben, der das für dich übernimmt. Aber um das manuelle doppelte Ausgeben kommst du wohl nicht herum.

Die Streams hab ich nicht dazu gebracht, gleichzeitig an mehrere Ziele zu schreiben. Ein Beispiel hab ich gefunden, das streambuf verwendet um das zu erreichen (siehe Beispiel).
Ich frag mich nur, ob es keinen einfacheren Weg gibt.

Ich will im Program einfach nur loggen

log(debug) << dies ist ein einfacher log! << endl;

und das ausgeben und/oder in ein Logfile schreiben.

Kann mir wer beim Verstehen des Codes auf die Sprünge helfen?
Ich find keine Erklärung für das struct ComposeBuffer das sich von streambuf ableitet. Ein struct als Klasse?

Dieses struct Konstrukt hab ich so noch nie gesehen.

Also scheint es der streambuf zu werden. (Oh du steile c++ Lernkurve )

Du bist zwar nicht der einzige Anfänger, der meint einen Logger zu brauchen, aber du wärst sicherlich der erste, der wirklich einen braucht. Daher: Brauchst du wirklich einen? Falls ja: Wenn dir die anderen Lösungen nicht passen, dann bleibt wohl nur der Streambuf.

Kann mir wer beim Verstehen des Codes auf die Sprünge helfen?

Ich könnte es versuchen, aber:

Ein struct als Klasse?

Vielleicht solltest das ruhen lassen, bis du etwas mehr C++ kannst? Was bringt dir eine Erklärung, die du nicht verstehst? Frag in ein paar Wochen noch einmal nach Streambufs und mach bis dahin weiter Anfängerübungen. Dann lachst du darüber, dass du mal nicht gewusst hast, wie structs und Klassen sich zueinander verhalten und dann hast du auch eine Chance zu verstehen, wie die Streambufs funktionieren. Die Streams sind recht overdesigned, du musst mindestens Vererbung und Polymorphie verstehen, um die Streams zu verstehen und möglichst auch schon einmal selber viel mit den Streams gearbeitet haben, um die Schnittstellen zu kennen. Momentan wärst du damit wahrscheinlich ziemlich überfordert.

#include <iostream>
#include <fstream>
#include <boost/iostreams/tee.hpp>
#include <boost/iostreams/stream.hpp>

namespace io = boost::iostreams;

int main()
{
  typedef io::tee_device<std::ostream, std::ofstream> tee_device;
  std::ofstream ofs("log.txt");
  std::ostream cout_copy(std::cout.rdbuf());
  TeeDevice tee_device(cout_copy, ofs); 
  io::stream<tee_device> split(tee);
  std::cout.rdbuf(split.rdbuf());

  std::cout << "Hello, World!\n"; // schreib nach cout und nach log.txt
}

Zu boost/iostreams/tee hab ich keine brauchbare Doku gefunden.
Sonst hätte ich mir das schon überlegt.

lawl.

http://www.boost.org/doc/libs/
http://en.cppreference.com/w/

Ich will eine Logger Klasse schreiben und wundere mich gerade, das es in C++ scheinbar nicht einfach ist die Ausgabe gleichzeitig auf den Bildschirm und/oder in eine Datei zu leiten.

Kann mich jemand auf den richtigen Weg führen?

Edit: Google hilft teilweise.
Es geht wohl über den streambuf, dessen overflow und sync modifiziert werden.

Im Prinzip ja - guckst Du hier.
Die Weiche rufst Du auf, sobald klar ist, wo die Logging-Ausgabe hin gehen soll.

Gruß
Werner

Ich will eine Logger Klasse schreiben und wundere mich gerade, das es in C++ scheinbar nicht einfach ist die Ausgabe gleichzeitig auf den Bildschirm und/oder in eine Datei zu leiten.

Komisch, den Wunsch verspürte ich nie, obwohl er oft angefragt wird. Wenn ich in eine Datei logge, kann ich die doch in einem anderen Fenster bequem mitlesen, egal ob Windows oder Linux.

Komisch, den Wunsch verspürte ich nie, obwohl er oft angefragt wird. Wenn ich in eine Datei logge, kann ich die doch in einem anderen Fenster bequem mitlesen, egal ob Windows oder Linux.

Wie macht man das denn am besten? Geht das auch intelligenter als jede Sekunde "tail log" zu schreiben?

Wie macht man das denn am besten? Geht das auch intelligenter als jede Sekunde "tail log" zu schreiben?

Mit tail -f log?

qwas schrieb:

Mit tail -f log?

Ah danke - nun kommen mir meine "tail log"-Orgien rückblickend recht blöd vor.

Ah danke - nun kommen mir meine "tail log"-Orgien rückblickend recht blöd vor.

Falls du mehrere Files zu überwachen hast, kannst du auch multitail verwenden; auch ein sehr praktisches Tool.

Wie macht man das denn am besten? Geht das auch intelligenter als jede Sekunde "tail log" zu schreiben?

watch -n 1 -d tail log
wäre auch noch spaßig.