Données membres incorrecte lors du passage d'un pointeur à un thread

Bonjour à tous,

J'ai besoin d'un rappel (et d'une explication).

J'ai une classe qui possède des données membres et qui va créer un thread. Lors de la création du thread, je passe un pointeur (this) sur cette classe. Par contre, dans le thread, les données membres de la classe sont incorrectes (comme si le constructeur avait été rappelé). Pourquoi ?

Un peu de code, svp ?
:aie:

La valeur du "this" n'a pas été salopée avec un cast, une taille insuffisante pour un pointeur polymorphique, etc.... ?

Arf. J'avais loupé le message. :mur:.

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
#ifndef FILERESOURCE_HPP
#define FILERESOURCE_HPP
 
#include <string>
#include <thread>
 
struct ThreadParameters;
 
class FileResource
{
    private:
        std::thread m_watcherThread;
        bool m_threadRunning;
        std::string m_path;
        int m_ifd; // File Descriptor for inotify
        int m_wfd; // Watch Descriptor for inotify
        bool m_changed;
 
        void setupWatcher();
 
    public:
        FileResource(const std::string& path);
        virtual ~FileResource();
 
        bool hasChanged()const { return m_changed; }
        virtual void reload();
 
    friend void watcherThread(FileResource* pFR);
};
 
#endif

Et l'implémentation :

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
97
98
#include "FileResource.hpp"
 
#include <cassert>
#include <iostream>
 
#include <sys/inotify.h>
#include <errno.h>
#include <string.h>
#include <time.h>
#include <unistd.h>
 
 
FileResource::FileResource(const std::string& path)
    :m_threadRunning(false), m_path(path), m_ifd(-1), m_wfd(-1), m_changed(false)
{
    setupWatcher();
}
 
FileResource::~FileResource()
{
    if (m_threadRunning)
    {
        m_threadRunning = false;
        m_watcherThread.join();
    }
}
 
struct ThreadParameters
{
    FileResource* pResource;
};
 
void watcherThread(FileResource* pFR)
{
    assert(pFR);
 
    ssize_t len = 0;
    char buf[4096]  __attribute__ ((aligned(__alignof__(struct inotify_event))));
    const struct inotify_event* event;
    char* ptr = NULL;
 
    std::cout << "Should thread (" << pFR << ")" << std::endl;
    while(pFR->m_threadRunning)
    {
        std::cout << "Read "  << pFR->m_ifd << std::endl;
        len = read(pFR->m_ifd, buf, sizeof buf);
        if (len == -1 && errno != EAGAIN)
        {
            std::cerr << "Fail to read inotify file descriptor " << strerror(errno);
            break;
        }
        if (len > 0)
        {
            std::cout << "There is a change" << std::endl;
            for(ptr = buf ; ptr < buf + len ;
                            ptr += sizeof(struct inotify_event) + event->len)
            {
 
                event = (const struct inotify_event *) ptr;
                if (event->mask & IN_MODIFY)
                {
                     std::cout << "IN_MODIFY";
                     pFR->m_changed = true;
                }
            }
        }
 
        timespec delay = {0, 200000000};
        nanosleep(&delay,NULL);
    }
}
 
void FileResource::setupWatcher()
{
    int m_ifd = inotify_init1(IN_NONBLOCK);
    if(m_ifd == -1)
    {
        std::cerr << "Fail to init inotify : " << strerror(errno);
        return;
    }
    std::cout << "id is : " << m_ifd;
 
    int m_wfd = inotify_add_watch(m_ifd, m_path.c_str(), IN_MODIFY);
    if (m_wfd == -1)
    {
        std::cerr << "Fail to add engine watcher";
        return;
    }
 
    m_threadRunning = true;
    std::cout << "id is : " << m_ifd << " and ptr is : " << this;
    m_watcherThread = std::thread(watcherThread, this);
}
 
void FileResource::reload()
{
    std::cout << "Test";
}

Le m_ifd vaut 3 à la création du thread, mais -1 dans le thread.

J'ai un code fonctionnel, si j'utilise une structure dédiée au partage de données entre les threads. Mais je continue à ne pas comprendre pourquoi ça ne marche pas avec this.

Bonjour,

il y a 2 variables m_ifd, une locale ligne 75 qui vaut 3, une membre qui reste toujours à -1.
Idem pour m_wfd.

En effet :mur:. Le boulet :(.
Dommage que je n'avais pas l'option -Wshadow et qu'elle ne soit pas activée avec -Wextra.