attribut membre d'objet de classe

Version imprimable

Bonjour,

J'ai tout essayé pendant un long moment mais je ne suis parvenu à comprendre pourquoi ça ne marche pas.

dans Ball.h :

Code:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
#pragma once
class Ball {
 
public:
 
	Ball( int posX, int PosY, int speedX, int speedY);
	~Ball( void );
 
	int m_x;
	int m_y;
	int m_speedX;
	int m_speedY;
 
	static Ball *balls[2];
 
	void updateBall(int posX, int PosY);
 
};

Dans Ball.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
#include "Ball.h"
 
Ball * Ball::balls[2] = {0};
 
// build / destruct -------------------------------------------------------------------------
 
Ball::Ball( int posX, int posY, int speedX, int speedY)
{
	m_x = posX;
	m_y = posY;
	m_speedX = speedX;
	m_speedY = speedY; 
}
 
 
Ball::~Ball(void)
{
	//OutputDebugString("destruction ball\n");
}
 
void Ball::updateBall(int posX, int posY){
	m_x = posX;
	m_y = posY;
}

Et enfin dans le main.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
#include <math.h>
#include "Ball.h"
 
...
...
 
Ball::balls[0] = new Ball((int)(-SCREEN_WIDTH/2+50), (int)(-SCREEN_HEIGHT/2+50), 10, 10);
Ball::balls[1] = new Ball(0, 0, 10, 10);
 
...
...
 
void HeartGame::routine () {
 
	{
 
		for(int i=0; i<=1; i++){ //On boucle sur toutes les billes
 
			Ball *b = Ball::balls[i];
 
			//b->updateBall(b->m_x + x, b->m_y + x);
 
			b->updateBall(b->m_x + b->m_speedX, b->m_y + b->m_speedY);
 
			HeartGraphics::drawSmallSprite( b->m_x , b->m_y, 0, 0 );
 
		} 
 
 
	}
 
}
 
...
...

Je précise que dans main.cpp si j'incrémente une variable x dans la routine :

Code:

HeartGraphics::drawSmallSprite( x , x, 0, 0 );

Les 2 balles se déplacent bien en diagonales, alors que dans le code posté plus haut les 2 balles restent fixes.
A votre avis pourquoi m_x et m_y ne sont pas mis à jour à chaque frame ?

Merci

02/03/2014, 22h36
Iradrille
Hello,

Code:

static Ball *balls[2];

C'est moche, pour plusieurs raisons :
- pourquoi est-ce que c'est statique ?
- pourquoi est-ce que c'est dans la classe Ball ?
- préfères les std::array aux tableaux C style.
- maintenir un tableau (vector ? :)) de Ball est valable (non statique et dans une autre classe), mais quelle est la motivation pour avoir un tableau de pointeur ?

Pour l'erreur par contre je ne vois pas
Code:

1 2 3 4 void HeartGame::routine () { { for(int i=0; i<=1; i++){ //On boucle sur toutes les billes // ...
Ces doubles accolades + double indentation laisse penser qu'un morceau de code à été supprimé. Le problème peut venir de ce morceau de code manquant.

Code:

b->updateBall(b->m_x + b->m_speedX, b->m_y + b->m_speedY);

pourquoi ne pas simplement faire
Code:

1 2 b->m_x += b->m_speedX; b->m_y += b->m_speedY;
vu que les attributs sont publiques.
(Il faut prendre en compte le temps écoulé aussi, sinon la vitesse de déplacement dépendra du framerate).
02/03/2014, 22h54
guitz
Bonsoir Iradrille,

Merci pour ta réponse.

Citation:

C'est moche, pour plusieurs raisons :
- pourquoi est-ce que c'est statique ?
- pourquoi est-ce que c'est dans la classe Ball ?
- préfères les std::array aux tableaux C style.
- maintenir un tableau (vector ? ) de Ball est valable (non statique et dans une autre classe), mais quelle est la motivation pour avoir un tableau de pointeur ?

L'idée du statique c'est de créer une sorte de tableau global avec un "Ball::" devant pour clarifier le code (on sait que ça concerne les balls)

C'est dans la classe Ball car je croyais qu'il fallait creéer les variables statiques dans la classe en question

Merci pour le conseil des std::array, je vais l'appliquer

J'ai pas utilisé un vector car à l'avenir le nombre de billes sera constant (pas d'allocation dynamique ni de désalocation à gerer, les balls non utilisées seront placées en dehors de la scène.
J'ai utilisé un tableau de pointeurs car chaque objet est une adresse, donc un pointeur de type Ball *

Je viens d'essayer ce que tu mas conseillé :
Code:

1 2 3 4 5 6 ... b->m_x += b->m_speedX; b->m_y += b->m_speedY; HeartGraphics::drawSmallSprite( b->m_x , b->m_y, 0, 0 ); ...
ça ne marche pas, c'est ce que j'avais essayé en premier, le "+=" se comporte comme un "=" . C'est vraiment étrange

Merci

Citation:

Envoyé par guitz

L'idée du statique c'est de créer une sorte de tableau global avec un "Ball::" devant pour clarifier le code (on sait que ça concerne les balls)

Si ce tableau à un gros rôle dans l'appli alors fais en une classe, sinon le tableau se retrouvera dans une autre classe (attribut d'une classe "Scene" par exemple).

Citation:

Envoyé par guitz

J'ai utilisé un tableau de pointeurs car chaque objet est une adresse, donc un pointeur de type Ball *

Il n'y à ici pas d'intérêt : Ball n'est pas une classe héritée, il n'y à pas de polymorphisme.
un std::array<Ball, 2> balls; est plus adapté ici.

par exemple

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
class Ball {
public:
     int x, y, speedX, speedY;
     void update(float dt) {
          x += speedX * dt;
          y += speedY * dt;
      }
      Ball() { }
      Ball(int x, int y, int sx, int sy) : x(x), y(y), speedX(sx), speedY(sy) { }
      Ball(const Ball& b) : x(b.x), y(b.y), speedX(b.speedX), speedY(b.speedY) { }
      Ball& operator=(const Ball& b) {
          x = b.x;
          y = b.y;
          speedX = b.speedX;
          speedY = b.speedY;
          return *this;
      }
};
 
class BallArray {
public:
   typedef std::array<Ball, 2> array_type;
   typedef array_type::const_iterator const_iterator;
 
   void updateBall(unsigned int n, float dt) {
       if(n < m_array.size()) {
           m_array[n].update(dt);
       }
    }
    void updateAllBall(float dt) {
        for(auto& b: m_array) {
             b.update(dt);
         }
     }
 
     const_iterator begin() const { return m_array.begin(); }
     const_iterator end() const { return m_array.end(); }
 
private:
     array_type m_array;
};
 
class HeartGame {
public:
     void HeartGame::routine () {
           m_balls.updateAllBall(/* dt */);
           std::foreach(m_balls.begin, m_balls.end(), [](const Ball& b) {
                HeartGraphics::drawSmallSprite(b.x, b.y, 0, 0 );
           }
     }
 
private:
     BallArray m_balls;
};

03/03/2014, 00h26
Bousk

Bonsoir,

je vois à peu près rien qui empêcherait les balles de bouger dans ce code.
Il nous manquerait pas du code par hasard ? Parce qu'en l'état, je suis quasiment certain qu'en compilant ça, ça bougerait.
03/03/2014, 10h13
skeud

Citation:

Envoyé par guitz

Les 2 balles se déplacent bien en diagonales, alors que dans le code posté plus haut les 2 balles restent fixes.
A votre avis pourquoi m_x et m_y ne sont pas mis à jour à chaque frame ?

Il y a que moi que ça choc? Il dit que les deux balles se déplacent bien en diagonale, c'est le but non?
Et c'est conforme avec le code.

Je comprends pas quelle erreur il y a en fait :mouarf:.
03/03/2014, 13h46
Bousk

Oui, quand il utilise une variable x qu'il incrémente dans cette fonction, pas quand il utilise m_X + m_speedX
03/03/2014, 21h54
guitz

Citation:

Envoyé par skeud

Il y a que moi que ça choc? Il dit que les deux balles se déplacent bien en diagonale, c'est le but non?
Et c'est conforme avec le code.

Je comprends pas quelle erreur il y a en fait :mouarf:.

Bonjour skeud, j'ai passé un temps fou à essayer de comprendre pourquoi ça marche pas, je suppose maintenant que cest le fait d'avoir créer un tableau statique dans ma classe ball et dy avoir stocké des objets de type ball à lintérieur qui fait bugger. Je ne saurai expliquer pourquoi mais c'est la seule explication possible, voilà pourquoi je vais opter pour un code plus propre conseillé par Iradrille

Citation:

Envoyé par Iradrille

Si ce tableau à un gros rôle dans l'appli alors fais en une classe, sinon le tableau se retrouvera dans une autre classe (attribut d'une classe "Scene" par exemple).

Il n'y à ici pas d'intérêt : Ball n'est pas une classe héritée, il n'y à pas de polymorphisme.
un std::array<Ball, 2> balls; est plus adapté ici.

par exemple

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
class Ball {
public:
     int x, y, speedX, speedY;
     void update(float dt) {
          x += speedX * dt;
          y += speedY * dt;
      }
      Ball() { }
      Ball(int x, int y, int sx, int sy) : x(x), y(y), speedX(sx), speedY(sy) { }
      Ball(const Ball& b) : x(b.x), y(b.y), speedX(b.speedX), speedY(b.speedY) { }
      Ball& operator=(const Ball& b) {
          x = b.x;
          y = b.y;
          speedX = b.speedX;
          speedY = b.speedY;
          return *this;
      }
};
 
class BallArray {
public:
   typedef std::array<Ball, 2> array_type;
   typedef array_type::const_iterator const_iterator;
 
   void updateBall(unsigned int n, float dt) {
       if(n < m_array.size()) {
           m_array[n].update(dt);
       }
    }
    void updateAllBall(float dt) {
        for(auto& b: m_array) {
             b.update(dt);
         }
     }
 
     const_iterator begin() const { return m_array.begin(); }
     const_iterator end() const { return m_array.end(); }
 
private:
     array_type m_array;
};
 
class HeartGame {
public:
     void HeartGame::routine () {
           m_balls.updateAllBall(/* dt */);
           std::foreach(m_balls.begin, m_balls.end(), [](const Ball& b) {
                HeartGraphics::drawSmallSprite(b.x, b.y, 0, 0 );
           }
     }
 
private:
     BallArray m_balls;
};

Bonsoir Iradrille,

Un grand merci pour ton code, je l'ai copié collé dans mon projet et essaie de le comprendre :

Pour la classe Ball :

Code:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
class Ball {
public:
     int m_x, m_y, m_speedX, m_speedY;
     void updatePos(void) {
          m_x += m_speedX;
          m_y += m_speedY;
      }
      Ball() { }
      Ball(int x, int y, int sx, int sy) : m_x(x), m_y(y), m_speedX(sx), m_speedY(sy) { }
      Ball(const Ball& b) : x(b.x), y(b.y), speedX(b.speedX), speedY(b.speedY) { }
      Ball& operator=(const Ball& b) {
          x = b.x;
          y = b.y;
          speedX = b.speedX;
          speedY = b.speedY;
          return *this;
      }
};

Code:

Ball() { }

Pourquoi ceci juste avant le constructeur ?

Code:

Ball(int x, int y, int sx, int sy) : m_x(x), m_y(y), m_speedX(sx), m_speedY(sy) { }

Ok c'est le constructeur mais je croyais qu'il fallait mettre le prototype du constructeur dans Ball.h et le corps dans Ball.cpp
Or là tu mets tout en un, pourquoi ?

Code:

1
2
3
4
5
6
7
8
Ball(const Ball& b) : x(b.x), y(b.y), speedX(b.speedX), speedY(b.speedY) { }
      Ball& operator=(const Ball& b) {
          x = b.x;
          y = b.y;
          speedX = b.speedX;
          speedY = b.speedY;
          return *this;
      }

Désolé mais je ne comprends pas ce code

Citation:

Envoyé par guitz

Code:

Ball() { }

Pourquoi ceci juste avant le constructeur ?

C'est un constructeur par défaut : un constructeur qui ne prend aucun paramètre.

Citation:

Envoyé par guitz

Ok c'est le constructeur mais je croyais qu'il fallait mettre le prototype du constructeur dans Ball.h et le corps dans Ball.cpp
Or là tu mets tout en un, pourquoi ?

C'est effectivement préférable (bien que discutable dans le cas de fonctions aussi courtes).
Les deux sont possibles, mais c'est plus compréhensible comme ça (sur le forum, je ne séparerai jamais déclaration et définition).
Citation:
Envoyé par guitz
Code:

1 2 3 4 5 6 7 8 Ball(const Ball& b) : x(b.x), y(b.y), speedX(b.speedX), speedY(b.speedY) { } Ball& operator=(const Ball& b) { x = b.x; y = b.y; speedX = b.speedX; speedY = b.speedY; return *this; }
Désolé mais je ne comprends pas ce code
Constructeur par copie et opérateur =, pour permettre ce genre de chose
Code:

1 2 3 4 Ball b; // appel du constructeur par défaut; Ball b2(1, 1, 1, 1); // appel du constructeur prennant 4 ints Ball b3(b2); // appel du constructeur par copie b = b3; // appel de l'opérateur =

08/03/2014, 11h19
guitz

Merci à toi, je vais regarder tout ça
10/03/2014, 15h10
oodini

Citation:

Envoyé par Iradrille

Code:

static Ball *balls[2];

C'est moche, pour plusieurs raisons :
- pourquoi est-ce que c'est statique ?

Comme disait Chirac :
"Ça m'en fait bouger l'une sans faire bouger l'autre."
10/03/2014, 15h57
Iradrille

Pas sur de comprendre ? (bien que j'aime l'expression :D)

Ça n'influence pas les objets de la classe Ball : le principe d'un attribut statique.
Mais ça n'a rien à faire dans la classe Ball. Et si c'est autre part ça ne sera très probablement pas statique.
10/03/2014, 16h02
oodini

Citation:

Envoyé par Iradrille

Pas sur de comprendre ? (bien que j'aime l'expression :D)

balls, statique... ça m'a fait penser à l'expression... c'est juste le soleil qui m'avait mis d'humeur badine.