Mein Problem ist folgendes:
Ich habe eine Thread Funktion,

DWORD WINAPI MyThreadFunction(PVOID pParam)
{
    std::vector<int> List;

    /* push_back ... */

    pParam = List; // ???
}

möchte eine Struktur an pParam uebergeben und von der Thread Funktion einen Container vom Typ std::vector erhalten.

struct MyStructure
{
    int Value1;
    int Value2;
    /* ... */
};

int main(void)
{

    unsigned long id; // Thread identity

    MyStructure Information;

    HANDLE hThread = CreateThread(NULL, 0, &Information, 0, &id);

    return 0;
}

Wie mache ich das am geschicktesten?

struct Information
{
    int Value1;
    int Value2;
};

DWORD WINAPI MyThreadFunction(PVOID pParam)
{
    Information* info = static_cast<Information*>(pParam);
    // ...
    return 0;
}

Wie du dann nen std::vector zurückgeben kannst ist IMO naheliegend: pack den vector mit in die Struktur hinein:

struct Information
{
    int Value1;
    int Value2;
    std::vector<int> Result;
};

DWORD WINAPI MyThreadFunction(PVOID pParam)
{
    Information* info = static_cast<Information*>(pParam);
    // ...
    info->Result.push_back(...);
    info->Result.push_back(...);
    info->Result.push_back(...);
    // ...
    return 0;
}

Natürlich musst du dafür sorgen dass die struct mindestens solange lebt wie der Thread läuft, sonst kracht es. Sollte das Schwierigkeiten bereiten frag nochmal, gibt's relativ einfache Lösungen die sich eigentlich überall anwenden lassen.

PS: Sollte man Pointer nicht lieber mit reinterpret_cast casten?

PS: Sollte man Pointer nicht lieber mit reinterpret_cast casten?

Nein, nicht grundsätzlich, reinterpret_cast sollte nur das letzte Mittel sein, um eine "Umwandlung" zu erzwingen. static_cast berücksichtigt jedoch auch, wenn die Binärdarstellung des Zieltypen sich von der des Ausgangstypen unterscheidet und nimmt eine entsprechende Änderung vor. Dass die Binärdarstellungen unterschiedlich sind, muss zwar, je nach System, nicht sein, aber wenn man es auch hier so macht, gewöhnt man sich gleich den "richtigen" Einsatz der cast-Operatoren an und ist auf der "sicheren Seite".

MfG,

Probe-Nutzer

Aber noch ne kleine Frage:
Ist die ID des Threads wichtig? Ich mach das so, dass ich die 'unsigned long id;' einfach uninitialisiert lasse. Ist das so richtig?

Referenz

Eher ein Zeiger

ich entwickel zur Zeit ein 2D Spiel unter Windows.
Da ich dort für jeden BOT ein Pathfining-System anwende - welches natürlich viel Zeit in Anspruch nimmt (für jeden BOT ca. 0.1 Sekunden) - mache ich das für jeden BOT in einer Thread Funktion.
Diese Thread Funktion läuft dann nur ca. 0.1 Sekunden, bei 100 BOTs laufen dann natürlich 100 Threads aber dafür eben nur sehr kurz.

Was ich wissen möchte ist: was muss man machen (welche Funktionen der WinAPI sind notwendig) um das Programm Thread-sicher zu programmieren?

Momentan stützten bei mir nur die Threads ab aber das Programm selbst läuft noch für ein paar Sekunden weiter. Dann kommt das bekannte "Fehler senden oder nicht senden" und schließlich terminiert Windows meine Anwendung komplett.

Kennt sich jemand mit Thread-Programmierung unter Windows aus?

Mfg Lukas

Kennt sich jemand mit Thread-Programmierung unter Windows aus?

Ja, ich und einige andere.

was muss man machen (welche Funktionen der WinAPI sind notwendig) um das Programm Thread-sicher zu programmieren?

Das kann man so nicht sagen.

Du musst erstmal verstehen was Threads eigentlich sind, und warum es zu Problemen kommen kann. Wenn du das mal raus hast kannst du anfangen nach Lösungen zu suchen oder zu fragen.

Aber eigentlich sollte das ja kein Problem sein, denn einen boolean Variable auf 'true' oder 'false' zu setzten, entspricht doch auch nur einem Assembler Schritt, oder?!

Was für mich aber auch wichtig währe: gibt es eine Funktion um im Hauptprogramm zu prüfen ob der Thread noch läuft oder schon beendet wurde.

ob es zu Fehler kommen kann, wenn ein Thread und das Hauptprogramm gleichzeitig auf eine Variable (z.B. boolean) zugreifen?

Ja kann es.

Aber eigentlich sollte das ja kein Problem sein, denn einen boolean Variable auf 'true' oder 'false' zu setzten, entspricht doch auch nur einem Assembler Schritt, oder?!

Wenn dir der Compiler nicht mit irgendwelchen Optimierungen dazwischenpfuscht, und du auf einem x86 System arbeitest, dann geht es normalerweise. Wenn du auf anderen CPUs arbeitest kann es sein dass diverse Änderungen die Thread A macht erst *irgendwann* von Thread B "gesehen" werden. Auch kann es passieren dass Änderungen an z.B. 2 Variablen in der falschen Reihenfolge gesehen werden, also dass zuerst die 2. Änderung sichtbar wird und danach erst die 1. Änderung.

Was für mich aber auch wichtig währe: gibt es eine Funktion um im Hauptprogramm zu prüfen ob der Thread noch läuft oder schon beendet wurde.

Unter Windows: WaitForSingleObject() mit einem Timeout von 0. Mit PTHREADS kenne ich mich nicht so wirklich aus, müsste dir ein PTHREADS-Kenner beantworten.

edit: Und sowas wie eine kleine Regel zu gemeinsam von Threads verwendeten Variablen: Wenn alle Threads die gemeinsame Variable lesen ist das kein Problem, sobald mindestens einer schreibt, würde ich das Ganze mit Mutexen absichern. Für einfaches Mutex'ing verwende ich meist sf::Mutex mit sf::Lock aus der SFML-Bibliothek (http://www.sfml-dev.org/tutorials/1.3/system-threads.php, siehe weit unten).