utilisation de pointeur Intelligent

**mazertys17** · 06/01/2015, 10h32

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** · 06/01/2015, 11h10

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** · 06/01/2015, 11h37

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** · 06/01/2015, 11h52

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** · 06/01/2015, 12h30

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** · 06/01/2015, 14h00

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;
   }
};

utilisation de pointeur Intelligent

C++

Vue hybride

Discussions similaires

Partager

Partager