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 : 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
 
#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 : 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
 
#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 : 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
 
#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 : Sélectionner tout - Visualiser dans une fenêtre à part
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 :


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.