std::basic_stringbuf<CharT,Traits,Allocator>::overflow

 

C++

Compiler-Unterstützung

Freestanding und gehostet

Sprache

Standardbibliothek

Header der Standardbibliothek

Benannte Anforderungen

Feature-Test-Makros (C++20)

Bibliothek für Sprachunterstützung

Konzepte-Bibliothek (C++20)

Diagnostik-Bibliothek

Speicherverwaltungsbibliothek

Metaprogrammierungsbibliothek (C++11)

Allgemeine Dienstprogramme-Bibliothek

Container-Bibliothek

Iterator-Bibliothek

Ranges-Bibliothek (C++20)

Algorithmen-Bibliothek

Bibliothek für Zeichenketten

Textverarbeitungsbibliothek

Numerik-Bibliothek

Datums- und Zeitbibliothek

Ein-/Ausgabe-Bibliothek

Dateisystembibliothek (C++17)

Unterstützung für nebenläufige Programmierung (C++11)

Ausführungssteuerungsbibliothek (C++26)

Technische Spezifikationen

Symbolverzeichnis

Externe Bibliotheken

 

Ein-/Ausgabe-Bibliothek

I/O-Manipulatoren

Print-Funktionen (C++23)

C-Style I/O

Puffer

basic_streambuf

basic_filebuf

basic_stringbuf

basic_spanbuf (C++23)

strstreambuf (C++98/26*)

basic_syncbuf (C++20)

Streams

Abstraktionen

ios_base

basic_ios

basic_istream

basic_ostream

basic_iostream

Datei-I/O

basic_ifstream

basic_ofstream

basic_fstream

String-I/O

basic_istringstream

basic_ostringstream

basic_stringstream

Array-I/O

basic_ispanstream (C++23)

basic_ospanstream (C++23)

basic_spanstream (C++23)

istrstream (C++98/26*)

ostrstream (C++98/26*)

strstream (C++98/26*)

Synchronisierte Ausgabe

basic_osyncstream (C++20)

Typen

streamoff

streamsize

fpos

Fehlerkategorie-Schnittstelle

iostream_category (C++11)

io_errc (C++11)

 

std::basic_stringbuf

Öffentliche Memberfunktionen

basic_stringbuf::basic_stringbuf

basic_stringbuf::operator= (C++11)

basic_stringbuf::swap (C++11)

basic_stringbuf::str

basic_stringbuf::get_allocator (C++20)

basic_stringbuf::view (C++20)

Geschützte Memberfunktionen

basic_stringbuf::underflow

basic_stringbuf::pbackfail

basic_stringbuf::overflow

basic_stringbuf::setbuf

basic_stringbuf::seekoff

basic_stringbuf::seekpos

Nicht-Member-Funktionen

swap(std::basic_stringbuf) (C++11)

Nur exposition-only Memberfunktionen

basic_stringbuf::init_buf_ptrs

 

protected: virtual int_type overflow( int_type c = Traits::eof() );

Hängt das Zeichen c an die Ausgabezeichensequenz an.

Wenn c der End-of-File-Indikator ist (traits::eq_int_type(c, traits::eof()) = true), dann gibt es kein Zeichen anzuhängen. Die Funktion tut nichts und gibt einen nicht spezifizierten Wert zurück, der sich von traits::eof() unterscheidet.

Andernfalls, wenn die Ausgabesequenz eine verfügbare Schreibposition hat oder diese Funktion erfolgreich eine Schreibposition verfügbar machen kann, ruft sie sputc(c) auf und gibt c zurück.

Diese Funktion kann eine Schreibposition verfügbar machen, wenn der std::stringbuf für die Ausgabe geöffnet ist ((mode & ios_base::out) != 0): In diesem Fall wird der Puffer neu zugewiesen (oder initial zugewiesen), um groß genug zu sein, um den gesamten aktuellen Puffer plus mindestens ein weiteres Zeichen aufzunehmen. Wenn der std::stringbuf auch für die Eingabe geöffnet ist ((mode & ios_base::in) != 0), erhöht overflow auch die Größe des Get-Bereichs, indem egptr() so verschoben wird, dass er direkt hinter die neue Schreibposition zeigt.

Parameter

c

-

das zu speichernde Zeichen im Put-Bereich

Rückgabewert

Traits::eof(), um einen Fehler anzuzeigen, c, wenn das Zeichen c erfolgreich angehängt wurde, oder einen Wert, der sich von Traits::eof() unterscheidet, wenn er mit Traits::eof() als Argument aufgerufen wurde.

Hinweise

Diese Funktion unterscheidet sich von einem typischen overflow(), das den Inhalt des Puffers in die zugehörige Zeichensequenz verschiebt, da bei einem std::basic_stringbuf der Puffer und die zugehörige Sequenz eins und dasselbe sind.

Beispiel

In der Implementierung, die zur Ausführung dieses Beispiels verwendet wird (z. B. GCC-4.9), überweist overflow() den Put-Bereich auf 512 Bytes: ein Aufruf von str() würde nur die vier initialisierten Bytes zurückgeben, aber die nächsten 508 Aufrufe von sputc() würden keine neuen Aufrufe von overflow() erfordern.

Führen Sie diesen Code aus

#include <sstream>
#include <iostream>
 
struct mybuf : std::stringbuf
{
    mybuf(const std::string& new_str,
          std::ios_base::openmode which = std::ios_base::in | std::ios_base::out)
        : std::stringbuf(new_str, which) {}
 
    int_type overflow(int_type c = EOF) override
    {
        std::cout << "stringbuf::overflow('" << char(c) << "') called\n"
                  << "Before: size of get area: " << egptr() - eback() << '\n'
                  << "        size of put area: " << epptr() - pbase() << '\n';
 
        int_type ret = std::stringbuf::overflow(c);
 
        std::cout << "After : size of get area: " << egptr() - eback() << '\n'
                  << "        size of put area: " << epptr() - pbase() << '\n';
 
        return ret;
    }
};
 
int main()
{
    std::cout << "read-write stream:\n";
    mybuf sbuf("   "); // read-write stream
    std::iostream stream(&sbuf);
    stream << 1234;
    std::cout << sbuf.str() << '\n';
 
    std::cout << "\nread-only stream:\n";
    mybuf ro_buf("   ", std::ios_base::in); // read-only stream
    std::iostream ro_stream(&ro_buf);
    ro_stream << 1234;
 
    std::cout << "\nwrite-only stream:\n";
    mybuf wr_buf("   ", std::ios_base::out); // write-only stream
    std::iostream wr_stream(&wr_buf);
    wr_stream << 1234;
}

Mögliche Ausgabe

read-write stream:
stringbuf::overflow('4') called
Before: size of get area: 3
        size of put area: 3
After : size of get area: 4
        size of put area: 512
1234
 
read-only stream:
stringbuf::overflow('1') called
Before: size of get area: 3
        size of put area: 0
After : size of get area: 3
        size of put area: 0
 
write-only stream:
stringbuf::overflow('4') called
Before: size of get area: 0
        size of put area: 3
After : size of get area: 0
        size of put area: 512

Fehlerberichte

Die folgenden Verhaltensändernden Fehlerberichte wurden rückwirkend auf zuvor veröffentlichte C++-Standards angewendet.

DR	angewendet auf	Verhalten wie veröffentlicht	Korrigiertes Verhalten
LWG 169	C++98	der Puffer (neu) zugewiesen konnte nur ein zusätzliches Zeichen aufnehmen	lässt mehr zusätzliche Zeichen zu
LWG 432	C++98	overflow verschob epptr(), um direkt hinter das Neue zu zeigen Schreibposition, wenn der std::stringbuf für die Eingabe geöffnet ist	er wird nicht verschoben

Siehe auch

overflow [virtuell]	schreibt Zeichen aus dem Put-Bereich in die zugeordnete Ausgabesequenz (virtuelle geschützte Member-Funktion von std::basic_streambuf<CharT,Traits>)
underflow [virtuell]	gibt das nächste in der Eingabesequenz verfügbare Zeichen zurück (virtuelle geschützte Memberfunktion)