Herzlich Willkommen, lieber Gast!
  Sie befinden sich hier:

  Forum » C / C++ (ANSI-Standard) » cout nicht flushen

Forum | Hilfe | Team | Links | Impressum | > Suche < | Mitglieder | Registrieren | Einloggen
  Quicklinks: MSDN-Online || STL || clib Reference Grundlagen || Literatur || E-Books || Zubehör || > F.A.Q. < || Downloads   

Autor Thread - Seiten: > 1 <
000
19.05.2005, 18:55 Uhr
Spacelord
Hoffnungsloser Fall


Hallo,
mal angenommen ich möchte nen Manipulator schreiben der den Inhalt des streambuffers von cout formatieren soll,also etwa in der Art:

C++:
cout<<"Hallo Leute im Forum!\n"<<my_manip(par1,par2);



Wie kann ich es jetzt am saubersten anstellen dass der String "Hallo Leute im Forum!"
mit Sicherheit(!) noch im Puffer ist wenn der Manipulator(in diesem Fall ein Functor) zur Ausführung kommt?

Am Anfang von my_manip::operator()(ostream& os) möchte ich etwa in dieser Art an den Puffer inhalt kommen:


C++:
      streambuf* sb = os.rdbuf();    
      stringstream sstr;
      sstr<<sb;
      string strTemp = sstr.str();
.......



Jetzt ist aber nunmal so dass cout zu diesem Zeitpunkt schon geflusht wurde und nichts mehr im Puffer steht.
Mal abgesehen davon dass ich es eigentlich vermeiden möchte nounitbuf usw. zu verwenden ist mir das auch zu unsicher(funktioniert die halbe Zeit ohnehin nicht oder wird später von anderen Programmierern vergessen).
Es sollte also absolut sichergestellt sein dass der Inhalt der vor dem Manipulator steht auch noch im Puffer steht,andererseits sollte die "normale"
Arbeitsweise mit cout so wenig wie möglich beeinflusst werden.

Ich hoffe ich konnte halbwegs klar machen was ich möchte.

MfG Spacelord
--
.....Ich mach jetzt nämlich mein Jodeldiplom.Dann hab ich endlich was Eigenes.

Dieser Post wurde am 19.05.2005 um 19:53 Uhr von Spacelord editiert.
 
Profil || Private Message || Suche Download || Zitatantwort || Editieren || Löschen || IP
001
19.05.2005, 21:12 Uhr
virtual
Sexiest Bit alive
(Operator)


Was möglicherweise ein Ansatz wäre ist mittels rdbuf den StreamBuffer von cout auf einen stringstream Buffer zu setzen. Ansosnten sehe ich Dein Vorhaben auch aus Designsicht recht skeptisch.
--
Gruß, virtual
Quote of the Month
Ich eß' nur was ein Gesicht hat (Creme 21)
 
Profil || Private Message || Suche Download || Zitatantwort || Editieren || Löschen || IP
002
22.05.2005, 18:16 Uhr
Spacelord
Hoffnungsloser Fall



Zitat von virtual:
Was möglicherweise ein Ansatz wäre ist mittels rdbuf den StreamBuffer von cout auf einen stringstream Buffer zu setzen. Ansosnten sehe ich Dein Vorhaben auch aus Designsicht recht skeptisch.


Die Idee mit dem stringstream und den bitteren Beigeschmack was das Design angeht hatte ich auch.
Im ersten Augenblick hatten mich aber die zahlreichen Insertion Operatoren von ostream gelockt und ich fand es auch recht intuitiv diese Funktionalität als Manipulator anzubieten.
Die Funktionalität fällt bei meinem aktuellen Projekt eher als Nebeneffekt an und ich dachte mir dass die für "normale" Konsolenprojekte durchaus interessant ist.
Konkret geht es darum Ausgaben in einem festzulegendem Rechteck an beliebiger Position anzuzeigen.
Deshalb fand ich zuerst die Möglichkeit mit cout ganz ok.

C++:
cout<<"Gib Text,Zahlen:"<<3<<" und alles was nen << Operator bietet in folgendem Rechteck aus"<<rect_out(xPos,yPos,weite,hoehe);



Da sich das Ganze aber nicht ohne gepfusche an cout realisieren lässt hab ich jetzt umgeschwenkt und die Funktionalität komplett von cout unabhängig umgesetzt.
Um weiterhin die Möglichkeiten der zahlreichen << Operatoren nutzen zu können hab ich jetzt nen stringstream Attribut genommen und in der Klasse nen Member-Template für den Insertion Operator geschrieben der die Typen an das stringstream Attribut weiterreicht.
Damit dürfte die Klasse alles schlucken was auch cout annehmen würde.


C++:
#include <iostream>
using namespace std;

class rect_out  
{
public:
    rect_out(size_t x=0,size_t y=0,size_t width=0,size_t heigth=0);
    virtual ~rect_out();
    void setPosition(size_t x=0,size_t y=0){_x =x;_y=y;}
    void setSize(size_t w=0,size_t h=0){_w=w;_h=h;}

    rect_out& operator<<(rect_out& (*_f)(rect_out&))
    {
        return(*_f)(*this);        
    }

    template<typename T> rect_out& operator<<(const T& _t)
    {
        sstr<<_t;
        return *this;
    };

    void displayRect(){drawRect();}
    void delContent();
protected:
    virtual void drawRect();
private:
    size_t _x,_y,_w,_h;
    stringstream sstr;
};

inline rect_out& draw(rect_out& re)
{
    re.displayRect();
    return re;
};

inline rect_out& del(rect_out& re)
{
    re.delContent();
    return re;
}



Im Einsatz sieht das dann etwa so aus:

C++:
rect_out rect(15,15,20,4);
rect<<"Text und zahlen "<<3<<" und allen zippi zappi"<<draw;



Damit liegt das Ganze in etwa in dem Bereich wie ich es mir ursprünglich gedacht hatte.

MfG Spacelord
--
.....Ich mach jetzt nämlich mein Jodeldiplom.Dann hab ich endlich was Eigenes.

Dieser Post wurde am 22.05.2005 um 18:17 Uhr von Spacelord editiert.
 
Profil || Private Message || Suche Download || Zitatantwort || Editieren || Löschen || IP
Seiten: > 1 <     [ C / C++ (ANSI-Standard) ]  


ThWBoard 2.73 FloSoft-Edition
© by Paul Baecher & Felix Gonschorek (www.thwboard.de)

Anpassungen des Forums
© by Flo-Soft (www.flo-soft.de)

Sie sind Besucher: