Discussion :

[mazertys17]

Bonjour.

Depuis une discutions sur les pointeurs, j'ai suivis les conseils donnés et me suis résolu a utiliser des pointeurs intelligents, a savoir, ici, boost::shared_ptr.
J'ai un petit soucis, et je pense que cela vient justement de pointeurs de ce type.

J'ai un vector d'objet, dont chaque objet contient 2 boost::shared_ptr d'autres objets, qui servent a recevoir/envoyer leur coordonnées pour l'affichage et pour les collision. Tout fonctionne très bien, jusqu'au moment ou je décide de supprimer l'un de ces objets ainsi:

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
10
11
 
 
    for(vector<Objet>::iterator it = m_objet.begin() ; it != m_objet.end() ; it++)
    {
        it->rafraichi();
        if(!it->renvoiVie())
        {
           m_objet.erase(it);
           it = m_objet.begin() ;
        }
    }

il plante alors et me dit ceci en console : " pure virtual method called // terminate called without an active exception "

Une question me vient donc, quand aux boost::shared_ptr:

Si on envoi un boost::shared_ptr<Objet> a un autre objet, faut-il lui indiquer si l'objet est détruit (donc la référence), si en l'occurence, cela peut être la source du plantage, et si c'est le cas, comment le faire?

Merci si vous pouvez m'aider

[Flob90]

Bonjour,

Tu ne peux pas utiliser le C++11/C++14 à la place d'utiliser boost ici ?

Pourquoi des shared_ptr ? Des unique_ptr ne conviennent pas ?

Je ne vois pas de raison pour que ça plante ici, tu pourrais donner plus de code ? Celui de Objet par exemple.

[dragonjoker59]

Après, si Objet est une classe de base avec une fonction virtuelle pure parmi rafraichi, renvoiVie ou son destructeur, alors, pas de surprise à ce que ça explose, car dans ton vecteur tu stockes des Objet et pas des pointeurs (au sens large : nu, unique_ptr, shared_ptr ou weak_ptr) sur Objet

[mazertys17]

Merci pour vos réponses

voici le code de mon objet.

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

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
 
class CharbonPetit2
{
public:
    CharbonPetit2();
 
    //CharbonPetit2 (const CharbonPetit2 &charbonPetitCopie);
 
    ~CharbonPetit2();
 
    //CharbonPetit2& operator = (const CharbonPetit2 charbonPetitCopie);
    void                                        recoitPtrAfficheur(boost::shared_ptr<Afficheur> ptr_afficheur);
    void                                        recoitPtrFeuElement(boost::shared_ptr<FeuElement> m_ptr_feuElement);
    void                                        cree(string nom, sf::Texture *texture, int tailleImageL, int tailleImageH );
    void                                        recoitCollisionSimple(int x, int y, int taille);
    void                                        recoitDepar(int x, int y, int nombreImageDepar);
    void                                        recoitFin(int x, int y, int nombreImageFin);
    void                                        positionne(int x, int y);
    void                                        initialise();
 
    void                                        rafraichi();
    void                                        anime();
    void                                        collisionne();
    void                                        brule();
 
    bool                                        renvoiVie();
    string                                      renvoiNom();
 
 
private:
 
    boost::shared_ptr<Afficheur>                m_ptr_afficheur;
    boost::shared_ptr<FeuElement>               m_ptr_feuElement;
 
    string                                      m_nom;
    EI                                          m_EI;
    CollisionSimple                             m_collisionSimple ;
    CollisionSimple                             m_collisionSimpleDeclencheur;
    sf::Vertex                                  m_vertex[4];
 
    bool                                        m_tip, m_demarre, m_vie , m_animation;
    float                                       m_x, m_y, m_z;
    int                                         m_temps;
    int                                         m_colX, m_colY, m_colTaille;
    int                                         m_tailleTextureL, m_tailleTextureH, m_tailleImageL, m_tailleImageH;
    int                                         m_nombreImageDepar, m_nombreImageFin;
    int                                         m_compteurX, m_compteurY, m_compteurImage, m_deparX, m_deparY , m_finX, m_finY ;
    float                                       m_compteurTemps;
 
};

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

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
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
228
229
230
231
232
233
234
235
236
237
238
239
240
241
242
243
244
245
246
247
248
249
250
251
252
253
254
255
256
257
258
259
260
261
262
263
264
265
266
267
268
269
270
271
272
273
274
275
276
277
278
279
280
281
282
283
284
285
286
287
288
289
 
 
 
CharbonPetit2::CharbonPetit2(){}
 
CharbonPetit2::~CharbonPetit2(){}
 
void CharbonPetit2::recoitPtrAfficheur(boost::shared_ptr<Afficheur> ptr_afficheur)
{
    m_ptr_afficheur = ptr_afficheur;
}
 
void CharbonPetit2::recoitPtrFeuElement(boost::shared_ptr<FeuElement> ptr_feuElement)
{
    m_ptr_feuElement = ptr_feuElement;
    m_collisionSimple.recoitPtrFeuElement(ptr_feuElement);
    m_collisionSimpleDeclencheur.recoitPtrFeuElement(ptr_feuElement);
}
 
void CharbonPetit2::cree(string nom, sf::Texture *texture, int tailleImageL, int tailleImageH)
{
    m_demarre = true;
    m_animation = false;
    m_vie = true;
    m_compteurTemps = -37;
    m_tip = 0;
 
    m_nom = nom;
    m_tailleTextureL = texture->getSize().x;
    m_tailleTextureH = texture->getSize().y;
    m_tailleImageL   = tailleImageL;
    m_tailleImageH   = tailleImageH;
 
    m_x = 0;
    m_y = 0;
    m_z = 1117777;
 
    m_compteurX = 0;
    m_compteurY = 0;
    m_deparX = 0;
    m_deparY = 0;
 
    m_vertex[0] = sf::Vector2f(m_x                              ,m_y );
    m_vertex[1] = sf::Vector2f(m_x + m_tailleImageL             ,m_y );
    m_vertex[2] = sf::Vector2f(m_x + m_tailleImageL             ,m_y + m_tailleImageH);
    m_vertex[3] = sf::Vector2f(m_x                              ,m_y + m_tailleImageH);
 
    m_vertex[0].texCoords = sf::Vector2f(0                       , 0);
    m_vertex[1].texCoords = sf::Vector2f(m_tailleImageL          , 0);
    m_vertex[2].texCoords = sf::Vector2f(m_tailleImageL          , m_tailleImageH);
    m_vertex[3].texCoords = sf::Vector2f(0                       , m_tailleImageH);
 
    m_EI.recoitTexture(texture);
    m_EI.recoitVertex(m_vertex);
 
}
 
void CharbonPetit2::recoitCollisionSimple(int x, int y, int taille)
{
    m_collisionSimple.initialise(x, y, taille);
    m_collisionSimpleDeclencheur.initialise(x, y, taille *2);
}
 
void CharbonPetit2::recoitDepar(int x, int y, int nombreImageDepar)
{
    m_deparX = x;
    m_deparY = y;
    m_nombreImageDepar = nombreImageDepar;
    m_compteurImage = nombreImageDepar;
}
 
void CharbonPetit2::recoitFin(int x, int y, int nombreImageFin)
{
    m_finX = x;
    m_finY = y;
    m_nombreImageFin = nombreImageFin;
}
 
void CharbonPetit2::positionne(int x, int y)
{
    m_x = x + m_tailleImageL/2;
    m_y = y + m_tailleImageH/2;;
 
}
 
void CharbonPetit2::initialise()
{
    m_EI.recoitZ(m_y + m_tailleImageH/4);
    m_ptr_afficheur->recoitEI(&m_EI);
 
    m_collisionSimple.deplace(m_x, m_y);
    m_collisionSimpleDeclencheur.deplace(m_x, m_y);
}
 
