[C++] Een 'runnable' class in c++/windows

[Verwijderd]

Ik heb al gesearched maar kon niets vinden wat aan mijn verwachtingen voldeed, dus hier mijn ruime vraag:

Hoe maak ik in C++ een 'runnable class' als in Java?
Ik wil dus een klasse maken die een functie heeft die op een aparte thread wordt uitgevoerd, hoe doe ik dat?

[Soultaker]

Dat kan niet; je hebt een globale functie die aangeroepen wordt bij het starten van je executable. Dat ding heeft meestal 'main' (maar dat hangt ook van je compilerinstellingen af). Als je dus een hoofdklasse hebt waar je iets mee wil doen op een Java-achtige maneir, dan kan dat zo:

code:

class MijnKlasse {
public:
    static int main(int arc, char *argv[]) {
        // whatever.
        return 0;
    }
}

int main(int argc, char *argv[])
{
    return MijnKlasse::main(argc, argv);
}

Maar natuurlijk kun je dan net zo goed allerlei initialisatie in de globale main-functie zelf doen (in plaats van een statische methode aan te roepen die dat voor je doet).

[Tmr]

ik ben niet echt op de hoogte van het Win32 threads programming model (ik ken enkel POSIX threads) maar wat ik wel weet is dat in C++ met pthreads (unix/linux) je een nieuwe thread alleen kan starten door aan de thread_create functie de startroutine mee te geven:

bijv met pthreads zou je zoiets kunnen doen om het java model te kunnen simuleren:

C++:

#include <pthread.h>

class SomethingRunnable
{
  private:
    void* do_work (void *arg);

  public:
    void run ()
    {
      pthread_t tid;
      pthread_create (&tid, NULL, do_work, NULL);
      pthread_detach (tid);
    }
}

maar goed de precieze syntax van het Win32 model weet ik dus niet. Ik heb effe snel wat research gedaan op internet maar volgens mij kan je uit de Win32 API een functie als CreateThread gebruiken.

Misschien heb je hier nog wat aan: http://www.codeproject.com/threads/thread_win32.asp

edit
Ik heb die link nog even bekeken en volgens mij werken win32 threads ongeveer op een soortgelijke manier. Overigens heb je niet speciaal een class nodig om een aparte thread uit te voeren: je kan volgens mij gewoon een thread maken en deze een startfunctie + argumenten als parameters meegeven. Maar in het Java model is inderdaad alles een class.

Kleine hint voor als je enkel Java gewend bent en je wilt data delen tussen verschillende threads: C/C++ kent geen 'synchronized'

Threads programming is koel maar kan veel hoofdbrekens kosten...

[ Voor 25% gewijzigd door Tmr op 19-05-2005 20:52 ]

[Verwijderd]

Dat voorbeeld in die url had ik inderdaad al gevonden, maar wanneer je daar meer dan 3 threads naast elkaar draait crashed de hele handel ik heb nog niet gekeken waarom, misschien een goed idee.

De win api kan alleen maar fucties in een nieuwe thread starten, dat is het probleem. Ook het voorbeeld van die url wordt een work-around gebruikt om eerst de klasse te maken en dan een nieuw klasse via die functie in een nieuwe thread te starten (crappy explaination).

Het is om een klein servertje te bouwen die verbindingen met meerdere clients onderhoud. Wat er dus moet gebeuren is dat al die verbindingen aan een aparte thread geven worden, de functie van die thread schiet in een while todat de verbinding verbroken word zodat ze paralel naast elkaar draaien.

elke verbinding in een aparte klasse was mooi geweest een work-around met globale variablen moet ook wel te doen zijn, maar dat wordt een pot bagger. Ik begin er inmiddels een hard hoofd in te krijgen met mijn c++ kennis (meer thuis in java/C). Maar t moet mogelijk zijn niet?

[ Voor 8% gewijzigd door Verwijderd op 19-05-2005 23:05 ]

[MSalters]

Sorry, maar zoek eens beter. Het is triviaal om elke verbinding door een eigen object te laten beheren. C++ heeft net zoals Java methods, en daar kan dus rustig een while() { } in staan.

Overigens zou ik als ik jou was naar Boost threads kijken. Dat is een eenvoudigere manier om threads en OO te combineren.

[Verwijderd]

Maak het zo:

C++:

class Ik
{
  static DWORD WINAPI Run( LPVOID lpParam );
}

//Create the thread
hThread = CreateThread( 
        NULL,               
        0,                  
        Ik::Run,    
        0,                  
        0,                  
        &dwThreadId);

//Vervolgens in Run
static DWORD WINAPI Ik::Run( LPVOID lpParam )
{
  Ik *pInstance = new ik();
  while(bRun)
  {
    //.....
  }

  delete pInstance ;
}

[ Voor 4% gewijzigd door Verwijderd op 20-05-2005 10:38 ]

[MSalters]

Het probleem met die opzet is dat degene die de thread aanmaakt niet bij pInstance kan. Overigens is de code ook incorrect: je mag geen exception lekken, de catch(...) ontbreekt dus. Daardoor heb je ook een potentieel memoryleak. Dat memoryleak wordt mede veroorzaakt door een onnodige new/delete. new en vooral delete horen in constructors/destructors. Dit object hoort gewoon op de stack.