Ich arbeite in einem Programm mit mehreren Threads, die alle Ausgaben an std::ostreams (z.B. auch cout) geben wollen. Ich hätte dafür gerne eine Art blockierenden Stream. Meine Überlegung war bisher, den Stream mit einem Mutex zu versehen, der jedesmal beim Aufruf des op<< gelockt wird. Der Mutex müsste für das Hintereinanderschalten die Eigenschaft haben, dass er vom selben Thread mehrmals gelockt werden kann und die gesamtem Locks mit einem Unlock wieder abgeräumt werden können. Die Mutexklasse dafür habe ich schon. Die Ausgabe sollte dnn im Code möglichst ähnlich wie hier sein:

int foo()
{
  lockedcout << i /*hier hat sich op<< den lock geholt */ 
             << " Hello World" 
             << setprecision(4) 
             << setw(10) 
             << 5.0;  
             << endl;//schon 6mal gelockt...
  int y = berechneY(); //(Stream ist immernoch gelockt...) 
  bar();

  lockedcout << "geht weiter...";
  lockedcout << "und weiter...";
  lockedcout << "und jetzt ist Schluss!" << endl << unlock; //jetzt dürfen endlich andere Threads...
}

Das Problem ist folgendes:
Ich hätte die Klasse gern als Ableitung von std::ostream, wegen der Manipulatoren und allem anderen. Außerdem würde ich am Liebsten einfach bestehende Streams (wie z.B. cout) mit dieser Funktionalität nachrüsten können.
Das hat mich jetzt darauf gebracht, dass ich dann wohl vermutlich quasi eine Ableitung von streambuf brauche, in der sich das Locken versteckt und die aber alle Eingaben an einen anderen streambuf weitervergibt, den sie quasi "gekapert" hat. Im Grunde wäre das sone Art Decorator, den man vor den vorhandenen Buffer klemmt.
Das Problem was ich jetzt seh: Die nichtvirtuellen Funktionen von streambuf würden sich damit nur auf meinen streambuf auswirken, nicht aber auf den der die eigentliche Arbeit verrichtet. Hat jemand ne Idee wie man das hinbiegen kann?

};

Eine Idee hätte ich, ist aber keine vollwertige Lösung, da mir ein paar zusätzliche Informationen fehlen:

void foo()
{
  StreamLock lock;
  std::ostream& os = lock.getStream();

  os << "Bla bla usw. usf.";
}

StreamLock müsste sich halt irgendwoher den Stream holen können. Gäbe da viele unterschiedliche Möglichkeiten. Ganz simple zum Beispiel:

class StreamLock
{
  // Static attributes //
private:
  static std::ostream stream;

  // Static functions //
public:
  static void setStreamBuffer(std::streambuf* buffer)
  {
    if(buffer)
    {
      stream.rdbuf(buffer);
    }
    else
    {
      stream.rdbuf(std::cout.rdbuf());
    }
  }

  // Constructor mit lock usw. usf. //

  // Methods //
public:
  std::ostream& getStream() { return stream; }
};

Könntest aber auch über eine std::map arbeiten und entsprechende Konstanten oder einem Array und einem Enum.

Einfach mal so eine/ein paar Ideen

Grüssli

- ich bin gespannt ob das funktioniert und obs noch performant genug ist...

Nur so ein Gedanke. Weil wenn du mehrere threads gleichzeitig da mit verwendest hast du das problem das du dein programm ausbremst. Edit: Natürlich nur wenn du viele ausgaben machst und das in vielen threads.

Edit: Natürlich nur wenn du viele ausgaben machst und das in vielen threads.

Wird hauptsächlich Ausgaben aus einem Thread geben, aus nem zweiten kommt hin und wieder was, aber nicht sehr häufig...