void CharbonPetit2::rafraichi()
{
 
    m_tip = false;
    if(m_ptr_afficheur->renvoiTemps())
    {
        m_temps++;
        if(m_temps >= 2)
        {
            m_temps = 0;
            m_tip = true;
        }
 
    }
 
    if(m_demarre)
    {
        m_demarre = false;
    }
 
    this->anime();
    this->collisionne();
 
//////////////////////////////////////////////////////////////////////////////////////////////////////////////////
//////////////////////////////////////////////////////////////////////////////////////////////////////////////////
//////////////////////////////////////////////////////////////////////////////////////////////////////////////////
//////////////////////////////////////////////////////////////////////////////////////////////////////////////////
}
 
void CharbonPetit2::anime()
{
 
 
    if(!m_animation && m_compteurTemps <=-37)
    {
        m_compteurX = 0;
        sf::Vector2f vector2f;
 
    sf::Vector2i pixelPos = sf::Mouse::getPosition(*m_ptr_afficheur->renvoiFenetre());
    sf::Vector2f worldPos = m_ptr_afficheur->renvoiFenetre()->mapPixelToCoords(pixelPos);
 
        if(m_collisionSimple.collisionneObjet(worldPos))
        {
            m_compteurX = 1;
        }
    }
 
 
    if(m_tip == 1 && m_animation)
    {
            m_compteurX ++;
            m_compteurImage++;
 
            m_compteurTemps ++;
    }
 
 
    if(m_compteurX >= m_tailleTextureH / m_tailleImageL)
    {
        m_compteurX = 0;
        m_compteurY++;
    }
 
    if(m_compteurY >= m_tailleTextureH / m_tailleImageH)
    {
        m_compteurX = m_deparX;
        m_compteurY = m_deparY;
    }
 
    if(m_compteurImage >= m_nombreImageFin)
    {
        m_compteurX = m_deparX;
        m_compteurY = m_deparY;
        m_compteurImage = m_nombreImageDepar;
    }
 
 
 
    m_vertex[0] = sf::Vector2f(m_x                              ,m_y );
    m_vertex[1] = sf::Vector2f(m_x + m_tailleImageL             ,m_y );
    m_vertex[2] = sf::Vector2f(m_x + m_tailleImageL             ,m_y + m_tailleImageH);
    m_vertex[3] = sf::Vector2f(m_x                              ,m_y + m_tailleImageH);
 
    m_vertex[0].texCoords = sf::Vector2f(m_tailleImageL * m_compteurX                            , m_tailleImageH * m_compteurY);
    m_vertex[1].texCoords = sf::Vector2f(m_tailleImageL * m_compteurX + m_tailleImageL           , m_tailleImageH * m_compteurY);
    m_vertex[2].texCoords = sf::Vector2f(m_tailleImageL * m_compteurX + m_tailleImageL           , m_tailleImageH * m_compteurY + m_tailleImageH);
    m_vertex[3].texCoords = sf::Vector2f(m_tailleImageL * m_compteurX                            , m_tailleImageH * m_compteurY + m_tailleImageH);
 
 
    m_EI.recoitVertex(m_vertex);
}
 
void CharbonPetit2::collisionne()
{
 
    m_collisionSimple.rafraichi();
 
    if(m_collisionSimpleDeclencheur.collisionneSimple())
    {
        if(m_ptr_afficheur->renvoiTemps())
        {
            m_compteurTemps++;
        }
        if(m_compteurTemps == 0)
        {
        this->brule();
        }
    }
 
 
 
//////////////////////////////////////////////////////////////////////////////////////////////////////////////////
//////////////////////////////////////////////////////////////////////////////////////////////////////////////////
//////////////////////////////////////////////////////////////////////////////////////////////////////////////////
//////////////////////////////////////////////////////////////////////////////////////////////////////////////////
    if(m_compteurTemps < -37 )
    {
        m_compteurX = 0;
    }
 
 
    if(m_compteurTemps >= -37 && m_compteurTemps <= 0)
    {
        m_compteurX = 2;
 
        if(m_tip == 1)
        {
        m_compteurTemps --;
        }
 
    }
 
    if(m_compteurTemps >= 1 && m_compteurTemps <= 1117)
    {
        if(m_compteurImage ==9)
        {
            m_deparX = 0;
            m_deparY = 1;
            m_nombreImageDepar = 16;
 
            m_finX = 5;
            m_finY = 1;
            m_nombreImageFin =21;
        }
    }
    if(m_compteurTemps == 117)
    {
        this->recoitFin(5,2,37);
    }
 
    if(m_compteurImage >= 36)
    {
        m_vie = false;
        //m_colision.detruit();
    }
 
 
 
 
}
 
 
void CharbonPetit2::brule()
{
    m_animation = true;
    m_compteurTemps++;
 
    if(m_compteurTemps == 1)
    {
    m_compteurX = 2;
    m_compteurY = 0;
    m_nombreImageDepar = 2;
    m_compteurImage = 2;
 
    m_deparX = 2;
    m_deparY = 0;
    m_nombreImageDepar = 2;
 
    m_finX = 5;
    m_finY = 1;
    m_nombreImageFin = 21;
    }
 
 
}
 
