in unserer Software gibt es eine C-Funktion Log(fmtStr, ...) , die bei jedem Aufruf eine Zeile in eine Datei schreibt.
Ich möchte jetzt einen C++-Stream haben, der diese Funktion aufruft. Dazu habe ich mir den Code von https://groups.google.com/forum/#!topic/comp.lang.c++.moderated/5zP90fSOVgU angesehen und eine streambuf-Klasse gebaut, die Log() aufruft.

Damit kann ich nun

TollesLog << "Bla " << "Blubb";

schreiben, und die Ausgabe erscheint im Logfile. Aber das Buffering stört - es muss unbedingt nach jeder Ausgabe geflusht werden. Ich bin schon auf

setf(std::ios::unitbuf);

gestoßen, was aber nicht das gewünschte Ergebnis bringt: es wird nun für jedes Datum Log() aufgerufen, statt "zeilenweise".

Ich will keine newlines oder std::endl oder ähnliches in den Stream schreiben müssen. Ich möchte, dass die Programmzeile

TollesLog << "Bla " << "Blubb";

zu einem einzigen Aufruf von Log() führt, und somit zu einer einzelnen Zeile im Logfile.

Wie lässt sich das bewerkstelligen?

du kannst nicht unterscheiden zwischen

str << 1 << 2;

und

str << 1;
str << 2;

mach einfach ein std::endl am ende jeder zeile

Ja, das ist schon klar. Will ich aber nicht. Gibt es keine andere Möglichkeit?

not smart schrieb:

mach einfach ein std::endl am ende jeder zeile

Ja, das ist schon klar. Will ich aber nicht. Gibt es keine andere Möglichkeit?

Du kannst auch std::flush reinschieben, das ist dasselbe, nur ohne Zeilenumbruch.

not smart hat bereits erwähnt, dass es hier keinen semantischen Unterschied zwischen

stream << a << b;
// und
stream << a; stream << b;

gibt, den dein Streambuffer feststellen könnte. Du musst dir einen Kompromiss überlegen.

Edit:

Aber das Buffering stört - es muss unbedingt nach jeder Ausgabe geflusht werden.

Wie wäre es mit einem kleineren Buffer?

du kannst nicht unterscheiden zwischen

str << 1 << 2;

und

str << 1;
str << 2;

So ähnlich kriegt mans aber hin.

struct HilfsLog{
    stringstream s;
    HilfsLog(Log &l) : log(l){}
    HilfsLog &operator <<(char *t){
        s << t;
        return *this;
    }
    ~HilfsLog(){
        log.log(s.str().c_str());
    }
    Log &log;
};
struct Log{
    HilfsLog operator (){
        return HilfsLog(this);
    }
    void log(char *s){
        Log(s, ...); //c-Funktion, nicht stuct typ
    }
} TollesLog;

//Benutzung
TollesLog() << "Bla" << "Keks"; //<-Beim Semikolon wird das temporäre
//HilfsLog-Objekt, dass durch TollesLog() erzeugt wurde zerstört und
//ruft Log::log mit "BlaKeks" auf. Danach noch flushen

Was bringt es denn, die Buffergröße zu ändern?

Nun, es wird lediglich öfter geflusht, da der Buffer schneller voll ist. Ist aber wahrscheinlich nicht was du willst.

raute schrieb:

@nwp: Das sieht ganz gut aus. Interessante Idee.

Aber was bringt das? Ich verstehe immer noch nicht, wieso du nicht einfach immer wenn geflusht werden soll das auch explizit sagst. Ist das so umständlich?

#include <iostream>
struct LogHelper
{
	std::ostream& Target;
	LogHelper(std::ostream& Target)
		: Target(Target)
	{
	}
	~LogHelper()
	{
		Target << std::endl;
	}
};
template<class T>
std::ostream& operator<< (LogHelper Stream, T const& Rhs)
{
	return Stream.Target << Rhs;
}
struct Log
{
	std::ostream& Target;
	Log(std::ostream& Target)
		: Target(Target)
	{
	}
};
template<class T>
LogHelper operator<< (Log& Stream, T const& Rhs)
{
	Stream.Target << Rhs;
	return LogHelper(Stream.Target);
}
Log TollesLog(std::cout);
struct UserDefinedType
{
	float Lhs, Rhs;
	UserDefinedType(float Lhs, float Rhs)
		: Lhs(Lhs), Rhs(Rhs)
	{
	}
};
std::ostream& operator<< (std::ostream& Stream, UserDefinedType const& Rhs)
{
	return Stream << '(' << Rhs.Lhs << '|' << Rhs.Rhs << ')';
}
int main()
{
	UserDefinedType Var(5, -5);
	TollesLog << "Hallo" << ' ' << "Welt" << 123;
	TollesLog << "Hallo Welt";
	TollesLog << "Mein Typ: " << Var;
}

Hallo Welt123
Hallo Welt
Mein Typ: (5|-5)

http://ideone.com/91xUwB

Ich verstehe immer noch nicht, wieso du nicht einfach immer wenn geflusht werden soll das auch explizit sagst.

Aus dem gleichen Grund, warum Log() kein explizites newline am Ende des Strings erfordert: weil man sich nicht ständig unnötig wiederholen will. Es gibt überhaupt keinen Fall, wo nicht geflusht werden soll.

in unserer Software gibt es eine C-Funktion Log(fmtStr, ...) , die bei jedem Aufruf eine Zeile in eine Datei schreibt.
Ich möchte jetzt einen C++-Stream haben, der diese Funktion aufruft.

Eigentlich ist die Funktions-Syntax besser. Das ist dann ein variadic Makro vor einem variadic Template, das normal in den Stream schreibt und am Ende die Zeile umbricht und flusht. Und man kann das Logging inclusive Auswertung der Log-Argumente abschalten! Ach, Du bist ja auch an so einen Krüppel-Stream geraten.
Viel Spaß mit

debugLog<< "FileExists(\"bla.dat\")=" << FileExists("bla.dat");

raute schrieb:

streambuf gebaut

raute schrieb:

Damit kann ich nun

TollesLog << "Bla " << "Blubb";

schreiben, und die Ausgabe erscheint im Logfile.

Ich würde LOG("Bla","Blubb") nicht völlig ausschließen.