Constructeur/Destructeur, regles de codage

Version imprimable

Bonjour,

J'ai un probleme de compréhension au niveau des constructeur/destructeur.

J'ai un main ainsi qu'une classe (donc un .h et un .cpp).

Asteroid.h

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
 
#ifndef ASTEROID_H
#define ASTEROID_H
 
#include <SDL/SDL.h>
#include <SDL/SDL_ttf.h>
#include <vector>
 
#include "constantes.h"
#include "Ressource.h"
 
 
class Asteroid
{
/******************  o--------------o  ********************
*******************  |   Methodes   |  ********************
*******************  o--------------o  *******************/
 
    public:
 
    /* Constructeur et destructeur */
    Asteroid(Ressource *ListeRessource,
             int niveau,
             std::string typeAsteroid,
             int positionX,
             int positionY,
             float directionX,
             float directionY,
             float vitesseDeplacement
             );
    ~Asteroid();
 
 
 
/******************  o---------------o  ********************
*******************  |   Attributs   |  ********************
*******************  o---------------o  *******************/
 
    protected:
 
    std::string m_typeAsteroid;
 
    int m_niveau;
 
    int m_pointDeVie;
 
    int m_nombreDeSprite;
    std::vector<SDL_Surface*> m_image;
    float m_vitesseRotation;
    float m_indice;
 
    float m_positionX;
    float m_positionY;
 
    float m_directionX;
    float m_directionY;
    float m_vitesseDeplacement;
 
};
 
#endif

Asteroid.cpp

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
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
 
#include "Asteroid.h"
 
using namespace std;
 
 
Asteroid::Asteroid(Ressource *ListeRessource,
                   int niveau,
                   string typeAsteroid,
                   int positionX,
                   int positionY,
                   float directionX,
                   float directionY,
                   float vitesseDeplacement
                   )
{
    /* Toujours Fixe */
    m_indice = 0;
 
 
    /* Determiné lors de la construction */
    m_niveau = niveau;
 
    m_typeAsteroid = typeAsteroid;
 
    m_positionX = positionX;
    m_positionY = positionY;
 
    m_directionX = directionX;
    m_directionY = directionY;
 
    m_vitesseDeplacement = vitesseDeplacement;
 
 
 
    /* Determiné aleatoirement */
 
 
 
    /* La robustesse est determiné aleatoirement entre 20 et 86
       selon le niveau.
       Cependant, en fonction du type de l'Asteroid, la robustesse
       de l'Asteroid sera réevaluer. */
    switch (m_niveau)
    {
        case 1:
            /* L'asteroid le plus petit - Sa robustesse est comprise entre 20 et 33 */
            m_pointDeVie = static_cast<int> (20 + (static_cast<float>( rand()) / RAND_MAX * 14));
            break;
 
        case 2:
            /* L'Asteroid moyen - Sa robustesse est comprise entre 40 et 57 */
            m_pointDeVie = static_cast<int> (40 + (static_cast<float>( rand()) / RAND_MAX * 18));
            break;
 
        case 3:
            /* Le plus gros des asteroid - Sa robustesse est comprise entre 60 et 86 */
            m_pointDeVie = static_cast<int> (60 + (static_cast<float>( rand()) / RAND_MAX * 27));
            break;
 
        default:
            /* On met le niveau à 1 afin de ne pas faire planter le programme mais on le signal */
            m_niveau = 1;
            m_pointDeVie = 1;
            cerr << "Probleme lors de la creation d'un asteroid : niveau de l'Asteroid incorrect." << endl;
            break;
    }
 
    if (m_typeAsteroid == "Asteroid Molybdene")
        /* Resistance acrue de 10 à 15 point de vie */
        m_pointDeVie += static_cast<int> (10 + (static_cast<float>( rand()) / RAND_MAX * 6));
    else
        if (m_typeAsteroid == "Asteroid Strontium")
            /* Resistance acrue de 20 à 25 point de vie */
            m_pointDeVie += static_cast<int> (25 + (static_cast<float>( rand()) / RAND_MAX * 6));
        else
            if (m_typeAsteroid == "Asteroid Rubidium")
                /* Resistance acrue de 60 à 85 point de vie */
                m_pointDeVie += static_cast<int> (60 + (static_cast<float>( rand()) / RAND_MAX * 26));
 
 
 
    /* La vitesse absolue est comprise entre 25 et 65 Image/Seconde */
    m_vitesseRotation = static_cast<int>(25 + (static_cast<float>( rand()) / RAND_MAX * 41))/static_cast<float>(FPS);
    if (static_cast<int>(static_cast<float>( rand()) / RAND_MAX * 2))
        m_vitesseRotation = -m_vitesseRotation;
 
    /* On "pioche" au hasard une animation
       Cette pioche indique la valeur de nombreDeSprite et donc d'image */
   int ligne = 0, colonne = 0;
 
    switch (static_cast<int> (1 + static_cast<float>( rand()) / RAND_MAX *  20))
    {
        /* Animation contenant juste un sprite (10% de probabilité) */
        case 1:
        case 2:
            ligne = static_cast<int> (static_cast<float>( rand()) / RAND_MAX * 45);
            colonne = static_cast<int> (static_cast<float>( rand()) / RAND_MAX * 29);
 
            m_nombreDeSprite = 1;
            m_image.resize(m_nombreDeSprite, NULL);
 
            m_image[0] = ListeRessource->GetSprite(m_typeAsteroid, ligne + ((m_niveau-1)*45), colonne);
 
            m_vitesseRotation = 0;
            break;
 
        /* Animation plutot moche (5% de probabilité) */
        case 3:
            colonne = static_cast<int> (static_cast<float>( rand()) / RAND_MAX * 29);
 
            m_nombreDeSprite = 45;
            m_image.resize(m_nombreDeSprite, NULL);
 
            for (int i=0 ; i<m_nombreDeSprite ; i++)
                m_image[i] = ListeRessource->GetSprite(m_typeAsteroid, i+((m_niveau-1)*45), colonne);
 
            break;
 
        /* Animation plutot bien (40% de chance) */
        case 4: case 5: case 6: case 7: case 8: case 9: case 10: case 11:
 
            ligne = static_cast<int> (static_cast<float>( rand()) / RAND_MAX * 45);
 
            m_nombreDeSprite = 29;
            m_image.resize(m_nombreDeSprite, NULL);
 
            for (int i=0 ; i<m_nombreDeSprite ; i++)
                m_image[i] = ListeRessource->GetSprite(m_typeAsteroid, ligne + ((m_niveau-1)*45), i);
 
            break;
 
        default:
            int pas = static_cast<int> (1 + static_cast<float>( rand()) / RAND_MAX * 28);
 
            m_nombreDeSprite = 1305 * pas;
 
            m_image.resize(m_nombreDeSprite, NULL);
 
            int positioncourante = 0;
 
            for (int i=0 ; i<1305 ; i++)
                for (int j=0 ; j<pas ; j++)
                {
                    m_image[positioncourante] = ListeRessource->GetSprite(m_typeAsteroid, (i%45) + ((m_niveau-1)*45), positioncourante%29);
                    positioncourante++;
                }
            break;
    }
 
}
 
 
Asteroid::~Asteroid()
{
    /* En realité, le destructeur ne sert a rien car
       ON NE LIBERE PAS LES SURFACE
       La classe Ressource s'en occupe */
 
    cout << "Un asteroid vient d'etre detruit" << endl;
 
}

et voici mon main

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
 
#include <SDL/SDL_ttf.h>
#include <SDL/SDL.h>
#include <iostream>
 
#include "constantes.h"
 
#include "Asteroid.h"
 
 
 
using namespace std;
 
int main( int argc, char** argv )
{
 
   /* ... */
 
    /* Creation de la liste d'Asteroid */
    list<Asteroid> ListeAsteroid;
 
 
 
    /* Les asteroid */
    ListeAsteroid.push_back( Asteroid(&ListeRessource, 3, "Asteroid Strontium", 80, 400, cos(63 * M_PI/180), sin(63 * M_PI/180), 5) );
 
 
    // Iterateur de liste d'Asteroid
    std::list<Asteroid>::iterator AsteroidCourant;
 
    AsteroidCourant = ListeAsteroid.begin();
    //AsteroidCourant = ListeAsteroid.erase(AsteroidCourant);
 
    cout << "debut boucle jeu" << endl;
 
   /* ... */
 
    return EXIT_SUCCESS;
}

J'ai volontairement occulté beaucoup de code.
Dans le destructeur de la class Asteroid, j'ai mis

Code:

1
2
 
cout << "Un asteroid vient d'etre detruit" << endl;

afin de savoir quand un asteroid est detruit.

Je lance mon programme, je regarde mon fichier de sortie et obtiens ceci :

Citation:

Un asteroid vient d'etre detruit
debut boucle jeu
Un asteroid vient d'etre detruit

Voici donc (enfin) mes questions :

* J'instancie les asteroid avant "debut boucle jeu" et les detruit apres.
Pourquoi mon destructeur est appelé avant "debut boucle jeu" ?

* J'avais lu lors d'une recherche sur ce probleme que le compilateur semblait instancier une class temporaire si, dans le constructeur, un variable membre etait utilisé sans pour autant avoir été initialisé. J'ai donc fait attention a éviter ce cas-ci, mais peut etre ai-je fait une erreur.

* Je voudrais savoir s'il existe des regle precise lors du codage d'un constructeur et d'un destructeur (par exemple, ne pas faire d'aleatoire)

* J'ai vu que l'on utilisé .hpp lors d'un projet en C++. Or, j'ai nommé le mien .h.
Quelle en sont les consequence ?

* J'aimerai si possible avoir des critique sur mon constructeur (je sais que beaucoup utilise les liste d'initialisation).

Merci de votre patience et de votre lecture.

29/07/2009, 18h56
ram-0000
Je pense que dans ce bout de code avant ta boucle de jeu
Code:

1 2 /* Les asteroid */ ListeAsteroid.push_back( Asteroid(&ListeRessource, 3, "Asteroid Strontium", 80, 400, cos(63 * M_PI/180), sin(63 * M_PI/180), 5) );
tu crées un objet temporaire dont une copie qui va être empilée dans la liste et ensuite l'objet temporaire est détruit d'où ton message.
29/07/2009, 19h13
SofEvans

C'est exact :ccool:

A vrai dire, je voudrait pouvoir creer autant d'asteroid que l'utilisateur le demande, d'ou l'utilisation de list::
Comment faire eviter la creation de l'objet temporaire ?
29/07/2009, 19h27
ram-0000

En gérant une liste de pointeurs sur Asteroid.

Tu crées autant d'Asteroid que tu veux avec new et tu empiles les pointeur dans ta liste et en plus comme cela, tu pourras bénéficier du polymorphisme vu que c'est un pointeur.

De plus, plutôt que d'avoir des pointeurs nus dans ta liste, tu peux utiliser les pointeurs intelligents de boost par exemple.
29/07/2009, 19h36
SofEvans
Citation:

Envoyé par ram-0000

En gérant une liste de pointeurs sur Asteroid.

Tu crées autant d'Asteroid que tu veux avec new et tu empiles les pointeur dans ta liste.

Oki, je vais m'atteler a ça.

Citation:

Envoyé par ram-0000

De plus, plutôt que d'avoir des pointeurs nus dans ta liste, tu peux utiliser les pointeurs intelligents de boost par exemple.

Hein 8O ? Encore une notion qui me manque ... :calim2:

Merci pour tes conseil, je vais tacher de me degoter 2~3 tutos ou lien.

Juste une chose, pourquoi
Code:

1 2 ListeAsteroid.push_back( Asteroid(&ListeRessource, 1, "Asteroid Strontium", 2, 4, cos(1 * M_PI/180), sin(1 * M_PI/180), 3) );
fait-il un objet temporaire ?
est-ce parce que j'appel le constructeur de la class asteroid directement ?
29/07/2009, 19h43
ram-0000
Citation:

Envoyé par SofEvans

Encore une notion qui me manque ... :calim2:

regarde ici : Gérer ses ressources de manière robuste en C++
Citation:
Envoyé par SofEvans

Juste une chose, pourquoi

Code:

1 2 ListeAsteroid.push_back( Asteroid(&ListeRessource, 1, "Asteroid Strontium", 2, 4, cos(1 * M_PI/180), sin(1 * M_PI/180), 3) );

fait-il un objet temporaire ?
est-ce parce que j'appel le constructeur de la class asteroid directement ?
Probablement et puis aussi parce ue l'insertion dans une liste se fait en utilisant le constructeur de recopie
29/07/2009, 21h41
SofEvans

Merci pour le lien, va falloir que je vois ça de près.

Pour l'instant, ya pas trop de probleme.

Encore merci ram - 0000

Je rencontre a nouveau un probleme pour le moins .... #!%~é"

