methodes virtuelles+encapsulation+heritage = complexe

Salut à tous, :D

J'ai besoin d'un coup de main en C++, car je voudrais réaliser un simulateur de trajectoire. Je m'explique je voudrais une classe mère Trajectoire sachant qu'une trajectoire peut être LigneDroite, Sinusoidale, Cercle, Bezier, etc...

Donc lorsque je créer mes objets qui se déplaceront je ne sais pas à l'avance quelle trajectoire ils suivront. Donc je leur donnerait juste un parametre :

Code:

---

Trajectoire * mTrajectoire;

---

Puis lors de l'initialisation (dans l'init) je ferais :

Code:

---

mTrajectoire = new LigneDroite();

---

Mais le problème c'est que pour initialiser une ligne droite, on peut donner deux points, le point de départ et le point de destination. Ou alors un point de depart et un angle.
Par contre pour initialiser un cercle, il faut donner le rayon, le point central et la vitesse de rotation par exemple.

Donc en gros pour initialiser ces trajectoires, il faut donner des paramètres différents, donc comment peut-on procéder en C++ à l'élaboration d'une structure précise pour cet exemple de trajectoire.

Merci d'avande pour votre aide, elle me sera d'une grande utilité :D

Là où tu crées ta trajectoire, tu sais exactement de quelle trajectoire il s'agit. Donc, logiquement, tu connais aussi les paramètres associés. Passe-le donc en paramètres aux divers constructeurs.

modelise tes trajectoires en objets,

Liste tes objets, trouve les données communes, etablie les specificitées de chaque type d objet, hierarchise les entres eux. Ensuite tu peux t attaquer aux metodes...

Et par la suite quand ton modèle est bon, passe à l 'implementation proprement dite. :yaisse2:


Pour etre plus pragmatique : les objets qui se deplacent doivent comporter un objet trajectoire génerique avec des methodes virtuelles dont l'implementation differeras suivant la nature de la trajectoire (polymorphisme). Reste à instancier le bon type de trajectoire... et le tour est joué :yaisse:

Ben oui justement c'est ca le problème, c'est que suivant le type de trajectoire il faut donner des types de données differents.

Pour cercle il faut : Vecteur centre, float rayon, float angleDepart
Pour bezier il faut : int nbPoints, CVecteur ** lesPoints

Donc on ne peut point faire une initialisation avec tous ses parametres puisque selon le type de trajectoire a initialiser, il faut donner un nombre de parametres differents et des types differents.
Donc je vois mal comment on pourrait faire pour faire une initialisation commune.

Donc ce que j'ai fait, mais c'est vrai que c'est pas très propre, c'est de déclarer une fonction d'inialisation de chaque type (cerlce, ligne droite, bezier, etc..) dans la classe abstraite Trajectoire, comme suit :

Code:

---

1 2 3 4 5 6 7

class Trajectoire { public : virtual void initC(CVecteur* center, float radius, float angle, float periode) = 0; virtual void initLD(CVecteur* _posDepart, CVecteur* _posDestination, float _nbSec) = 0; };

---

Mais le souci c'est qu'il faut ajouter à chaque fois les nouvelles fonctions d'inialisation dans la classe Trajectoire, et aussi redefinir les autres dans chaque classe LigneDroite, ou Cercle (qui ne l'utilisent pas), par exemple : il faut que je redefinisse le initC(param...) dans la classe LigneDroite et ne rien mettre dedans.

Il y t'il un autre moyen de faire autrement et plus simple.

Je ne comprends pas pourquoi tu peux connaître ces paramètres plus tard lorsque tu manipules un Trajectoire*, et pas avant lorsque tu construis l'instance de la classe dérivée.
En tout cas ce n'est pas normal (et accessoirement très crade comme solution ;)).

Comment ca c'est pas normal.

C'est vrai que pour certains objets je connais la trajectoire à l'avance (et est fixe par exemple LigneDroite), mais pour d'autres à un temps donné t on peut l'initialiser avec une LigneDroite et puis lorsque c'est fini enchaîner juste après avec une trajectoire sinusoidale puis ensuite avec eventuellement un Cercle, etc...).

Donc la trajectoire de l'objet dépend du temps et du comportement du joueur. C'est pour ca que je voudrai créer un Trajectoire pour les objets qui se déplacent afin d'utiliser seulement lorsque j'ai besoin la trajectoire dont j'ai besoin.

Pour etre plus précis c'est pour un jeu de shoot, les vaisseaux suivent une trajectoire mais dès fois on ne peut pas le connaître à l'avance ou alors ca peut être aléatoire.

Ce que je voulais dire, c'est que tu es censé connaître les paramètres au moment où tu instancies ta classe dérivée, tu peux donc les passer au constructeur et virer toutes ces fonctions virtuelles.

Citation:

---

Ce que je voulais dire, c'est que tu es censé connaître les paramètres au moment où tu instancies ta classe dérivée

---

Oui je suis d'accord sur ce point.

Citation:

---

tu peux donc les passer au constructeur et virer toutes ces fonctions virtuelles.[/

---

La je vois pas trop car justement je voulais différencier les différentes créations de trajectoires au niveau du nombre de paramètres et du type de ces derniers. Je ne peut donc point créer un constructeur commun pour toutes les trajectoires.

C'est ca en gros mon vrai problème, car bien que toutes ces classes (LigneDroite, Cercle, Bezier, etc...) correspondent bien à des trajectoires, leur fonctionnement est complètement différent et donc leur initialisation en sera autant.

Citation:

---

Je ne peut donc point créer un constructeur commun pour toutes les trajectoires

---

Il n'est pas question de créer un constructeur commun, chaque classe dérivée possède son propre constructeur qui prend des paramètres en bon nombre et de bons types. Non ?

=> Laurent Gomila

Oui en effet ca marche bien avec le polymorphisme merci à tous pour votre aide.