Ich wüsste gern wie ich Multitasking-Programme schreiben kann.
z.B.:Eine Zeitzählfunktion läuft neben dem Hauptprogramm.
Wenn man dann auf einen Button im Fenster klickt wird die gezählte Zeit angezeigt.
(also auch Variablenübertragung)

Kann mir da einer helfen?

Mfg

Welche GUI-API benutzt du denn? MFC, Win32, Qt, wxWidgets oder was? Die haben alle Multithreading im Angebot.

Ansonst gibts halt noch boost::thread. Mußt du natürlich die Boost Libs haben.

Hier ist ein dt. Tut von mir: http://www.kharchi.de/threads.html

http://boost.org/doc/html/threads.html

Ich wüsste gern wie ich Multitasking-Programme schreiben kann.
z.B.:Eine Zeitzählfunktion läuft neben dem Hauptprogramm.
Wenn man dann auf einen Button im Fenster klickt wird die gezählte Zeit angezeigt.
(also auch Variablenübertragung)

boost.thread ist schon mal ein guter Tipp. Erstens ist es plattform-übergreifend und zweitens einfacher, als sich z.B. mit einer Win-API herumzuschlagen.

Mal angenommen, da ist eine Zähler-Klasse, die im einfachsten Fall etwa so aussieht:

#include <boost/bind.hpp>
#include <boost/thread.hpp>

class Zaehler
{
public:
    Zaehler()
        : m_isRunning( true )
        , m_count( 0 )
        , m_thread( boost::bind( &Zaehler::Run, this ) )
        // compiler warning ignorieren, wenn m_thread letztes Member
    {}

    ~Zaehler()
    {
        m_isRunning = false; // Beenden des Threads ist notwendig
        m_thread.join();
    }

    int Count() const 
    {
        return m_count;
    }

private:
    void Run() // hier drin rennt mein Thread
    {
        for(; m_isRunning; ++m_count )
        {
            // mache hier was auch immer
            // z.B. 1 Sekunde schlafen (sleep)
        }
    }

    // --   Member
    bool m_isRunning;
    int m_count;
    boost::thread m_thread; // MUSS letztes Member sein
};

dann trägt 'Zaehler' einen Member m_thread, der die Methode Zaehler::Run in einem eigenen Thread laufen läßt. Wie Du siehst funktioniert das mit der Datenübertragung hier einfach so, dass beide Threads - also der Haupt-Thread und der Thread von m_thread einfach auf die Member des identischen Objekts zugreifen.
Das geht hier nur deshalb gut, weil immer nur einer von beiden schreibt und beide Variablen (m_count, m_isRunning) einfache Datentypen sind, bei denen das Lesen nicht durch einen Threadwechsel unterbrochen wird (so hoffe ich )

Beim Übersetzen bekommt man eine Compiler-Warning (zu Recht), da this als Parameter für einen der Member benutzt wird. Im Konstruktor von boost::thread rennt dieser gleich los und zu diesem Zeitpunkt müssen alle Member der Klasse initialisiert sein; daher muss m_thread das letzte Member sein.

Ein Objekt dieser Klasse kannst Du als Member eines Windows oder Dialoges setzen. Der Thread startet sobald das Window oder Dialog-Objekt angelegt ist. Danach kann man dann in einer On-Button-Klick-Methode einfach den Zähler-Stand mit Count() abfragen.

Wird die Klasse anspruchsvoller, so solltest Du die Member mit einem Mutex schützen. Dazu fügt man ein Mutex als Member hinzu:

// --   Member
    mutable boost::mutex m_guard;

den macht man am besten gleich mutable, damit man auch const-Methoden schützen kann.
So wird dann Count angepasst:

int Count() const 
    {
        boost::mutex::scoped_lock lock( m_guard );
        return m_count;
    }

und damit das ganze überhaupt Sinn macht, darf auch der eigenen Thread nur an m_count bzw. weitere (Nutz-)Member ran, wenn sonst keiner die Hand drauf hat - also das Mutex es zulässt:

void Run()
    {
        for(; m_isRunning;)
        {
            boost::mutex::scoped_lock lock( m_guard );
            // hier immer noch irgendwas tun, ..
            ++m_count; // auf 'm_count' exclusiv schreiben
        }
    }

boost ist
Gruß
Werner

was spricht dagegen, in der Run() - funktion ein lokale thread-instanz zu erstellen, die eine zweite funktion (DoWork() o.ä.) in einem neuen thread startet?

Dagegen spricht, dass von dieser lokalen Instanz am Ende von Run() der Destruktor aufgerufen wird. Es gibt zwei Möglichkeiten:
1.) Warte in Run() bis der Thread in DoWork() fertig ist; dann ist der Thread unnötig, man kann DoWork direkt aufrufen.
2.) Warte nicht, dann wird der Destruktor von boost::thread gerufen, der z.B. in Windows zu einem CloseHandle auf den Thread-Handle führt; bedeutet Freigabe der Ressourcen bei laufendem Thread - das kann eigentlich nur schiefgehen.

Preisfrage: Was würde dafür sprechen, wie ist Deine Idee?

Gruß
Werner

~thread();

Effects: Destroys *this. The actual thread of execution may continue to execute after the thread object has been destroyed.

wohl was missverstanden.