char Buffer_ptr[FILE_BUFFER_SIZE];
std::fstream swap_file_ptr("sdfsfd",ios....);
std::streambuf *Buffer_ptr_streambuf;
Buffer_ptr_streambuf=swap_file_ptr.rdbuf()->pubsetbuf(Buffer_ptr,FILE_BUFFER_SIZE);

Ich kann jetzt über den pointer Buffer_ptr_streambuf in Buffer_ptr schreiben mit

Buffer_ptr_streambuf->sputn("..........",sizeof("........."));

Wenn ich nun den Buffer_ptr in die Datei schreiben will so muß ich

Buffer_ptr_streambuf->pubsync();

Das funktioniert so, daß die Funktion sputn den
streambuf::epptr
pointer auf das zuletzt geschriebene Byte int Buffer_ptr setzt. So habe ich das zumindest verstanden.
Das
streambuf::pubsync()
Schreibt dann vom startpunkt bis zum streambuf::epptr.

--------------------------------------------------------------------
Kann ich irgendwie den epptr pointer selber setzen????
Ziel ist es folgendes machen zu können:

//In das Buffer Array schreiben
memcpy(Buffer_ptr,"........",sizeof("..........."));
//std::streambuf sagen daß zeichen im buffer sind
?????????????????????;
//Die Zeichen in die Datei schreiben
Buffer_ptr_streambuf->pubsync();

Also wie bekomme ich das
?????????????????;
hin ??
---------------------------------------------------------------------
Ableiten weiß ich nicht wie, da die
std::streambuf
Instanz von
std::fstream
erzeugt wurde.

Gruß

http://www.cplusplus.com/reference/iostream/streambuf/setp/

Frage: Dir ist aber schon klar, dass die Standardein-/ausgabe bereits gepuffert ist? Wenn du durch deine memcpy Operation nicht irgendeine neue tolle Funktionalität bekommst, ist dein Programm - zumindest geschwindigkeitstechnisch - kein Fortschritt.

Finde ich aber trotzdem mal interessant zu sehen, wie man die Streamoperatoren selbst implementiert.

528       /**
529        *  @brief  Setting the three write area pointers.
530        *  @param  pbeg  A pointer.
531        *  @param  pend  A pointer.
532        *  @post  @a pbeg == @c pbase(), @a pbeg == @c pptr(), and
533        *         @a pend == @c epptr()
534       */
535       void
536       setp(char_type* __pbeg, char_type* __pend)
537       {
538         _M_out_beg = _M_out_cur = __pbeg;
539         _M_out_end = __pend;
540       }

515       char_type*
516       epptr() const { return _M_out_end; }

Mir genügt das ende. Die funktion war nicht das Problem. Beide Member sind protected. Ich habe keinen zugriff.
Ich versuche nun:

class my_streambuf : public std::streambuf
{
   public:
        char* my_epptr() const { return std::streambuf::epptr(); }
};

Dann einen Pointer vom Type
my_streambuf
Und dann zugreifen.
Hoffe das klappt.

Wegen der Standartpufferung:
Das wird eine Rescue funktion die auf die Festpalatte schreibt, wenn kein Arbeitsspeicher im System mehr verfügbar ist.
+ Sie muß schnell gehen.
Deswegen eigene Pufferung.

gtuß

Das ganze läuft jetzt.
Die Lösung:

class my_streambuf : public std::streambuf
{
   public:
        char* my_epptr() const { return std::streambuf::epptr(); }
        void my_setp(char *start,char *end){ setp(start,end);}
};

char Buffer_ptr[FILE_BUFFER_SIZE];
std::fstream swap_file_ptr("sdfsfd",ios....);
std::my_streambuf *Buffer_ptr_streambuf;
Buffer_ptr_streambuf=reinterpret_cast<my_streambuf *>swap_file_ptr.rdbuf()->pubsetbuf(Buffer_ptr,FILE_BUFFER_SIZE);

Dann kann man mit

//In das Buffer Array schreiben
memcpy(Buffer_ptr,"........",sizeof("..........."));
//std::streambuf sagen daß zeichen im buffer sind
Buffer_ptr_streambuf->my_setp(Buffer_ptr,(Buffer_ptr+tmpp.size()));
//Die Zeichen in die Datei schreiben
Buffer_ptr_streambuf->pubsync();

