C/C++ Forum :: cout Ausgaben in txt Datei schreiben

phlox81 Moderator 11:43:47 30.07.2005 Titel:

Man soll C und C++ nicht mischen :rolleyes:

C++ bietet schließlich zu fast allem was C kann gute Alternativen.

Pdug Mitglied 12:30:26 30.07.2005 Titel:

phlox81 schrieb:

Man soll C und C++ nicht mischen :rolleyes:

C++ bietet schließlich zu fast allem was C kann gute Alternativen.

Genaugenommen ist genau das zur Zeit meine Aufgabe ...

IMHO: Ohne triftigen Grund sollte man C++ gegenüber C vorziehen · C++ ist typsicherer, modularer uvm ...
(und wär es nicht so langsam: Java ·
oder C# ? - kenn ich persönlich noch nicht, habe nur mal von Properties in C# gehört und das hörte sich gut an)

otze Mitglied 13:02:40 30.07.2005 Titel:

Zitat:

Grins - C++ ist irgendwie objektorientiert, ne?

nein, wenn überhaupt dann objektbasiert, aber eher multiparadigm, ändert aber nichts an der tatsache, dass C++ anders funktioniert.

Zitat:

Vom überladen von Operatoren hab ich noch nie was gehalten.

schade, da entgeht dir ne Menge.

Zitat:

std::cout << "Hallo!"; heißt bei mir debug("Hallo"); und hat letztlich was mit printf zu tun ...

nein, hat es nicht. C++ streams setzen nicht auf den C funktionen auf.
hätte es was mit printf zu tun, hätte man ein problem mit eigenen typen und insbesondere mit templates!

Zitat:

(und wär es nicht so langsam: Java. [...])

deine Infos sind veraltet, java ist nicht langsam.

7H3 N4C3R Mitglied 14:25:03 30.07.2005 Titel:

Argh... objektorientiert programmieren heißt nicht, dass man irgendwo class vorschreibt. Auch mit C kann man objektorientiert programmieren... man sehe sich mal die File-Schnittstelle an. Ich glaub aber mal... Thema verfehlt ^^ Sollte woanders fortgesetzt werden.

Pdug Mitglied 18:07:28 30.07.2005 Titel:

Zitat:

schade, da entgeht dir ne Menge.

Mag sein. - Nur um dir ne Freude zu machen werd ich meine Haltung dazu noch mal überdenken.

Zitat:

...hat letztlich was mit printf zu tun

ist zu lesen: Ich verwende für Methoden wie z.B. debug("Hallo"); noch printf (ist mitnichten eine Aussage über C++ oder guten Programmierstil)

Java hat sich in den letzten Jahren sehr positiv entwickelt · Bei einem sukzessiven Wechsel in den letzten Monaten (Java Projekt endete - C++ Projekt begann) habe ich einen Performanceunterschied bemerkt. (Habe keine Benchmarktests gemacht ..) Worauf ich unten hinaus wollte: Solche Unterschiede außer Acht gelassen würde ich Java im Zweifelsfall gegenüber C(++) den Vortritt lassen

(objektorientiert programmieren heißt auch nicht, dass man irgendwelche Methoden nicht benutzen darf, weil sie aus dem falschen Stall kommen.)

Artchi Autor 18:19:46 30.07.2005 Titel:

Bitte keine Java vs. C++ Diskussion. Sonst fang ich auch gleich an.

Im ernst, lasst es. Der Fragesteller hat jetzt eine Lösung auf seine Frage und gut ist.

Pdug Mitglied 18:32:35 30.07.2005 Titel:

Zitat:

Bitte keine ...

Ganz im ernst: Geht mir auch so · und schönes WE noch ...

Werner Salomon Mitglied 17:26:22 31.07.2005 Titel:

brainesic schrieb:

möchte meine ganzen Kontrollausgaben (momentan über cout) AUCH in eine Textdatei schreiben. Möchte aber nicht an jede cout Stelle gehen und den gleichen Inhalt nochmal auf eine Textdatei richten.

Gibt es eine Möglichkeit die Funktion cout so umzuschreiben, dass die Ausgaben auf dem Bildschirm erscheinen UND in eine Textdatei geschrieben werden ?

Ja, diese Möglichkeit gibt es. Zunächst muss man einiges dazu wissen. 'cout' ist keine Funktion sondern ein Objekt vom Type std::ostream. In C++ bzw. genauer in der Input/Output-Library von C++ ist jede IO-Konstruktion immer zweigeteilt. Auf der einen Seite stehen die iostream's und auf der anderen die streambuf's. Letztere und nur die sind dafür zuständig Zeichen irgendwo hinzuschreiben oder irgendwo rauszulesen. Die Streams dienen 'nur' der Formatierung und als Anwender-Schnittstelle.

D.h. wenn Du die Ausgabe verdoppeln willst, musst Du an den Streambuf von cout ran. Die Idee ist, zwischen dem cout-Objekt und seinem Streambuf einen weiteren Streambuf (im folgenden mal 'Weiche' genannt) zu hängen und alle Zeichen, die dort durchkommen auch an einen weiteren Streambuf Deiner Wahl zu leiten.

So könnte es aussehen:

C/C++ Code:
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55	1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55	#include <iostream> #include <fstream> #include <streambuf> class Weiche : public std::streambuf { public: typedef std::streambuf base_type; typedef base_type::traits_type traits_type; Weiche( std::ostream& out, std::ostream& out2 ) : m_sb1( out.rdbuf() ) , m_sb2( out2.rdbuf() ) , m_out1( out ) { out.rdbuf( this ); // hänge mich selbst bei 'out' als Streambuf ein. } ~Weiche() { m_out1.rdbuf( m_sb1 ); // Stellt die Ausgangssituation wieder her } protected: virtual overflow( int_type c = traits_type::eof() ) { // jedes Zeichen an BEIDE Streambufs sb1 & sb2 weitergeben if( m_sb1 && m_sb2 && !traits_type::eq_int_type( m_sb1->sputc( c ), traits_type::eof() ) && !traits_type::eq_int_type( m_sb2->sputc( c ), traits_type::eof() ) ) return traits_type::not_eof( c ); return traits_type::eof(); // einer der Streambufs tut nicht } private: Weiche( const Weiche& ); Weiche& operator=( const Weiche& ); // Kopieren verhindern std::streambuf* m_sb1; std::streambuf* m_sb2; std::ostream& m_out1; }; int main() { using namespace std; ofstream fout("cout.log"); Weiche w( cout, fout ); // Ausgaben von cout gleichzeitig auf fout lenken cout << "ein kleines Programm ... " << endl; for( int i=0; i<10; ++i ) cout << " " << i; cout << "\nProgramm-Ende" << endl; return 0; }

C/C++ Code:
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55	#include <iostream> #include <fstream> #include <streambuf> class Weiche : public std::streambuf { public: typedef std::streambuf base_type; typedef base_type::traits_type traits_type; Weiche( std::ostream& out, std::ostream& out2 ) : m_sb1( out.rdbuf() ) , m_sb2( out2.rdbuf() ) , m_out1( out ) { out.rdbuf( this ); // hänge mich selbst bei 'out' als Streambuf ein. } ~Weiche() { m_out1.rdbuf( m_sb1 ); // Stellt die Ausgangssituation wieder her } protected: virtual overflow( int_type c = traits_type::eof() ) { // jedes Zeichen an BEIDE Streambufs sb1 & sb2 weitergeben if( m_sb1 && m_sb2 && !traits_type::eq_int_type( m_sb1->sputc( c ), traits_type::eof() ) && !traits_type::eq_int_type( m_sb2->sputc( c ), traits_type::eof() ) ) return traits_type::not_eof( c ); return traits_type::eof(); // einer der Streambufs tut nicht } private: Weiche( const Weiche& ); Weiche& operator=( const Weiche& ); // Kopieren verhindern std::streambuf* m_sb1; std::streambuf* m_sb2; std::ostream& m_out1; }; int main() { using namespace std; ofstream fout("cout.log"); Weiche w( cout, fout ); // Ausgaben von cout gleichzeitig auf fout lenken cout << "ein kleines Programm ... " << endl; for( int i=0; i<10; ++i ) cout << " " << i; cout << "\nProgramm-Ende" << endl; return 0; }

C/C++ Code:
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55	#include <iostream> #include <fstream> #include <streambuf> class Weiche : public std::streambuf { public: typedef std::streambuf base_type; typedef base_type::traits_type traits_type; Weiche( std::ostream& out, std::ostream& out2 ) : m_sb1( out.rdbuf() ) , m_sb2( out2.rdbuf() ) , m_out1( out ) { out.rdbuf( this ); // hänge mich selbst bei 'out' als Streambuf ein. } ~Weiche() { m_out1.rdbuf( m_sb1 ); // Stellt die Ausgangssituation wieder her } protected: virtual overflow( int_type c = traits_type::eof() ) { // jedes Zeichen an BEIDE Streambufs sb1 & sb2 weitergeben if( m_sb1 && m_sb2 && !traits_type::eq_int_type( m_sb1->sputc( c ), traits_type::eof() ) && !traits_type::eq_int_type( m_sb2->sputc( c ), traits_type::eof() ) ) return traits_type::not_eof( c ); return traits_type::eof(); // einer der Streambufs tut nicht } private: Weiche( const Weiche& ); Weiche& operator=( const Weiche& ); // Kopieren verhindern std::streambuf* m_sb1; std::streambuf* m_sb2; std::ostream& m_out1; }; int main() { using namespace std; ofstream fout("cout.log"); Weiche w( cout, fout ); // Ausgaben von cout gleichzeitig auf fout lenken cout << "ein kleines Programm ... " << endl; for( int i=0; i<10; ++i ) cout << " " << i; cout << "\nProgramm-Ende" << endl; return 0; }

..das ist nicht die performanteste Lösung, aber sie braucht nicht so viel Code.

Gruß
Werner

Unregistrierter

****************

Unregistrierter

Besten Dank Werner Salomon,

das nenn ich mal kompetente Hilfe. :live:

Einfach ausgezeichnet!

Nochmals Vielen Dank