Discussion :

[SebastienM]

Bonjour,

Je souhaite réécrire un petit moteur 3D (que j'avais fait sans notion objet il y a longtemps).
L'idée est de décomposer en plusieurs classes :
-> Engine
----> Scene
---------> Object

par exemple.

Pour cela ma classe scène hérite de Engine - et évidement la classe engine peut avoir plusieurs scènes (logique me direz vous).

Mon soucis est le suivant :
Je veux que dans le code principal, j'instancie un Engine avec certaines propriétés. Jusque là tout va bien.
Ensuite je veux créer une scène - j'instancie donc une scène avec certaines propriétés.
Maintneant, j'aimerai que lorsque j'accède aux propriétés parentes de mon objet scène, je retrouve les propriétés de Engine définies précédemment.

Comment faire ?

Merci.

[r0d]

Bonjour,

tout d'abord, pourquoi la scene hérite de engine? Quelles en sont les raisons objectives?

[SebastienM]

ça me paraît logique ... mais c'est la seule raison que je vois ^^
Il serait plus simple à expliquer en prenant un level en dessous :
Un objet hérite des propriétés d'une scène.

[r0d]

En fait, je ne vois pas de raison qui légitime ce choix. Je dis bien "je ne vois pas", ce qui signifie que peut-être il en existe mais que je passe à côté.

Il y a plusieurs façon d'utiliser l'héritage. Généralement, on l'utilise de façon à retranscrire une relation logique entre deux entités. Par exemple "est un": chien et chat héritent de animal car chien "est un" animal, et chat "est un" animal. Ici, ce n'est pas le cas: une scene n'est pas un moteur.

Il y a aussi l'héritage de type "contrat", très utilisé en java, mais aussi un peu en c++. Cela consiste à définir une interface; interface dans le sens: "un ensemble de fonctionnalités et propriétés". Les classes dérivant d'une interface devront implémenter ces fonctionnalités et propriétés. D'où la notion de contrat: "je suis d'accord pour que tu hérites de moi, mais il faut que tu implémentes ces choses-là". Par exemple, si l'interface animal déclare les fonctions manger(), et que les classes chien et chat veulent hériter de animal, alors il faudra que chien et chat implémentent la fonction manger(). Ici encore, je ne vois pas quel type de contrat il pourrait y avoir entre engine et scene.

Je travaille moi-même, sur mon temps libre, sur un petit jeu video. C'est en 2D, donc c'est différent. Mais j'ai le même type d'architecture, c'est à dire un moteur de rendu, et des scenes. Faire hériter scene de engine (dans mon cas les noms de classes sont différents) ne m'est jamais venu à l'esprit.

A vrai dire, je ne vois pas ce que scene et engine peuvent avoir en commun.
Encore une fois, peut-être que je raconte n'importe quoi parce que je suis passé à côté de quelque chose.
Mais quoi qu'il en soit, lorsqu'on décide d'une relation d'héritage entre deux classes, il faut savoir pourquoi on le fait, sinon c'est qu'il y a quelque chose qui cloche.

[SebastienM]

D'accord, je comprend bien ta réponse, et je te remercie d'avoir pris le temps de me répondre.
En fait je vais essayer de formuler ma question un peu différement ; je cherche un modèle qui pourrait structurer mon code correctement.

J'ai par exemple dans ma classe Engine une gestion des logs - et j'aimerai pouvoir en "profiter" dans mes autres classes (ça peut être des logs ou n'importe quoi).
Ma première idée était de créer un pointeur au sein de mes sous classe permettant de récupérer l'objet engine instancié.

En gros je suis ouvert à toute proposition

[screetch]

que chaque objet connaisse l'engine est une idée qui semble correcte mais qui en fait est dangereuse.

Disons pour simplifier qu'il y a plusieurs types de relations entre objet, qui s'ecrivent en francais avec les 3 verbes:
être
avoir
utiliser

être -> héritage
avoir -> composition
utiliser -> outil, paramètre, méthode

par exemple, le chien est un animal
le chien a un propriétaire
le proprietaire a des chiens
le propriétaire utilise une laisse pour promener le chien


on a donc:

Code :

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

1
2
3
4
5
6
7
8
9
10
11
class Proprietaire
{
  std::vector<Chien*> mesChiens; // a des chiens
  public:
    void promenerChiens(Laisse* laisse); // utilise une laisse, voire même plusieurs
};
 
class Chien : public Animal // est un animal
{
  Proprietaire* proprio; // a un proprietaire
}

Dans ton cas, un Moteur a une scene (par exemple) voire même des scenes
une scene a des objets
les objets utilisent le log (qui, by the way, n'a rien a faire dans la classe Moteur)