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

Die Absicht dieser Funktion ist es, Zeichen aus dem Put-Bereich des Streampuffers an die assoziierte Zeichensequenz zu übertragen.

Formal 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() bereit.

Parameter

Rückgabewert

Traits :: eof ( )

Implementierungsanforderungen

Jede überschreibende Definition dieser virtuellen Funktion muss den folgenden Einschränkungen folgen, andernfalls ist das Verhalten undefiniert:

• Die Wirkung der Funktion besteht darin, eine anfängliche Teilsequenz der Zeichen der ausstehenden Sequenz  zu konsumieren. 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 ( ) ) zurückgibt true ).
• Nach dem Konsumieren werden die Put-Bereich-Zeiger aktualisiert, um die verbleibenden Zeichen (falls vorhanden) zu halten. Formal sei r die Anzahl der nicht konsumierten Zeichen in der ausstehenden Sequenz:
  • Wenn r ungleich 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 dem zugehörigen Ausgabestrom zugeordnet.
  • Wenn r Null ist (alle Zeichen der ausstehenden Sequenz wurden konsumiert), dann wird entweder pbase() auf einen Nullwert gesetzt, oder pbase() und pptr() werden beide auf denselben Nicht-Nullwert gesetzt.
• Die Funktion kann fehlschlagen, wenn entweder das Anhängen eines Zeichens an den zugehörigen Ausgabestrom fehlschlägt oder wenn sie nicht in der Lage ist, pbase() und pptr() gemäß den obigen Regeln einzurichten.
• Wenn die Funktion erfolgreich ist, gibt sie einen Wert zurück, der nicht Traits :: eof ( ) entspricht. Typischerweise wird ch zurückgegeben, um Erfolg anzuzeigen, außer wenn Traits :: eq_int_type ( ch, Traits :: eof ( ) ) zurückgibt true , in welchem Fall Traits :: not_eof ( ch ) zurückgegeben wird.
• Wenn die Funktion fehlschlägt, gibt sie Traits :: eof ( ) zurück oder wirft eine Ausnahme.

Hinweis

Die Funktionen sputc() und sputn() rufen diese Funktion im Falle eines Overflows auf ( pptr ( ) == nullptr oder pptr ( ) >= epptr ( ) ).

Beispiel

#include <array>
#include <cstddef>
#include <iostream>
// Puffer für std::ostream implementiert durch 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-Bereich-Zeiger zur Arbeit mit 'buffer' setzen
        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{}; // Buffer wertinitialisieren
};
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";
}

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

Siehe auch