Namespaces
Variants

std::basic_osyncstream<CharT,Traits,Allocator>:: basic_osyncstream

From cppreference.net
C++
Input/output library
std::basic_osyncstream
Public member functions
basic_osyncstream::basic_osyncstream
(C++20)
(C++20)
(C++20)
(C++20)
(C++20)
(C++20)
basic_osyncstream ( streambuf_type * buf, const Allocator & a ) ;
(1)
explicit basic_osyncstream ( streambuf_type * buf ) ;
(2)
basic_osyncstream ( std:: basic_ostream < CharT, Traits > & os, const Allocator & a ) ;
(3)
explicit basic_osyncstream ( std:: basic_ostream < CharT, Traits > & os ) ;
(4)
basic_osyncstream ( std:: basic_osyncstream && other ) noexcept ;
(5)

Konstruiert einen neuen synchronisierten Ausgabestrom.

1-4) Konstruiert das private Mitglied std:: basic_syncbuf unter Verwendung des bereitgestellten Puffers und Allokators und initialisiert die Basisklasse mit einem Zeiger auf das Mitglied std:: basic_streambuf .
5) Move-Konstruktor. Move-konstruiert die std:: basic_ostream Basis und das std::basic_syncbuf-Mitglied aus den entsprechenden Unterobjekten von other , ruft dann set_rdbuf mit dem Zeiger auf den neu konstruierten zugrundeliegenden std:: basic_syncbuf auf, um die Initialisierung der Basis abzuschließen. Nach diesem Move-Konstruktor gibt other. get_wrapped ( ) nullptr zurück und die Zerstörung von other erzeugt keine Ausgabe.

Parameter

buf - Zeiger auf den std::basic_streambuf , der umschlossen wird
os - Referenz auf einen std::basic_ostream , dessen rdbuf() umschlossen wird
a - der Allokator, der an den Konstruktor des Mitglieds std::basic_syncbuf übergeben wird
other - ein anderer osyncstream, von dem verschoben wird

Beispiel

Diesen Code ausführen 
#include <iostream>
#include <string_view>
#include <syncstream>
#include <thread>
void worker(const int id, std::ostream &os)
{
    std::string_view block;
    switch (id)
    {
        default: [[fallthrough]];
        case 0: block = "██";
                break;
        case 1: block = "▓▓";
                break;
        case 2: block = "▒▒";
                break;
        case 3: block = "░░";
                break;
    }
    for (int i = 1; i <= 50; ++i)
        os << block << std::flush;
    os << std::endl;
}
int main()
{
    std::cout << "Synchronized output should not cause any interference:" << std::endl;
    {
        auto scout1 = std::osyncstream{std::cout};
        auto scout2 = std::osyncstream{std::cout};
        auto scout3 = std::osyncstream{std::cout};
        auto scout4 = std::osyncstream{std::cout};
        auto w1 = std::jthread{worker, 0, std::ref(scout1)};
        auto w2 = std::jthread{worker, 1, std::ref(scout2)};
        auto w3 = std::jthread{worker, 2, std::ref(scout3)};
        auto w4 = std::jthread{worker, 3, std::ref(scout4)};
    }
    std::cout << "\nLack of synchronization may cause some interference on output:"
              << std::endl;
    {
        auto w1 = std::jthread{worker, 0, std::ref(std::cout)};
        auto w2 = std::jthread{worker, 1, std::ref(std::cout)};
        auto w3 = std::jthread{worker, 2, std::ref(std::cout)};
        auto w4 = std::jthread{worker, 3, std::ref(std::cout)};
    }
}

Mögliche Ausgabe: 

Synchronized output should not cause any interference:
░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░
▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒
▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓
████████████████████████████████████████████████████████████████████████████████████████████████████
Lack of synchronization may cause some interference on output:
████▓▓██▒▒▒▒▓▓██░░▒▒██░░▒▒░░░░▒▒░░▓▓▒▒██░░████████████▓▓██████▓▓▒▒▓▓██░░████▓▓▓▓██▒▒░░░░░░░░▓▓░░▓▓██▒▒▒▒▒▒▒▒▓▓██▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒░░▒▒▒▒░░▒▒▒▒▒▒▒▒▒▒▓▓▒▒▒▒▒▒▒▒▒▒▒▒██░░░░░░░░▓▓▓▓▓▓▓▓▓▓▓▓▓▓░░▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓████████▓▓▓▓▓▓▓▓▓▓▓▓░░▓▓▓▓
▒▒▒▒██░░██████████████████████████░░░░░░░░░░░░░░██░░▒▒░░░░░░██████████████████
▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒░░▒▒░░░░░░░░░░░░░░░░░░░░░░░░░░░░▒▒▒▒▒▒
░░░░░░

Siehe auch

Konstruiert ein basic_syncbuf Objekt
(öffentliche Elementfunktion von std::basic_syncbuf<CharT,Traits,Allocator> )