ist es möglich, die Werte, welche an cout übergeben werden
sollen, über eine Funktion zu übergeben?
Beispiel:

cout << "ein Text" << ", flags:" << inputFile.good() << inputFile.eof() << endl;

und dann per Funktion:

void Output_Error(??? msg)
{
	cout << msg;
}
Aufruf dann irgendwie so:

Output_Error("ein Text" << ", flags:" << inputFile.good() << inputFile.eof() << endl);

Ist blöd zu erklären, hoffe es versteht jemand...

Danke und Grüße pumi

Bau dir nen String und übergib den.

danke für deine Antwort.
Einen String zu bauen wolte ich ja gerade vermeiden, da ja dann die
ganze Power von cout verloren geht, und ich jeden Typ usw. selber
casten müsste.

Grüsse pumi

Danke und Grüsse pumi

#define OutputError(msg)    do { std::cout << msg; } while(false)

Damit funktioniert dann Dein Aufruf. Das do..while habe ich gemacht, damit es syntaktisch mit einer Anweisung identisch ist. Dann bekommst Du keine Probleme mit der Auswertreihenfolge von Operatoren oder ähnliches.
In dem Makro kannst Du natürlich auch komplexere Dinge machen, wie z. B. ein Flag auswerten, ob die Ausgabe überhaupt erfolgen soll. Das hat den Vorteil, dass die ganze Formatierung nur durchgeführt wird, wenn das Flag gesetzt ist.

Ich habe so etwas mal selbst gemacht. Ein Beispiel findest Du unter http://www.tntnet.org/download/cxxtools-1.4.7/include/cxxtools/log/cxxtools.h

2000 Mädchen schrieb:

Bau dir nen String und übergib den.

danke für deine Antwort.
Einen String zu bauen wolte ich ja gerade vermeiden, da ja dann die
ganze Power von cout verloren geht, und ich jeden Typ usw. selber
casten müsste.

Grüsse pumi

Is klar, Bildschirmausgabe ist natürlich viel schneller als stringstream. Und warum musst du casten?

Mach dich mal über stringstreams schlau.
z.B. hier http://www.cplusplus.com/reference/iostream/stringstream/

Oder einfach mal danach googeln.

Alternativ kannst du auch ein ostream Objekt anlegen
und das an deine Funktion übergeben um es dort auszugeben.

außer den bereits erwähnten Lösungsansätzen gibt es noch die Möglichkeit, eine sogenannte Expression zu konstruieren, die dann als ganzes an die Funktion 'Output_Error' übergeben wird. Die eigentlichen Ausgabe erfolgt dann erst innerhalb der Funktion.

Hier mal ein Ansatz ohne Anspruch auf Optimierung und Vollständigkeit.

#include <iostream>

struct Nix {};
std::ostream& operator<<( std::ostream& out, Nix )
{
    return out;
}

template< typename T1, typename T2 >
struct OutputExpr
{
    OutputExpr() : m_a(), m_b() {}
    OutputExpr( T1 a, T2 b )
        : m_a( a )
        , m_b( b )
    {}

    // --   für Text
    OutputExpr< OutputExpr<T1,T2>, const char* > operator<<( const char* x )
    {
        return OutputExpr< OutputExpr<T1,T2>, const char* >( *this, x );
    }
    // --   für endl, usw.
    OutputExpr< OutputExpr<T1,T2>, std::ostream& (*)( std::ostream& ) > operator<<( std::ostream& (*x)( std::ostream& ) )
    {
        return OutputExpr< OutputExpr<T1,T2>, std::ostream& (*)( std::ostream& ) >( *this, x );
    }
    // --   für den Rest
    template< typename X >
    OutputExpr< OutputExpr<T1,T2>, X > operator<<( const X& x )
    {
        return OutputExpr< OutputExpr<T1,T2>, X >( *this, x );
    }

    friend std::ostream& operator<<( std::ostream& out, const OutputExpr& ex )
    {
        return out << ex.m_a << ex.m_b;
    }
private:
    T1 m_a;
    T2 m_b;
};

// --   globale Variable
OutputExpr< Nix, Nix > trc;

template< typename T1, typename T2 >
void Output_Error( const OutputExpr< T1, T2 >& msg )
{
    using namespace std;
    cout << msg;
} 
// Makro falls man die globale Variable 'trc' nicht im Code sehen soll.
#define OUTPUT_ERROR( x ) Output_Error( trc << x )

int main()
{
    using namespace std;
    ostream inputFile(0);
    Output_Error( trc << "ein Text" << ", flags:" << inputFile.good() << inputFile.eof() << endl );
    OUTPUT_ERROR( "Eine Ausgabe ohne 'trc' im Code" << endl );
    return 0;
}

Ist vielleicht ein bisschen heftig für einen Anfänger, aber sollte im Prinzip leicht anwendbar sein.

Gruß
Werner

Gruesse pumi