cout über eine Funktion übergeben

pumi

Hallo,

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.

pumi

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

Firefighter

vieleicht solltest du überlegen dir eine Klasse zu schreiben und den operator<< zu überladen und gucken ob dir dort die gewünschte Funktion basteln kannst.

pumi

hm.. das klingt kompliziert.
Ich wüsste leider nicht wie ich so etwas hinbekommen
könnte.(bin noch Anfänger)
Hast du mir einen Ansatz, wie so etwas aussehen könnte?

Danke und Grüsse pumi

tntnet

Also zunächst einmale: es geht nicht. Es gibt allerdings 2 Lösungsmöglichkeiten. Es hängt davon ab, was Du erreichen willst. Entweder implementierst Du einen std::ostream, bzw. ein std::streambuf. Das ist aber nicht unbedingt etwas für Anfänger. Oder Du verwendest Makros. Ich vermute mal, dass das Dein Problem löst. Also etwa so:

#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

pumi schrieb:

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?

dark-eye

@pumi:

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.

Werner Salomon

Hallo pumi,

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

pumi

vielen Dank für die Antworten.
Damit sollte ich klar kommen.

Gruesse pumi