std::basic_osyncstream<CharT,Traits,Allocator>::basic_osyncstream - cppreference.com

De cppreference.com

`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)

Construye un nuevo flujo de salida sincronizado.

1-4) Construye el miembro privado std::basic_syncbuf usando el búfer y el asignador de memoria provisto, e inicializa la clase base con un puntero al miembro std::basic_streambuf.

5) Constructor de movimiento. Construye por movimiento la base std::basic_ostream y el miembro std::basic_syncbuf a partir de los subobjetos correspondientes de other, luego llama a

set_rdbuf

con el puntero al std::basic_syncbuf subyacente recién construido para completar la inicialización de la base. Después de este constructor de movimiento, other.get_wrapped() devuelve nullptr y la destrucción de other no produce ningún resultado.

Parámetros

buf	-	Puntero al std :: basic_streambuf que se envolverá.
os	-	Referencia a un std::basic_ostream, cuyo rdbuf() se envolverá.
a	-	El asignador de memoria para pasar al constructor del miembro std::basic_syncbuf.
other	-	Otro flujo de salida sincronizado del que mover.

Ejemplo

#include <string_view>
#include <syncstream>
#include <iostream>
#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 << "La salida sincronizada no debería causar ninguna interferencia:" << 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 << "\nLa falta de sincronización puede causar alguna interferencia en la salida:" << 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)};
  }
}

Posible salida:

La salida sincronizada no debería causar ninguna interferencia:
░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░
▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒
▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓
████████████████████████████████████████████████████████████████████████████████████████████████████

La falta de sincronización puede causar alguna interferencia en la salida:
████▓▓██▒▒▒▒▓▓██░░▒▒██░░▒▒░░░░▒▒░░▓▓▒▒██░░████████████▓▓██████▓▓▒▒▓▓██░░████▓▓▓▓██▒▒░░░░░░░░▓▓░░▓▓██▒▒▒▒▒▒▒▒▓▓██▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒░░▒▒▒▒░░▒▒▒▒▒▒▒▒▒▒▓▓▒▒▒▒▒▒▒▒▒▒▒▒██░░░░░░░░▓▓▓▓▓▓▓▓▓▓▓▓▓▓░░▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓████████▓▓▓▓▓▓▓▓▓▓▓▓░░▓▓▓▓
▒▒▒▒██░░██████████████████████████░░░░░░░░░░░░░░██░░▒▒░░░░░░██████████████████
▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒░░▒▒░░░░░░░░░░░░░░░░░░░░░░░░░░░░▒▒▒▒▒▒
░░░░░░

Véase también

Construye un objeto basic_syncbuf.
(función miembro pública de std::basic_syncbuf<CharT,Traits,Allocator>) [editar]