bool CharbonPetit2::renvoiVie()
{
    return m_vie;
}
 
string CharbonPetit2::renvoiNom()
{
    return m_nom;
}

[Flob90]

AMA il y a plus simple que ce que tu fais là, c'est quoi le contexte générale de ton application ?

Tu as des fonctions virtuelles pures dans ton code ? En particulier dans Afficheur/FeuElement, si c'est le cas tu peux faire voir la hiérarchie correspondant aux classes déclarant ces fonctions ?

[mazertys17]

AMA il y a plus simple que ce que tu fais là

C'est a dire? sur quoi?

c'est quoi le contexte générale de ton application ?

C'est un jeu vidéo 2D en vue isométrique. J'utilise SFML, code::block.

Tu as des fonctions virtuelles pures dans ton code ? En particulier dans Afficheur/FeuElement

En fait, je n'ai pas dirrectement de fonction virtuelle pure (a moins que je me trompe sur ce qu'est une fonction virtuelle pure ), car je n'utilise pour l'instant pas l'héritage...Que des class en dure, si je puis dire....
En revanche, j'utilise une class EI, qui est dérivée de sf:: Drawable, qui en contient surement. Je pense d'ailleurs vraiment que ca doit venir de là. J'avais oublié de mettre cette ligne de code, dans mon objet, juste avant qu'il demande sa destruction en changeant m_vie :

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
 
 
        m_ptr_afficheur->efface(&m_EI);
        m_vie = false;

Qui aurait pu être la cause du plantage...puisque Afficheur affiche toutes les EI dirrectement depuis leurs adresses...

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
 
 
    for(multiset<EI*>::iterator it = m_EI.begin() ; it != m_EI.end() ; it ++)
    {
        m_fenetre->draw(**it);
    }

mais ca plante toujours.

voici la fameuse class EI qui est dérivée de sf:rawable :

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

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
 
 
 
 
class EI : public sf:: Drawable
{
public:
 
    friend struct MonFoncteur;
 
    void recoitTexture(sf::Texture *texture)
    {
        m_texture = texture;
        m_actif = true;
    }
    void recoitVertex(sf::Vertex vertex[4])
    {
        m_tableauVertex[0] = vertex[0];
        m_tableauVertex[1] = vertex[1];
        m_tableauVertex[2] = vertex[2];
        m_tableauVertex[3] = vertex[3];
 
    }
    void active(bool actif)
    {
        m_actif = actif;
    }
    void recoitZ(int z)
    {
        m_z = z;
    }
 
private:
 
    virtual void draw(sf::RenderTarget& cible, sf::RenderStates states) const
    {
        if(m_actif)
        {
        cible.draw(m_tableauVertex,4, sf::Quads, m_texture);
        }
    }
 
    bool m_actif;
    float m_z;
    sf::Vertex m_tableauVertex[4];
    sf::Texture *m_texture;
 
};
 
struct MonFoncteur
{
   bool operator() (const EI* un, const EI* deux) const
   {
        return un->m_z < deux->m_z;
   }
};

[Daïmanu]