In die Datei schreiben.
Frag mich ob ich die Pointer wieder zurücksetzen muß, um die alte Funktionalität der Klasse zu behalten.

Gruß

/usr/lib/gcc/i686-pc-linux-gnu/4.3.2/include/g++-v4/streambuf

528       /**
529        *  @brief  Setting the three write area pointers.
530        *  @param  pbeg  A pointer.
531        *  @param  pend  A pointer.
532        *  @post  @a pbeg == @c pbase(), @a pbeg == @c pptr(), and
533        *         @a pend == @c epptr()
534       */
535       void
536       setp(char_type* __pbeg, char_type* __pend)
537       {
538         _M_out_beg = _M_out_cur = __pbeg;
539         _M_out_end = __pend;
540       }

515       char_type*
516       epptr() const { return _M_out_end; }

Mir genügt das ende. Die funktion war nicht das Problem. Beide Member sind protected. Ich habe keinen zugriff.

Häh? Die Funktion setp macht doch EXAKT das was du willst, sowohl laut Standardreferenz als auch im Quellcode, wie du gesehen hast.

edit: Ok, da hast du es selbst schneller gemerkt, als ich geantwortet habe.

Wegen der Standartpufferung:
Das wird eine Rescue funktion die auf die Festpalatte schreibt, wenn kein Arbeitsspeicher im System mehr verfügbar ist.
+ Sie muß schnell gehen.
Deswegen eigene Pufferung.

gtuß

Das kann ich mal überhaupt nicht nachvollziehen: Der Speicher ist voll und du legst noch zusätzlich deinen eigenen Ausgabepuffer an der Speicher braucht und das alles, obwohl es bereits eine gepufferte Ausgabe gibt?

Um im Notfall etwas zu retten will man eher eine ungepufferte Ausgabe (wie cerr), damit überhaupt noch irgendwas auf der Platte ankommt.

Die erste lösung ist falsch. Es wird noch folgendes benötigt:

class my_streambuf : public std::streambuf
{
   public:
        char* my_epptr() const { return std::streambuf::epptr(); }
        void my_setp(char *start,char *end){ setp(start,end);}
        //erhöht den put zähler um n
        void my_pbump(int n){pbump(n);}

};

char Buffer_ptr[FILE_BUFFER_SIZE];
std::fstream swap_file_ptr("sdfsfd",ios....);
std::my_streambuf *Buffer_ptr_streambuf;
Buffer_ptr_streambuf=reinterpret_cast<my_streambuf *>swap_file_ptr.rdbuf()->pubsetbuf(Buffer_ptr,FILE_BUFFER_SIZE);

Schreiben mit:

//In das Buffer Array schreiben
memcpy(Buffer_ptr,"........",sizeof("..........."));
//std::streambuf sagen daß zeichen im buffer sind
Buffer_ptr_streambuf->my_setp(Buffer_ptr,(Buffer_ptr+tmpp.size()));
//Den put zähler erhöhen
Buffer_ptr_streambuf->my_pbump(tmpp.size());
//Die Zeichen in die Datei schreiben
Buffer_ptr_streambuf->pubsync();

Schreiben mit nur dem put zähler erhöhen schlägt genau so fehl wie schreiben mit
Grenzen nicht setzen.

Gruß

Kurtz: Ist genügend Speicher vorhanden, um die Klasse zu instanzieren, kann sie ausschließlich auf der Festplatte arbeiten. Damit das System nicht ganz in die knie geht benötige ich einen puffer, dessen Größe konstant sein muß und im konstruktor alloziirt wird.

Wenn ich die arbeit hier nicht mache, ist ja klar dass nichts mehr auf der Festplatte ankommt.
Deswegen.

Rescue
+geschwindigkeit
->eigener puffer

Genau das ist ja der Sinn des ganzen.

gruß

new(nothrow)
Man muß was tuen damit ne ausnahme geworfen wird. Zumindest bei meinem kompiler.

was willst du damit sagen? Oo

bb