Tastaturabfrage in C++

[HaWe]

gerade auf dem Raspi (Raspbian Jessie) hab ich einiges (!!!) an source codes durchgetestet, bis was funktionierendes dabei war.
Letztlich funktioniert hat dieses hier:

/* 
 * rpiconio.h
 * mimics kbhit(), getch()
*/

#ifndef RPICONIO_H
#define   RPICONIO_H

#include <stdbool.h>
#include <stdio.h>
#include <string.h>
#include <termio.h>
#include <unistd.h>

bool kbhit(void) {
    struct termios original;
    tcgetattr(STDIN_FILENO, &original);
    struct termios term;
    memcpy(&term, &original, sizeof(term));
    term.c_lflag &= ~ICANON;
    tcsetattr(STDIN_FILENO, TCSANOW, &term);
    int characters_buffered = 0;
    ioctl(STDIN_FILENO, FIONREAD, &characters_buffered);
    tcsetattr(STDIN_FILENO, TCSANOW, &original);
    bool pressed = (characters_buffered != 0);
    return pressed;
}

void echoOff(void) {
    struct termios term;
    tcgetattr(STDIN_FILENO, &term);
    term.c_lflag &= ~ECHO;
    tcsetattr(STDIN_FILENO, TCSANOW, &term);
}

void echoOn(void) {
    struct termios term;
    tcgetattr(STDIN_FILENO, &term);
    term.c_lflag |= ECHO;
    tcsetattr(STDIN_FILENO, TCSANOW, &term);
}


#endif

Testcode:

#include <stdio.h>
#include <string.h>
#include <unistd.h>
#include <wiringPi.h>

#include "rpiconio.h"

int main(void)
{
    long i=0;
    echoOff();
    int c = '\0';
    while (c != 'q')   {
        if (kbhit())
        {
            c = getchar();
            printf("(hier ggf. auskommentieren:) got key \'%c\'\n", c);
            if(c==27) { printf("\nuser break\n"); return 1;  }
        }
        printf("%ld\n", ++i);
        delay(100);
    }
    echoOn();    
    return 0;
}

[hirnfrei]

Das mit Thread scheint ja ganz gut zu funktionieren und gefällt mir prinzipiell auch ganz gut.

Nur kann man von dem einen Thread auch etwas in einen anderen schreiben?

[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.