Discussion :

[guitz]

Bonjour,


Voici ma classe Ball dans ball.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
class Ball
{
	public:
		Ball(int id, int radius, int x, int y, float velocity_x, float velocity_y);
 
		~Ball();
 
		void move_(int l_left, int l_top, int l_right, int l_bot); // les limites gauche, haut, droite, bas 
		void collision(Ball** balls);
 
                const static int s_num_balls = 10;
                static bool s_collision;
                static int s_num_collisions;
		static int s_min_velocity;
		static int s_max_velocity;
 
        int m_id;
		int m_radius;
		int m_x;
		int m_y;
		double m_velocity_x;
		double m_velocity_y;
		double m_accel_x;
		double m_accel_y;
 
    private:
 
        void free();
};

Je crée dynamiquement des instances de classe ainsi dans main.cpp :

Code :

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

1
2
3
for(int i=0; i<Ball::s_num_balls; i++){
      balls[i] = new Ball(...);
}

Voici le destructeur vide de ma classe Ball :

Code :

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

1
2
3
4
Ball::~Ball() //destructeur
{
	//delete this;
}

Et voici la fonction close() dans main.cpp

Code :

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

1
2
3
4
5
6
7
8
void close()
{
    for(int i=0; i<Ball::s_num_balls; i++){
        delete balls[i];
    }
 
    ...
}

Est-ce que je m'y prends bien pour libérer la mémoire occupée par chaque objet Ball lors de sa déstruction ?

Merci

[foetus]

Je ne vois rien de choquant mais pourquoi tu ne crées pas une classe Ball_Util (<- nom douteux)

Je me demande même si delete[] n'appelle pas tous les destructeurs respectifs

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
class Ball_Util {
public:
 
    Ball_Util() : num_balls(0) { /* ... */ }
 
    ~Ball_Util() {
//  Version if array_balls is a C-array
        for(int nb=0; nb < num_balls; nb++){
            delete array_balls[nb];
            array_balls[nb] = NULL;
        }
    }
 
    void add_ball(Ball& ) { /* ... */ }
    void add_multi_balls(vector<Ball>& ) { /* ... */ }
 
//  void operator+ (Ball& ) { /* ... */ } // Or a non-member version
 
    void test_collisions() { /* ... */ }
 
private: /*protetected:*/
 
    Ball* array_balls;
//  vector<Ball> array_balls;
 
private: /*protetected:*/
 
    int num_balls;
    bool collision;
    int num_collisions;
    int min_velocity;
    int max_velocity;
};

Édit: Médinoc a raison , mais c'est du code vite-fait pour montrer qu'on peut concevoir de manière à éviter 2-3 trucs comme des variables statiques dans chaque balle.

[Médinoc]

La classe, je l'appellerais probablement ball_collection ou bien ball_manager.

Code :

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

void add_ball(Ball& ) { /* ... */ }

Ta fonction add_ball(), si elle prend une référence en paramètre, elle a intérêt à faire une copie de l'objet, et non en prendre possession.

---

@guitz: Ta fonction membre collision() devrait retourner un Booléen plutôt que jouer avec une variable globale. De plus, elle devrait probablement être déclarée const, ainsi que son paramètre, si la détection de collision n'est pas censée modifier les balles.

[r0d]

Problème: éviter fuites mémoires. (titre du fil)
Solution: Ne pas utiliser de pointeur.

Hope it helps.

[ternel]

C'est vrai que les pointeurs nus sont la source première de fuites mémoires.
S'en passer autant que possible au profit des références et du RAII réduit considérablement le risque.

pour rappel, le RAII de pointeur est std::unique_ptr et std::share_ptr.

[Ehonn]

Pourquoi tu n'utilises pas std::vector dans ton code ?

Grosso modo, pour ne pas avoir de fuites mémoires, il suffit de ne pas utiliser directement l'allocation dynamique.