Discussion :

[rami zouari]

je ne suis ni débutant en c++, ni pro,je connais Qt et maintenant entrain de connaitre SFML.
aujourd'hui entrain d'améliorer mon projet SFML, j'étais confus dans entre créér un constructeur avec des arguments infini(si c'est possible, je sais qu'il est possible avec les fonction) ou un tableau (comme int a[]) ou dynamique avec push.back...
dans mon projet:
qu'est ce que je peu faire?
a- CollisionManager(Balle & ball, Bar & bar1, Bar & bar2, sf::Vector2u window_Size, obstacle::Obstacle,...);
b- CollisionManager(Balle & ball, Bar & bar1, Bar & bar2, sf::Vector2u window_Size, obstacle::Obstacle[]);

Note: 'Obstacle' est une classe abstraite

merci pour votre aide

[moham104]

Personnellement je crois qu'avoir une fonction quelconque avec plus que 4 ou 5 paramètre est une fonction à ne pas écrire. De plus, je ne voie pas l'utilité d'un fonction qui pourrais supporter un infinité de paramètre. Les structures sont là pour ça.

Tu peux te définir une type avec un structure et recevoir cette structure en paramètre dans ta fonction.

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
 
typedef struct{
Balle bal,
Bar  bar1,
sf::Vector2u window_Size,
obstacle::Obstacle,
...,
} TypeX;
 
TypeX parametre;
 
parametre.bal = quelquechose;
parametre.bar1 = quelquechosedautre;
... ;
 
//La déclaration
CollisionManager(TypeX param);
 
//L'utilisation
CollisionManager(parametre);

[Neckara]

Bonjour,

Tu peux regarder du côté des va_list (plutôt C) et du côté des templates (plutôt C++).

Cf : http://www.cplusplus.com/forum/beginner/90610/

[koala01]

Salut,

Le constructeur d'une classe n'est jamais qu'une fonction comme une autre, à ceci près que c'est une fonction qui est appelée au moment de la création de l'objet.

Tu peux donc faire avec un constructeur tout ce que tu peux faire avec une autre fonction (tant que tu n'essayes pas de le rendre virtuel ou ami de ta classe).

Cependant, l’utilisation de l'ellipse " ... " n'est vraiment pas recommandée, pour la simple et bonne raison qu'elle signifie " et le reste, dont je ne sais strictement rien (ni le type des arguments qui viendront ni leur nombre)".

Même en adoptant un schéma de pensée plus proche du C que du C++, il faut avouer que le nombre de cas où il est intéressant de permettre à une fonction d'accepter un nombre inconnu d'argument de type inconnu est très fortement limité.

C'est d'autant plus vrai pour le constructeur d'une classe car j'ai vraiment énormément de peine à imaginer la raison pour laquelle il pourrait être nécessaire de disposer d'un nombre inconnu d'arguments de type inconnus pour être en mesure d'initialiser un objet de telle manière à ce qu'il présente un état cohérent une fois créé (ce qui est, rappelons le, le but du constructeur )

A titre personnel, cela fait plus de dix ans que je développe en C++, et je n'ai encore jamais été confronté à ce besoin , du moins sous cette forme.

Après, il est vrai que C++11 est arrivé avec ce que l'on appelle les variadic template.

Si le résultat est fort proche de l'utilisation de l'ellipse en C, c'est malgré tout une technique particulièrement très particulière et très qui permet d'obtenir quelque chose de très très générique, mais les cas d'utilisation de cette technique restent très limités malgré tout

Je ne peux que confirmer les dires de moham104 (bien que l'exemple qu'il donne de la structure me déplaise énormément car trop "C style à mon gout) : tu peux déclarer une fonction avec autant de paramètres que tu le désires, mais il faut savoir que quatre à cinq paramètres, c'est le grand maximum "humainement gérable".

Dés lors, pour répondre à tes questions:
a - oui, tu peux le faire, mais je serais personnellement surpris que cela corresponde réellement à tes besoins
b - oui, tu peux le faire aussi, mais je préférerais l'utilisation d'une collection de la stl comme std::vector (ou n'importe quelle autre) en lieu et place de ton obstacle::Obstacle[]. Cela te posera beaucoup moins de soucis

[rami zouari]

Merci vos trois , je vais essayer avec std::vector...

[rami zouari]

maintenant je suis bloqué dans ce complexe std::vector,
j'ai pas pus itérer sur pour connaître s il y a une collision...
Voici le code :

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
void CollisionManager::ManageCollisionsX(bool &gamestate, bool &timemode)
{
	// Récupération de la boîte englobante de la balle
	IntRect ballRect = myBall.getBoundingBox();
	// Récupération des boîtes englobantes des barres
	IntRect bar1Rect, bar2Rect;
	bar1Rect = myBar1.GetBoundingBox();
	bar2Rect = myBar2.GetBoundingBox();
	// Test des Collisions en X
	for (std::vector<obstacle::Obstacle>::iterator obs = monObstacle.begin(); obs != monObstacle.end(); ++obs)
	{

	}
	if (Collision(ballRect, bar1Rect) || Collision(ballRect, bar2Rect)) // la collision
	{
		// On annule le mouvement de la balle et on lui inverse son mouvement en X
		myBall.ReverseDX();
		myBall.MoveX();
	}

}

Le reste...
}

l'objectif est de transmettre chaque élément de ce objet en IntRect;

voici ma version de GetBoundingBox() (pour RectangleObstacle)...

Code :

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

1
2
3
4
5
6
7
8
9
10
 
IntRect RectangleObstacle::GetBoundingBox() const
{
	IntRect boundingBox;
	boundingBox.left = (int)carré.getPosition().x;
	boundingBox.width = boundingBox.left + (int)carré.getSize().x;
	boundingBox.top = (int)carré.getPosition().y;
	boundingBox.height = boundingBox.top + (int)carré.getSize().y;
	return boundingBox;
}

la classe Obstacle.

Code :

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

1
2
3
4
5
6
7
8
class Obstacle abstract :
		public sf::Shape
	{
	public:
		virtual ~Obstacle() = 0;
		virtual sf::IntRect GetBoundingBox() const = 0;
	private:
	};

merci pour votre aide

[JolyLoic]

Une autre nouveauté intéressante du C++11 pour ça est l'initializer_list avec l'initialisation uniforme. Tu peux l'utiliser directement ou indirectement.

Par exemple, si ton constructeur prend en paramètre un vector<Point> et que Point prend en paramètre 2 doubles, tu peux écrire :

Code :

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

MaClass a({{1,2},{4,3.2},{12,42}});

[rami zouari]

merci, je vais essayer

mais ça ne m'aide pas dans la création de la classe :/

[JolyLoic]

Dans ta classe Obstacle, je vois du virtual. Ce qui semble dire qu'il faut la manier à l'aide de pointeurs. Or tu crées un vector<Obstacle>, et non pas un vector<Obstacle*>. Tu risques donc d'avoir des soucis.

Sinon, je n'ai pas trop compris tes soucis...

Code :

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

1
2
3
4
for (std::vector<obstacle::Obstacle>::iterator obs = monObstacle.begin(); obs != monObstacle.end(); ++obs)
	{
            IntRect rect = obs->GetBoundingBox();
	}

Ou, une fois que tu seras passé à des pointeurs :

Code :

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

1
2
3
4
for (std::vector<obstacle::Obstacle>::iterator obs = monObstacle.begin(); obs != monObstacle.end(); ++obs)
	{
            IntRect rect = (*obs)->GetBoundingBox();
	}

Ou, en version C++11 :

Code :

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

1
2
3
4
for (auto const &obs : monObstacle)
	{
            auto rect = obs->GetBoundingBox();
	}

[oodini]

Cependant, l’utilisation de l'ellipse " ... " n'est vraiment pas recommandée,

La traduction d'ellipsis par ellipse n'est vraiment pas recommandée (anglicisme).
Préférer tout simplement "points de suspension".

[rami zouari]

tous vous m'avez donné n'ont pas marché :/ j'essayais milles fois, le programme fonctionne OK, mais pas de collision :/

[LittleWhite]

Alors, essayez de comprendre pourquoi cela ne marche pas en débogant, soit avec des print, soit avec le débogueur et des points d'arrêts.

[Bousk]

Je suis un peu géné de voir une hésitation entre des varargs/variadic template et un vector en paramètres de fonction...
Soit la fonction doit prendre des paramètres optionnels dans leur nombre, voire leur type (printf, ..), soit elle prend un tableau d'éléments (tous identiques).
Je ne vois même pas comment on peut avoir une telle hésitation.

[rami zouari]

J'ai compris l'erreur,j'ai observé que la boucle For que vous me aviez donné n'a pas marché ...

Code :

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

1
2
3
4
5
6
7
8
9
10
for(auto const &obs : monObstacle)
{
auto rect = obs->GetBoundingBox;
If(Collision(rect,myBall))
{
  ReverseDX;
  MoveX;
}
std::cout << "It works!" << std::endl;
}

Le "cout" ne marche pas...

aussi avec les statique quand je déclare dans la classe Collision Manager comme Private: obstacle::Obstacle* Obstacle[];
alors le compilateur me dit Erreur : Type non complet.
mais si ça ne marche pas mais pourquoi quand je fais char a[], ça marche ?

[rami zouari]

Enfin je ça marche