Namensräume
Varianten
Aktionen

std::basic_streambuf<CharT,Traits>::overflow

Von cppreference.com
< cpp‎ | io‎ | basic streambuf
 
C++
 
Ein-/Ausgabe-Bibliothek
 
std::basic_streambuf
 
protected:
virtual int_type overflow( int_type ch = Traits::eof() );

Die Absicht dieser Funktion ist es, Zeichen aus dem [[cpp/io/basic_streambuf|Put-Bereich] des Stream-Puffers in die zugeordnete Zeichensequenz zu übertragen.

Formal ausgedrückt stellt diese Funktion sicher, dass im Put-Bereich Platz für mindestens ein Zeichen vorhanden ist. Die Basisklassenversion schlägt immer fehl, und eine möglicherweise erfolgreiche Implementierung kann nur in abgeleiteten Klassen bereitgestellt werden (siehe Implementierungsanforderungen). Die Standardbibliothek stellt std::strstreambuf::overflow(), (bis C++26)std::basic_stringbuf::overflow() und std::basic_filebuf::overflow() zur Verfügung.

Inhalt

[bearbeiten] Parameter

ch - das zu speichernde Zeichen im Put-Bereich

[bearbeiten] Rückgabewert

Traits::eof()

[bearbeiten] Implementierungsanforderungen

Jede überschreibende Definition dieser virtuellen Funktion muss die folgenden Einschränkungen befolgen, andernfalls ist das Verhalten undefiniert.

  • Die Auswirkung der Funktion besteht darin, eine Anfangsuntersequenz der Zeichen der *ausstehenden Sequenz* zu verbrauchen. Die ausstehende Sequenz ist definiert als die Verkettung der folgenden Sequenzen:
    • Der Put-Bereich (formal, leere Sequenz, wenn pbase() null ist, andernfalls (pptr() - pbase()) Zeichen beginnend bei pbase()).
    • Das Zeichen ch oder nichts, wenn ch EOF ist (formal, wenn Traits::eq_int_type(ch, Traits::eof()) true zurückgibt).
  • Nach dem Verbrauch werden die Put-Bereich-Zeiger aktualisiert, um die verbleibenden Zeichen, falls vorhanden, zu halten. Formal, sei r die Anzahl der Zeichen in der ausstehenden Sequenz, die nicht verbraucht wurden.
    • Wenn r nicht null ist, dann werden pbase() und pptr() so gesetzt, dass alle folgenden Bedingungen erfüllt sind:
      • pptr() - pbase() ist r.
      • Die r Zeichen beginnend bei pbase() sind der zugeordnete Ausgabestrom.
    • Wenn r null ist (alle Zeichen der ausstehenden Sequenz wurden verbraucht), dann wird entweder pbase() auf einen Nullwert gesetzt oder pbase() und pptr() werden beide auf denselben Nicht-Null-Wert gesetzt.
  • Die Funktion kann fehlschlagen, wenn entweder das Anhängen eines Zeichens an den zugeordneten Ausgabestrom fehlschlägt oder wenn sie pbase() und pptr() gemäß den obigen Regeln nicht einrichten kann.
  • Wenn die Funktion erfolgreich ist, gibt sie einen Wert zurück, der sich von Traits::eof() unterscheidet. Typischerweise wird ch zurückgegeben, um Erfolg anzuzeigen, außer wenn Traits::eq_int_type(ch, Traits::eof()) true zurückgibt. In diesem Fall wird Traits::not_eof(ch) zurückgegeben.
  • Wenn die Funktion fehlschlägt, gibt sie Traits::eof() zurück oder löst eine Ausnahme aus.

[bearbeiten] Hinweis

Die Funktionen sputc() und sputn() rufen diese Funktion bei einem Überlauf auf (pptr() == nullptr oder pptr() >= epptr()).

[bearbeiten] Beispiel

Führen Sie diesen Code aus
#include <array>
#include <cstddef>
#include <iostream>
 
// Buffer for std::ostream implemented by std::array
template<std::size_t size, class CharT = char>
struct ArrayedStreamBuffer : std::basic_streambuf<CharT>
{
    using Base = std::basic_streambuf<CharT>;
    using char_type = typename Base::char_type;
    using int_type = typename Base::int_type;
 
    ArrayedStreamBuffer()
    {
        // put area pointers to work with 'buffer'
        Base::setp(buffer.data(), buffer.data() + size);
    }
 
    int_type overflow(int_type ch) 
    {
        std::cout << "overflow\n";
        return Base::overflow(ch);
    }
 
    void print_buffer()
    {
        for (char_type i : buffer)
        {
            if (i == 0)
                std::cout << "\\0";
            else
                std::cout << i;
            std::cout << ' ';
        }
        std::cout << '\n';
    }
 
private:
    std::array<char_type, size> buffer{}; // value-initialize buffer
};
 
int main()
{
    ArrayedStreamBuffer<10> streambuf;
    std::ostream stream(&streambuf);
 
    stream << "hello";
    streambuf.print_buffer();
    if (stream.good())
        std::cout << "stream is good\n";
 
    stream << "world";
    streambuf.print_buffer();
    if (stream.good())
        std::cout << "stream is good\n";
 
    stream << "!";
    streambuf.print_buffer();
    if (!stream.good())
        std::cout << "stream is not good\n";
}

Ausgabe

h e l l o \0 \0 \0 \0 \0
stream is good
h e l l o w o r l d 
stream is good
overflow
h e l l o w o r l d 
stream is not good

[bearbeiten] Siehe auch

[virtuell]
 liest Zeichen aus der zugeordneten Eingabesequenz in den Get-Bereich und rückt den nächsten Zeiger vor
(virtuelle geschützte Memberfunktion) [bearbeiten]
[virtuell]
 liest Zeichen aus der zugeordneten Eingabesequenz in den Get-Bereich
(virtuelle geschützte Memberfunktion) [bearbeiten]
[virtuell]
 schreibt Zeichen aus dem Schreibbereich in die zugeordnete Datei
(virtuelle geschützte Memberfunktion von std::basic_filebuf<CharT,Traits>) [bearbeiten]
[virtuell]
 hängt ein Zeichen an die Ausgabesequenz an
(virtuelle geschützte Memberfunktion von std::basic_stringbuf<CharT,Traits,Allocator>) [bearbeiten]
[virtuell]
 hängt ein Zeichen an die Ausgabesequenz an, kann den Puffer neu allokieren oder initial allokieren, falls er dynamisch und nicht eingefroren ist
(virtuelle geschützte Memberfunktion von std::strstreambuf) [bearbeiten]
Abgerufen von "https://cppreference.de/mwiki/index.php?title=cpp/io/basic_streambuf/overflow&oldid=181464"