Logging mit ostream

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?

Columbo

raute schrieb:

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?

not smart schrieb:

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

std::flush ist schon besser, aber immer noch hässlich. Völlig inakzeptabel, da lasse ich es lieber wie es ist.
Was bringt es denn, die Buffergröße zu ändern? Ich will weder, dass Zeilen umbrochen werden, noch dass zwei logische Zeilen in einer physischen landen. Beides darf nicht passieren.

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

Columbo

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?

hihi wenn wir schon beim basteln sind:

#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

(macht das selbe wie das von nwp3 aber für jeden typ T und auch ohne klammern nach TollesLog)

Arcoth schrieb:

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.

volkard

raute schrieb:

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.