sf::Drawable a son destructeur déclaré virtuel, et tu ne définis pas de destructeur dans ta classe EI.

[mazertys17]

Merci, Daïmanu, pour ta réponse.

Comment faudrait-il le faire pour faire au mieu, depuis l'EI ?

[Flob90]

Ta classe CharbonPetit2 me semble bien trop compliqué, deux shared_ptr, des pointeurs nues, et des noms étranges (tu peux enlever tout les recoit, c'est évident qu'une fonction reçoit des paramètres, le nom doit décrire ce que fait la fonction, pas le fait qu'elle reçoit des paramètres). Je pense vraiment qu'il y a un problème de conception.

Tu peux faire une exécution pas à pas ? Tu devrais voir qu'elle est la fonction qui pose problème et pourquoi elle est appelée. De là on pourra trouver comment le corriger. Tu peux aussi faire voir le code qui utilise EI ? En particulier comment ils sont stockés.

@Daïmanu: Tant que le destructeur de la classe mère est définie, la classe fille n'a aucun problème pour définir le sien.

[Daïmanu]

@Daïmanu: Tant que le destructeur de la classe mère est définie, la classe fille n'a aucun problème pour définir le sien.

Au temps pour moi, je pensais que c'était nécessaire, d'autant plus que j'ai eu des problèmes avec std::unique_ptr si je ne déclarais pas de destructeur (même avec ~c() = default;).

[Flob90]

@Daïmanu: Étrange que tu ais eu des problèmes, il y a une problématique avec unique_ptr et le destructeur (dans une situation "par défaut") quand tu utilises un type incomplet, mais ce n'est pas le cas que tu sembles avoir vécu (quoique).

Dans le cas de l'OP, je pense à un appel directe de sf::Drawable::draw après qu'un EI ai été copié en un sf::Drawable.

[mazertys17]

Merci, Flob90 pour ta réponse.

c'est évident qu'une fonction reçoit des paramètres

dans mon cas, il peut y avoir, par ex: monObjet.rafraichi();

Mais bon, je reconnais que c'est une façon de faire probablement pas très académique.

Ta classe CharbonPetit2 me semble bien trop compliqué

Je veux bien l'admettre. Cependant, il faut préciser qu'il s'agit d'un objet qui:

-permet de s'éclairer quand on passe la souris sur.
-peut/doit être animé, selon plusieurs cycles(l'objet prend feu, il brule, il "explose" et disparait)//ce qui prend beaucoup de texte pour pas grand chose...surtout qu'il partage une texture avec d'autres objets...
-peut s'activer si on s'approche de lui (donc 1 collision ).
-doit bloquer le passage a un objet qui bouge (ici elemenFeu, donc 2 collisions).

Il y a probablement d'autres façons de faire, mais pour l'instant, jusqu'au moment ou j'essaye de les détruires, ca marche. dans mes tests, je peux en utiliser plus de 16000 en même temps sans que ca rame. Pour mon gd, ca me suffit.
Si le seul problème de conception est le vocabulaire, alors, ca ira ...si par contre c'est une question de programmation/pointeurs, etc... il va faloir que je fasse très attention...

J'ai enlevé les collisions, pour voir, et ca plante toujours, donc ca ne vient probablement pas de là,(surtout qu'il n'y a aucune class hérité là dedans...)

voici ma class Afficheur :

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

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
 
 
 
class Afficheur
{
public:
 
    Afficheur();
    ~Afficheur();
 
    void                               recoitEI(EI* entiteImage);
    void                               recoitFenetre(sf::RenderWindow *fenetre);
    void                               recoitPtrEvent(boost::shared_ptr<sf::Event>  ptr_event);
    void                               recoitTemps();
    void                               recoitDeltaTemps(float deltaTemps);
    void                               efface(EI *eI);
    void                               vide();
 
    void                               affiche();
 
    sf::RenderWindow*                  renvoiFenetre();
    boost::shared_ptr<sf::Event>       renvoiPtrEvent();
    Vue*                               renvoiVue();
    bool                               renvoiTemps();
    float                              renvoiDeltaTemps();
 
private:
 
    sf::RenderWindow                   *m_fenetre;
    boost::shared_ptr<sf::Event>       m_ptr_event;
    std::multiset<EI*, MonFoncteur>    m_EI;
    Vue                                m_vue;
    float                              m_deltaTemps;
    bool                               m_temps;
 
};

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

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
 
 
#include "Afficheur.h"
 
Afficheur::Afficheur(){}
Afficheur::~Afficheur(){}
 
void Afficheur::recoitFenetre(sf::RenderWindow *fenetre)
{
        m_fenetre = fenetre;
        m_vue.renvoiVue()->setSize(m_fenetre->getSize().x,m_fenetre->getSize().y);
        m_vue.renvoiVue()->setCenter(m_fenetre->getSize().x/2,m_fenetre->getSize().y/2);
}
 
void Afficheur::recoitPtrEvent(boost::shared_ptr<sf::Event>  ptr_event)
{
    m_ptr_event = ptr_event;
    m_vue.recoitPtrEvent(ptr_event);
}
 
void Afficheur::recoitEI(EI* entiteImage)
{
    multiset<EI*>::iterator it = m_EI.begin();
    m_EI.insert(it,entiteImage);
}
 
void Afficheur::recoitDeltaTemps(float deltaTemps)
{
    m_deltaTemps = deltaTemps;
}
 
void Afficheur::recoitTemps()
{
    m_temps = true;
}
 
void Afficheur::affiche()
{
    m_vue.rafraichi(m_temps);
    m_temps = false;
 
    m_fenetre->setView(*m_vue.renvoiVue());
 
 
    for(multiset<EI*>::iterator it = m_EI.begin() ; it != m_EI.end() ; it ++)
    {
        m_fenetre->draw(**it);
    }
 
}
 
void Afficheur::efface(EI *eI)
{
    for(multiset<EI*>::iterator it = m_EI.begin() ; it != m_EI.end() ; it ++)
    {
       if(*it == eI)
       {
            m_EI.erase(it);
            it = m_EI.begin();
       }
    }
 
}
 
void Afficheur::vide()
{
    m_EI.clear();
}
 
 
sf::RenderWindow*   Afficheur::renvoiFenetre()
{
    return m_fenetre;
}
 
boost::shared_ptr<sf::Event>   Afficheur::renvoiPtrEvent()
{
    return m_ptr_event;
}
 
Vue*  Afficheur::renvoiVue()
{
    return &m_vue;
}
 
float Afficheur::renvoiDeltaTemps()
{
    return m_deltaTemps ;
}
 
bool Afficheur::renvoiTemps()
{
    return m_temps;
}

merci pour l'aide

[Daïmanu]

@Daïmanu: Étrange que tu ais eu des problèmes, il y a une problématique avec unique_ptr et le destructeur (dans une situation "par défaut") quand tu utilises un type incomplet, mais ce n'est pas le cas que tu sembles avoir vécu (quoique).

En fait c'était dans le cas d'un couple pimpl idiom / unique_ptr où le destructeur, selon gcc, doit être déclaré et défini dans la classe qui possède l'unique_ptr<Impl> pimpl, donc c'ést précisément un type incomplet

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
10
11
12
13
 
void Afficheur::efface(EI *eI)
{
    for(multiset<EI*>::iterator it = m_EI.begin() ; it != m_EI.end() ; it ++)
    {
       if(*it == eI)
       {
            m_EI.erase(it);
            it = m_EI.begin();
       }
    }
 
}

Cette fonction me parait étrange, si tu changes it = m_EI.begin(); par it++; qu'est-ce qui se passe ?

[Flob90]

Fais une exécution pas à pas, ça devrait permettre d'avancer pour localiser le problème.

@Daïmanu: C'est Impl qui est incomplet ? Parce que si c'est le cas, peu importe ce que dit gcc, ton code est et reste mauvais peu importe ce que tu fais aux destructeurs (celui de Impl ou de la classe englobante ?).

[dragonjoker59]

Cette fonction me parait étrange, si tu changes it = m_EI.begin(); par it++; qu'est-ce qui se passe ?

Ca plantera.
Sa boucle est correcte, même si je ne l'aurais pas écrite comme ça.

EDIT :

En fait la boucle est effectivement incorrecte mais pas pour la même raison :
Tu effaces un élément, puis tu te places sur begin, puis tu fais ++.
Au final, je crois qu'il restera un élément non testé dans ta liste.
Tu as un multiset, pourquoi ne pas utiliser la fonction find ?

[mazertys17]

Je confirme que ca vient bien de l'Afficheur/*EI, car si j'enlève ca:

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
 
 
    m_ptr_afficheur->recoitEI(&m_EI);

et que je detruit l'objet, pas de plantage...Mais du coup plus d'affichage non plus, forcément...

Devrais-je transformer ca:

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
 
 
class Afficheur
{
public:
 
   ...
    void                               recoitEI(EI* entiteImage);
   ...
 
private:
 
   ...
    std::multiset<EI*>, MonFoncteur>    m_EI;
   ...

en ca :

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
 
 
class Afficheur
{
public:
 
   ...
    void                               recoitEI(boost::share_ptr<EI> entiteImage);
   ...
 
private:
 
   ...
    std::multiset<boost::share_ptr<EI>, MonFoncteur>    m_EI;
   ...

selon vous ?

[mazertys17]

Merci, DragonJoker59 pour ta réponse.

je viens d'essayer en changeant :

dans l'afficheur :

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
10
11
 
 
 
void Afficheur::efface(EI *eI)
{
 
    std::multiset<EI*>::iterator it ;
    it =  m_EI.find(eI);
    m_EI.erase(it);
 
}

mais ca plante carrément sans raisons...En même temps, ca m'étonerais que ca vienne de cette fonction "efface" de l'Afficheur, puisque je l'utilise a chaque frame par mon objet Mouvant afin d'actualiser son classement par rapport au zOrder et que ca marchais très bien :

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
 
 
    m_ptr_afficheur->efface(&m_EI);
    m_ptr_afficheur->recoitEI(&m_EI);

sinon j'ai essayé sur mon objet ceci aussi :

m_charbonPetit2.erase(it);
it = m_charbonPetit2.begin() ;

par

m_charbonPetit2.erase(it);
it = m_charbonPetit2.end() ;

pour voir si va venait du fait qu'il repartait sur begin. Il plante toujours, mais le message n'est plus le exactement le même:

"assertion failed: px != 0, file.../program Files <x86>/Codeblock/boost_1_57_0/boost/smart_ptr/shared_ptr.hpp, line648 "

il me semble que c'est un pb d'allocation de memoire, nan?

[Flob90]

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
 
m_EI.erase(eI);

Edit: En faite non, tu as changé le comparateur, ça va pas marcher.

[mazertys17]

je viens d'essayer en changeant :

dans l'afficheur :

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
 
void Afficheur::efface(EI *eI)
{
 
    std::multiset<EI*>::iterator it ;
    it =  m_EI.find(eI);
    m_EI.erase(it);
 
}

mais ca plante carrément sans raisons...En même temps, ca m'étonerais que ca vienne de cette fonction "efface" de l'Afficheur, puisque je l'utilise a chaque frame par mon objet Mouvant afin d'actualiser son classement par rapport au zOrder et que ca marchais très bien :

Code :Sélectionner tout - Visualiser dans une fenêtre à part

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
 
 
    m_ptr_afficheur->efface(&m_EI);
    m_ptr_afficheur->recoitEI(&m_EI);

ps : je viens d'essayer :

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
 
 
    m_EI.erase(eI);

ca donne carrément des résultats étonnant: ca supprime d'un coup une rangé de "CharbonPetit2", sans que j'ai rien demandé, et mon objet Mouvant, qui l'utilise a chaque frame, devient super opaque( il recharge autant de fois la même image transparente )...pour planter exactement comme d'habitude...

[Flob90]

Et l’exécution pas à pas ?