Appel AfxBeginThread avec la fonction de membre de classe?

Comment puis-je appeler AfxBeginThread d'un arbitraire de non-statique méthode de la classe? Peut-être il ya quelque chose que je peux faire avec boost lier? Ci-dessous est de l'utilisation de Microsoft (et c'est un exemple d'appel d'un non-statique méthode, mais elle est codée en dur de la méthode):

UINT MyThreadProc( LPVOID pParam )
{
    CMyObject* pObject = (CMyObject*)pParam;

    if (pObject == NULL ||
        !pObject->IsKindOf(RUNTIME_CLASS(CMyObject)))
    return 1;   //if pObject is not valid

    //do something with 'pObject'

    return 0;   //thread completed successfully
}

//inside a different function in the program
...
pNewObject = new CMyObject;
AfxBeginThread(MyThreadProc, pNewObject);

Vous avez déjà la solution. Vous l'avez posté dans la question. En quoi est-il pas suffisant pour vous?
Ce que j'aimerais être capable de faire est d'exécuter l'arbitraire d'un membre de la classe de fonction dans un thread comme vous pouvez le faire avec boost fil. Mon posté exemple fonctionne, mais c'est codé en dur à une classe particulière. Je voudrais utiliser boost fil, mais il semble qu'il y a des problèmes lors de l'utilisation dans un contexte MFC.
Vous devez appeler votre fonction membre où il est l'espace réservé commentaire "faire quelque chose avec 'pObject'". Désolé, mais c'est juste la façon dont il est.

InformationsquelleAutor User | 2011-10-21

boost-bind c++member-functions multithreading windows

3

Vous aurez besoin d'une fonction statique de passer à AfxBeginThread, mais il peut être une fonction très simple qui appelle à l'objet. Voici un non testé fonction de modèle, qui pourrait travailler.
```
template<class T>
UINT __cdecl StartThread(LPVOID pParam)
{
    return ((T*)pParam)->MyThreadProc();
}
```
InformationsquelleAutor Mark Ransom
2

Votre exemple de code est très bien. Vous aurez besoin d'une fonction de thread pour chaque non-statique méthode de classe que vous souhaitez appeler dans des threads séparés.

boost:bind ne sera pas vous aider que ce soit... AfxBeginThread devrait être en C++ une fonction de modèle, sinon il ne peut pas être compatible avec boost::bind ou C++11 lambdas avec capture.

Une Alternative est de créer une structure, avec un enum pour chaque classe/méthode de combinaison que vous aurez, mais cela vous oblige à ajouter manuellement le code à la fois à l'enum et de la fonction de rappel pour chaque classe/méthode de combinaison. Cependant ce n'est pas que beaucoup moins de code que de créer un thread séparé de la fonction pour chaque classe/méthode de combinaison.
```
struct ThreadData
{
  LPVOID object;
  enum ObjectCallType {
    Foo_Foo,
    Foo_Bar
  } objectCallType;
  LPVOID* param;
  ThreadData( LPVOID pobject, ObjectCallType poct, LPVOID* pparam=0 )
  :object(pobject), objectCallType(poct), param(pparam) {}
};

UINT MyThreadProc( LPVOID pParam )
{
    TheadData* thData = (ThreadData*)pParam;
    try 
    {
        switch( thData->objectCallType )
        {
            case ThreadData::Foo_Foo:
                Foo* foo = (Foo*)thData->object;
                foo->foo();
                break;
            case ThreadData::Foo_Bar:
                Foo* foo = (Foo*)thData->object;
                foo->bar( thData->param );
                break;
            default:
                throw std::exception("unhandled method call type");
        }
    }
    catch( std::exception& e )
    {
        std::cerr << e.what() << std::endl;
        delete thData;
        return 1;
    }
    delete thData;
    return 0;
}



//usage:
AfxBeginThread(MyThreadProc, new ThreadData(myFooObject,ThreadData::Foo_Bar,myFooCallParam));
```
Boost exemple (non testé):
```
boost::thread myFooFooThread( boost::bind( &Foo::Foo, myFooObject ) );
```
- Je n'ai pas d'expérience avec boost lier. Pourriez-vous passer un coup de pouce lier objet en tant que paramètre à MyThreadProc puis ont MyThreadProc simplement appeler la poussée de la fonction de liaison?
- non tu ne peux pas, parce que vous avez à jeter les boost::bind objet de LPVOID de l'objet réel, et ce n'est pas anodin, parce qu'à peu près tous les boost::bind objet a un autre (compliquée) de type. Vous pouvez toutefois utiliser boost::bind objets avec boost::thread.
- étant donné que je me demande si vous pourriez utiliser boost::bind avec basé sur un modèle StartThread fonction comme dans Marc Rançon de la réponse.
- oui vous pouvez, mais vous devez toujours spécifier le type de la liaison de l'expression en tant que paramètre du modèle, et c'est très gênant, sauf si vous pouvez utiliser le C++11 caractéristiques auto et decltype ou std::function.
InformationsquelleAutor smerlin
0

Je sais que cette question est assez vieux -- mais c'est proche de ma situation actuelle. Je suis en train de travailler sur une application écrite en Visual Studio 2008 projet, et éviter toutes les fonctions de démarrage.

Ce que j'ai trouvé il y a deux différents appels d'AfxBeginThread: On exige la fonction start (pour le lancement des threads de travail); l'autre prend en premier paramètre une classe dérivée de CWinClass et est utilisé pour la création de l'Interface Utilisateur les objets connectés ET les threads de travail.

J'ai choisi la deuxième option. Ne serait-ce pas aussi le travail dans la question ci-dessus?

InformationsquelleAutor Charles Thomas

Vous devez vous connecter pour publier un commentaire.