Voila, sur les bon conseil de ram - 0000, j'ai crée un conteneur list de pointeur d'asteroid.
J'alloue plusieur asteroid et effectivement, je ne vois plus d'appel intempestif au destructeur. Sauf que je n'arrive vraiment plus a appeler le destructeur ! :aie: ><

Code:

1
2
3
4
5
6
7
8
9
10
11
12
13
 
 
    /* Creation de la liste de pointeur d'Asteroid */
    list<Asteroid*> ListeAsteroid;
 
    /* Les asteroid */
    ListeAsteroid.push_back( new Asteroid(&ListeRessource, 3, "Asteroid Strontium", 80, 400, cos(63 * M_PI/180), sin(63 * M_PI/180), 5) );
    ListeAsteroid.push_back( new Asteroid(&ListeRessource, 3, "Asteroid Rubidium", 600, 400, cos(163 * M_PI/180), sin(163 * M_PI/180), 2) );
    ListeAsteroid.push_back( new Asteroid(&ListeRessource, 2, "Asteroid Molybdene", 200, 430, cos(13 * M_PI/180), sin(13 * M_PI/180), 1) );
 
 
    // Iterateur de liste d'Asteroid
    std::list<Asteroid*>::iterator AsteroidCourant;

Si je fais un new, c'est forcement que je dois faire un delete.

Mais je ne sais pas comment le faire !

Si une bonne âme pouvait m'indiquer la marche a suivre ...

EDIT

J'ai enfin reussi qT.Tp

La reponse etait plutot simple mais ce faisait en deux temps.

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
 
    /* Creation de la liste de pointeur d'Asteroid */
    list<Asteroid*> ListeAsteroid;
 
    /* Les asteroid */
    ListeAsteroid.push_back( new Asteroid(&ListeRessource, 3, "Asteroid Strontium", 80, 400, cos(63 * M_PI/180), sin(63 * M_PI/180), 5) );
    ListeAsteroid.push_back( new Asteroid(&ListeRessource, 3, "Asteroid Rubidium", 600, 400, cos(163 * M_PI/180), sin(163 * M_PI/180), 2) );
    ListeAsteroid.push_back( new Asteroid(&ListeRessource, 2, "Asteroid Molybdene", 200, 430, cos(13 * M_PI/180), sin(13 * M_PI/180), 1) );
    ListeAsteroid.push_back( new Asteroid(&ListeRessource, 1, "Asteroid Rubidium", 200, 50, cos(43 * M_PI/180), sin(43 * M_PI/180), 2.8) );
    ListeAsteroid.push_back( new Asteroid(&ListeRessource, 3, "Asteroid Krypton", 20, 400, cos(16 * M_PI/180), sin(16 * M_PI/180), 3.6) );
    ListeAsteroid.push_back( new Asteroid(&ListeRessource, 3, "Asteroid Molybdene", 2, 400, cos(0 * M_PI/180), sin(0 * M_PI/180), 10) );
    ListeAsteroid.push_back( new Asteroid(&ListeRessource, 2, "Asteroid Rubidium", 200, 40, cos(86 * M_PI/180), sin(86 * M_PI/180), 0.6) );
    ListeAsteroid.push_back( new Asteroid(&ListeRessource, 3, "Asteroid Krypton", 20, 40, cos(325 * M_PI/180), sin(325 * M_PI/180), 1) );
    ListeAsteroid.push_back( new Asteroid(&ListeRessource, 1, "Asteroid Strontium", 2, 4, cos(1 * M_PI/180), sin(1 * M_PI/180), 3) );
 
    /* Iterateur de liste d'Asteroid initialiser au debut */
    std::list<Asteroid*>::iterator AsteroidCourant = ListeAsteroid.begin();
 
    /* Boucle permettant de liberer l'espace allouer et de vider le tableau */
    while (ListeAsteroid.empty() == false)
    {
        delete (*AsteroidCourant);
        AsteroidCourant = ListeAsteroid.erase(AsteroidCourant);
    }

30/07/2009, 02h19
Goten

Si tu veux pas te trimballer de pointeur intelligent, (pourtant l'effort à consacrer pour les apprendre vaut vraiment le coup) alors il serait intéressant de stocker ces pointeurs dans un container approprié, boost en fourni. (ptr_container il me semble).
Sinon pour le problème direct :
http://cpp.developpez.com/faq/cpp/in...elete_sequence