pthread-Task als Methode einer C++ Klasse?

[shedepe]

Gibt es einen Grund warum es pthread direkt sein muss und das C++ 11 frontend nicht? (Btw. du redest über Tasks meinst aber Threads. Das ist ein ziemlicher Unterschied)
Mit C++ 11 ist es super einfach einen Thread in einer klasse laufen zulassen (Siehe Post von Mxt - Wobei der Code meiner Ansicht nach so nicht funktionieren wird
Ich finde das Beispiel auf Stackoverflow ganz gut: https://stackoverflow.com/questions/...ethod-of-class
Wenn du unbedingt direkt auf die pthread API programmieren willst wirst du um eine kompliziertere Lösung wie hier ( https://stackoverflow.com/questions/...start-function ) nicht drumherumkommen.

[HaWe]

der Grund für pthread ist, dass ich mich mittlerweile ENDLICH einigermaßen damit zurechtfinde, dass ich die thread priority sinnvoll justieren kann, dass auch wiringPi mit pthread arbeitet (auch mit vereinfachten Mutexen) und ich auch sonst immer nur pthread einsetze. C++ ist mir eigentlich ein Greuel, so wie auch andere OOP Sprachen (Java, C#) und ich nutze es nur, wenn zufällig ein paar libs ihre API Funktionen eben so zur Verfügung stellen (Arduino automatisch, beim Raspi v.a. wenn zwingend iostream gebraucht wird). Auch Gordon Henderson mit seinem wiringPi teilt übrigens meine Abneigung gegen C++, auch er nutzt (wie er mir mal schrieb) "aus Prinzip" nur ANSI C.

Ich habe aber keinen Schimmer, was (wie bei stackoverflow) in diesem Zusammenhang vektoren, this, eine static class method, eine plain ordinary function, to bootstrap the class, virtual, protected, public, private, static void * InternalThreadEntryFunc(void * This) {((MyThreadClass *)This)->InternalThreadEntry(); return NULL;}, boost::thread, ein pointer to "context", ein pointer to an instance, C++ construct - 'friend' function und all dieses Gedöns ist und den Unterschied zwischen :: und -> werde ich mit Sicherheit auch nie kapieren.

Ich gebe ntl zu, dass OOP hier und da Vorteile hat (wie bei Arduino Serial und TWI) und hatte vermutet, dass ich dieses schnell mal so auch ganz einfach bei meinem PID Controller nutzen kann, wenn ich nur ein PID Muster erstelle und dieses dann per new PID... samt seiner dann miterschaffenen Tasks einfach "vervielfachen" könnte. Leider ist mir der ganze OOP Rattenschwanz, der offenbar zwangsweise mitgeschleppt werden muss und der mir regelrechte Hirnkonvulsionen verursacht mit progressivem Gefühl mich unstillbar übergeben zu müssen, über alle Maßen bei weitem zu wirr, zu umständlich und zu aufwändig.

Ich wollte in mein Objekt nur irgendwie ganz einfach reinschreiben
pthread_t threadID;
pthread_create(&threadID, NULL, threadName, NULL);

und hatte gehofft, alle Instanzen würden dann auch ganz einfach so ihren eigenen pthread task starten, laufen lassen und beenden können, ohne dass es Probleme bei 8 oder 10 gleichzeitig oder nacheinander aufgerufenen Instanzen gegeben hätte.

Da ist es 1000x einfacher, wenn ich meine statischen Task Funktionen 10x untereinander per copy + paste schreibe als
void * PID_A
void * PID_B
void * PID_C
usw.

wie ich es in NXC gemacht habe - und bleibe beim guten alten ANSI C .

[Mxt]

Also std::thread ist nur eine dünne Verpackung um entweder pthread oder Windows threads. Man komm auch noch an den verpackten "nativen" Thread heran. Muss man auch, z.B. zum Setzen von Prioritäten.

Ich wollte in mein Objekt nur irgendwie ganz einfach reinschreiben

Da sind die Regeln ganz einfach: In C-Funktionen kann man nur statische Memberfunktionen von Objekten als Parameter übergeben. Objektinstanzen werden als void* übergeben.

[HaWe]

ich weiß gar nicht was statische Funktionen oder statische Memberfunktionen von Objekten sind und was nicht.... und was das für mein PID Problem jetzt eigentlich bedeutet....

[Mxt]

http://en.cppreference.com/w/cpp/language/static

- - - Aktualisiert - - -

(Siehe Post von Mxt - Wobei der Code meiner Ansicht nach so nicht funktionieren wird

Auf einem Pi habe ich ihn nicht getestet, aber in Visual Studio läuft er.

[HaWe]

".... und was das für mein PID Problem jetzt eigentlich bedeutet.... "

[shedepe]

Ohne dir zu nahe treten zu wollen, du schimpfst auf OOP ohne dich damit genau beschäftigt zu haben. Das C++ nunmal anders programmiert wird als C, auch wenn C eine Untermenge von C++ ist, ist nunmal dem geschuldet, dass es eine andere Programmiersprache ist. Und eine andere Programmiersprache muss man eben auch erst mal lernen. Zu einer Programmiersprache gehören eben nicht nur die keywords und die Syntax sondern eben auch Konzepte und Hintergrundwissen bezüglich dem was unter dem Oberfläche passiert.

Mein Vorschlag wäre nimm std::threads in deiner Klasse. Ein std::thread ist unter Linux genau das selbe wie ein thread der über Posix (pthread) gestartet wurde. Wenn du sachen machen willst wie thread abbrechen oder priority ändern. Lässt du dir von dem std::thread sein native handle (Das auch nur ein Verweis auf einen pthread ist) geben und kannst das ganz normal den pthread funktionen übergeben. Der Vorteil dabei ist, du sparst dir eben das etwas komplizierte Aufrufen eines pthreads auf eine Klassenfunktion.

[Mxt]

".... und was das für mein PID Problem jetzt eigentlich bedeutet.... "

Es beantwortet die Frage.

Statt im obigen Beispiel

  std::thread MakeTask()
  {
    return std::thread([this] { Control(3); });
  }

müsste man etwas in der Art

  static void MakeTask(void* this_instance)
  {
	((PidClass*) this_instance)->Control(3);
  }

schreiben. Dann könnte man

int main()
{
  PidClass pid;
  pthread_t t;
  pthread_create(&t, NULL, &PidClass::MakeTask, &pid);

Ungetestet und aus dem Kopf geschrieben, zeigt nur das Prinzip.