Probleme avec 'AfxBeginThread'

Voila j essai d'utiliser la fonction AfxBeginThread

Ma fonction appellée est définie dans le .h:

Code:

UINT captThread( LPVOID pParam);

Je l appelle comme ceci:

Code:

AfxBeginThread(captThread,NULL,THREAD_PRIORITY_NORMAL,0,0,NULL);

Le probleme est que je dois fournir un parametre de type char à la fonction

Et je ne sais pas où le signaler!

Bonjour,
Qu'est ce que tu veux faire avec ce char ?
Peux tu poster un peu de code ?

Citation:

Envoyé par jagboys

Bonjour,
Qu'est ce que tu veux faire avec ce char ?
Peux tu poster un peu de code ?

et regarder la faq ....
http://c.developpez.com/faq/vc/?page...keWorkerThread

j'ai regarder ds la FAQ mais en vain...

voila mon bout de code, ma fonction sans le multithread ma fonction est appellé comme ceci
Code:

1 2 capt_off_save(adresseTxt, adresseOffLine,adresseCAP);
La fonction appellée est de la forme
Code:

1 2 int capt_off_save(char *txt, char *capI, char *capO ) {
Comment faire passer ces parametres en utilisant AfxBeginThread

bon voici la partie de la faq qui t'interesse :

Citation:

Utilisation de AfxBeginThread():

Code:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
CWinThread* AfxBeginThread( 
AFX_THREADPROC pfnThreadProc, 
LPVOID pParam, 
int nPriority = THREAD_PRIORITY_NORMAL, 
UINT nStackSize = 0, 
DWORD dwCreateFlags = 0, 
LPSECURITY_ATTRIBUTES lpSecurityAttrs = NULL );
 
CWinThread* AfxBeginThread( 
CRuntimeClass* pThreadClass, 
int nPriority = THREAD_PRIORITY_NORMAL, 
UINT nStackSize = 0, 
DWORD dwCreateFlags = 0, 
LPSECURITY_ATTRIBUTES lpSecurityAttrs = NULL );

[
Pré-requis:
Include : déclarée dans Afxwin.h
Système: Win 95, Win NT ,WINCE 2.0 et plus.

Code:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
class CMyDialog : public CDialog
{
public:
    CMyDialog(CWnd* pParent = NULL)
        : CDialog(CMyDialog::IDD, pParent)
    {
        m_pThread = NULL;
    }
 
    bool InitThread()
    {
        m_pThread = AfxBeginThread(ThreadFunc, this);
        if(!m_pThread)
        {
            // Impossible de créer le thread !
            return false;
        }
        return true;              
    }
 
private:
    CWinThread *m_pThread;            
 
    static UINT ThreadFunc(LPVOID pvParam);
};
 
UINT CMyDialog::ThreadFunc(LPVOID pvParam)
{
    CMyDialog  *pThis=reinterpret_cast< CMyDialog *>( pvParam) ;
    // Votre code
    //
    return 0 ;
}

Autre exemple d'implementation :

Code:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
class CWorkerThread
{
public:
    CWorkerThread(); // crée le thread et démarre son exécution
    ~CWorkerThread(); // arrêter le thread si ce n'est pas fait
 
    // demande de s'arrêter au thread
    // si on lui donne un timeout, et que ce dernier expire,
    // la fonction tue le thread et renvoie false
    // renvoie true si le thread s'est terminé proprement
    bool Stop( DWORD dwTimeoutMs = INFINITE );
 
    // exemple de valeur retournée par le thread
    // son temps d'exécution en ms
    DWORD ExecutionTime;
 
private:
    // Execute contient votre code à exécuter dans le thread
    UINT Execute();
 
private:
    volatile bool m_StopThread; // arrêt demandé
    CWinThread * m_Thread; // thread créé
 
    static UINT WorkerThreadLauncher(LPVOID pvParam);
};
 
CWorkerThread::CWorkerThread():
    m_StopThread( false ),
    ExecutionTime( 0 )
{
    // depart du thread
    this->m_Thread = AfxBeginThread(WorkerThreadLauncher, this);
}
 
CWorkerThread::~CWorkerThread()
{
    this->Stop();
}
 
bool CWorkerThread::Stop( DWORD dwTimeoutMs )
{
    if ( this->m_Thread != NULL )
    {
        // demander de s'arrêter
        this->m_StopThread = true;
        // attendre qu'il soit arrêté pour la durée spécifiée
        if ( ::WaitForSingleObject(
                *this->m_Thread,
                dwTimeoutMs ) != WAIT_OBJECT_0 )
        {
            // échec de l'attente : le thread ne s'est pas terminé
            // on le tue
            ::TerminateThread( *this->m_Thread, 0 );
            this->m_Thread = NULL;
            return false;
        }
        // tout s'est bien passé
        this->m_Thread = NULL;
    }
    return true;
}
 
// point d'entrée du thread
UINT CWorkerThread::WorkerThreadLauncher(LPVOID pvParam)
{
    CWorkerThread *pThreadInstance =
        reinterpret_cast<CWorkerThread *>(pvParam);
    return pThreadInstance->Execute();
}
 
// IMPORTANT: si vous appelez des fonctions membres
// ou modifiez des données membres de CWorkerThread
// veillez à que leur utilisation soit thread safe
// car Execute() s'execute dans un autre thread contrairement
// aux autres fonctions qui sont appelées depuis le thread principal
// En particulier, il ne faut surtout pas appeler Stop()
UINT CWorkerThread::Execute()
{
    // exemple de code à exécuter
 
    DWORD start = ::GetTickCount();
 
    do
    {   
        // code de traitement
        ::Sleep( 1000 ); // simuler une opération de 1 sec
    } while ( this->m_StopThread == false ) ;
 
    DWORD end = ::GetTickCount();
 
    // renvoyer un résultat : temps d'exécution
    this->ExecutionTime = end - start;
 
    return 0;
}

utilisation :

Code:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
      // créer et lancer le thread
    CWorkerThread thread;
 
    // l'arrêter
    if ( thread.Stop() )
    {
        // récupérer le résultat
        CString s;
        s.Format( "%d ms", thread.ExecutionTime );
        AfxMessageBox( s );
    }
    else
    {
        AfxMessageBox( "Le thread a été tué" );
    }

comme tu peux le voir tu dois creer une structure pour gérer tes paramètres et passer la structure à AfxBeginThread. Il faut aussi que tu changes la siganture de ta fonction !

Merci pour les infos

Ca a fini par marcher

Par contre j'ai un autre probleme mais je vais faire un nouveau post....

:lol: