ausführen von threads der Klasse member-Funktion in c++

Als der Titel sagt.
Das folgende ist meine code-Skelett.

class CLASS
{
public:
    void A();
private:
    DWORD WINAPI B(LPVOID);
};

void CLASS::A()
{
    DWORD (WINAPI CLASS::*thread)(LPVOID) = &CLASS::B;
    ...
    CreateThread(NULL, 0, thread, &arg, 0, NULL);
    ...
}

die Funktion B muss KLASSE member-Variablen.
Aber ich habe einen Fehlercode, wenn ich zusammengestellt.
Es " kann nicht konvertieren argument 3 von 'DWORD (__stdcall CLASS::* )(LPVOID)' in 'LPTHREAD_START_ROUTINE' " oder so ähnlich.
Ich weiß nicht, ob es ist das gleiche in der englischen Umgebung.

kann jemand bitte helfen?

InformationsquelleAutor superscalar | 2011-01-12

  1. 11

    Ernst, die Verwendung von std::thread (oder boost::thread, wenn Ihr compiler nicht unterstützt, ist es noch):

    class CLASS
{
public:
    void A();
private:
    void B(your args go here);
};

void CLASS::A()
{
    boost::thread(&CLASS::B, this, your args go here);
}
    +1. Ja, auf jeden Fall gehen mit std::/boost::thread. Darüber hinaus brauchen Sie nicht einmal binden: boost::thread t(&CLASS::B, this, your args if any go here);. So einfach ist das.
    danke!!! behoben.

    InformationsquelleAutor ybungalobill

  2. 10

    Haben Sie zum definieren der callback-Funktion als static Funktion, wenn es die member-Funktion!

    Besseres design : definieren Sie eine wiederverwendbare Klasse!

    Aus meiner Vorherige Antwort: (mit kleiner änderung)

    Noch besser wäre es, zu definieren, eine wiederverwendbare Klasse mit rein virtuellen Funktion run() umgesetzt werden, indem die abgeleiteten thread Klassen. Hier ist, wie es gestaltet sein sollte:

    //runnable is reusable class. All thread classes must derive from it! 
class runnable
{
public:
    virtual ~runnable() {}
    static DWORD WINAPI run_thread(LPVOID args)
    {
        runnable *prunnable = static_cast<runnable*>(args);
        return prunnable->run();
    }
 protected:
    virtual DWORD run() = 0; //derived class must implement this!
};

class Thread : public runnable //derived from runnable!
{
public:
    void newthread()
    {
        CreateThread(NULL, 0, &runnable::run_thread, this, 0, NULL);
    }
protected:
    DWORD run() //implementing the virtual function!
    {
         /*.....your thread execution code.....*/
    }
}
    Ich würde eine Vorlage zu verwenden, eher als run-time-Vererbung. Aber die Grundidee ist richtig.
    du meinst CRTP?
    +1, aber ich würde die run Methode geschützt.
    guter Punkt. bearbeitet meine post. vielen Dank 🙂
    Es ist ein wenig altmodisch und umständlich design zu haben, um das ableiten einer Klasse und überschreiben einer Funktion zum ausführen einer thread. Besser ist die Verwendung von boost::thread oder einen ähnlichen Mechanismus, der nimmt einen Funktor als thread-Funktion und erfordert keine Ableitung von etwas.

    InformationsquelleAutor Nawaz

  3. 3

    Haben Sie zu machen, dass die Funktion static.

    Das problem hier ist, dass jedes nicht-statische member-Funktion ist eine implizite this parameter und das ist in der Tat, was der compiler versucht, Ihnen zu sagen - Ihre nin-statische member-Funktion hat die Signatur unterscheidet sich von der, die Sie erwartet.

    Siehe auch diese Antwort auf eine eng Verwandte Frage.

    Und bevor die OP beginnt immer irgendwelche kluge Ideen - nicht-statische Memberfunktion der Klasse Zeiger seltsam. Nicht nur sind die Aufrufkonventionen anders aus als die eines einfachen func(classname *this, ...), die Zeiger-Darstellung ist sonderbar - in einigen Fällen-Klasse member-Funktion-Zeiger können am Ende wird 2x die Größe einer normalen Funktion Zeiger, so denken Sie nicht einmal zwingen, den Guss 🙂

    InformationsquelleAutor sharptooth

Schreibe einen Kommentar