Tastaturabfrage in C++

[Mxt]

Ja, im Prinzip schon.

Dabei muss man zwei Dinge beachten. Einmal müssen die Daten natürlich sichtbar sein. Globale Variablen sind ja bei größeren Programmen eher verpöhnt. Man kann aber z.B. sowas machen

class Dings
{
   // irgendwelche gemeinsamen Daten, die auch noch andere verwenden
};

class Worker
{
  // ...

  explicit Worker(Dings ding)  // ob man hier kopiert oder mit Referenz oder (Smart-)Pointer arbeitet hängt von der Anwendung ab
                                       // Das explicit sagt: Ein Worker kriegt ein Ding. Ein Ding ist aber kein Worker.
                                       // Gegenbeispiel:  Bruchzahl(int i)   Ein int ist auch eine Bruchzahl
                                       // (Das ist nur bei Konstruktoren mit einem Parameter relevant)
  // ...


int main()
  // ...

  Dings zeug;  // Wird auch noch von anderen benutzt
  Worker worker(zeug);

  std::thread t(std::ref(worker));    // std::thread legt eine Kopie seiner Parameter an, 
                                                // das std::ref packt worker in einen reference_wrapper
                                                // dadurch arbeitet der Thread auf dem selben Objekt wie main

Dann ist da noch das Problem, dass mehrere Prozessorkerne auf die selben Daten lesend oder schreibend zugreifen wollen.
Bei bool oder int ist das kein Problem
https://de.wikipedia.org/wiki/Cache-Koh%C3%A4renz

Schon bei einem string würde es knallen. Deshalb auch diese Funktion zur Consolenausgabe mit dem lock_guard.

Das alles zu erklären, würde etwas lang werden. Hier mal was es zu threads im Standard gibt
http://en.cppreference.com/w/cpp/thread
außerdem gibt es noch atomare Werte, die nur am Stück geändert werden können
http://en.cppreference.com/w/cpp/atomic

[hirnfrei]

Danke. Bisher funktioniert das ganz gut muss ich sagen!

[HaWe]

wenn was "mal ne Zeitlang" gutgeht, heißt das nicht, dass es immer so sein wird. Meist gehen solche Sachen genau dann schief, wenn sie den größtmöglichen Schaden anrichten (acc to Murphy's Law (2) ).
Ganz persönlich finde ich: auf Multi-User-Multi-Tasking-OS in mehreren Tasks auf dieselben Ressourcen zuzugreifen ohne Mutexe zu benutzen - DAS finde ICH ziemlich "hirnfrei"

[Mxt]

ohne Mutexe zu benutzen

Was immer diese Antwort bedeuten mag. Ein std::mutex ist ein solcher.

Bei int oder bool kann man noch volatile davorschreiben, muss man aber bei den meisten Compilern nicht.

Atomic ist in der Tat lock free programming und basiert auf memory order. Wenn man nicht gerade Hochfrequenz Börsenhandel (mittlerweile eine der größten C++ Anwendungen) betreibt, sollte man da besser als Anfänger von Abstand nehmen.

[hirnfrei]

Ich sprach auch nicht davon das es "eine Zeit lang" funktioniert, sondern das es bisher funktioniert. Ich also alles, was das Programm bisher kann, auch schon mehrfach getestet habe und es funktioniert. Wie es sich verhält wenn das Programm wächst, bzw. mehr Daten anfallen wird sich zeigen. Aber auch da habe ich vor auf der sicheren Seite zu bleiben.