Discussion :

[Agoudard]

Bonjour,

Je suis en train de créer un petit moteur physique 2D.
L'objet World contient donc une collection d'objets.
Les objets contiennent eux une collection de de primitives géométriques (rectangles, cercles, etc).

Il me semble que la création/gestion d'objet devient vite fastidieuse.

Est-il judicieux dans ce cas, d'utiliser un design pattern Factory ? Pour avoir simplement à "demander" un nouvel objet et ainsi masquer toute la gestion new/delete.
Mais aussi pour enregistrer un objet complexe et ne pas avoir à recalculer toutes les normales par exemple.

Pour avoir un code utilisateur genre :

Code :

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

1
2
3
4
5
6
7
8
9
10
11
12
13
 
int main(int argc, char* argv[])
{
   CShape shape;
   shape    << CVector(0,0)
                << CVector(0,10)
                << CVector(10,10)
                << CVector(10,0);
   CWorld::register("monRectangle", shape);
   CObject* object = CWorld::create("monRectangle");
 
   return 0;
}

L'usage d'un singleton est-il justifié ?

Merci

[Joel F]

Est-il judicieux dans ce cas, d'utiliser un design pattern Factory ?

Oui

L'usage d'un singleton est-il justifié ?

Non

[Astraya]

+1

Une chose judicieuse est le Data-Driven programming.

[screetch]

le singleton n'est jamais justifié (si c'est un mensonge, c'est beaucoup plus proche de la vérité que "le singleton est souvent une bonne idée)

/me en croisade contre les singletons

[Agoudard]

Ok, donc quelque chose qui ressemble à :

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
 
int main(int argc, char* argv[])
{
   CWorld world;
 
   // Enregistrement de l'objet monRectangle
   CShape shape;
   shape << CVector(0,0)
             << CVector(0,10)
             << CVector(10,10)
             << CVector(10,0);
   world.getObjectFactory().register("monRectangle", shape);
 
   // Création de l'objet monRectangle & ajout à world
   CObject* object = world.getObjectFactory().create("monRectangle");
 
   return 0;
}

est un code assez confortable et opaque ?

Autre question : C'est mieux si CShape est un builder non ?

Merci pour vos réponses.

[bretus]

Bonjour,

CWorld se comporte comme une fabrique un peu particulière dans la mesure où elle se base sur un prototype pour créer l'instance. Son gros défaut est qu'elle ne te permet pas de passer les paramètres de construction.

CShape se comporte en effet comme un builder. Le fait est que CShape ne sait pas ce qu'il construit. Tu peux recourir à une approche du type :

Code :

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

1
2
3
4
5
6
7
8
 
CShapeBuilder builder;
builder.beginRectangle();
builder.addVector( Vector(0.0,1.0) );
builder.addVector( Vector(0.0,1.0) );
builder.addVector( Vector(0.0,1.0) );
builder.addVector( Vector(0.0,1.0) );
builder.endRectangle();

En fonction du besoin, tu peux ajouter des niveaux d'abstraction :

Code :

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

1
2
3
4
5
6
7
8
 
CShapeBuilder builder;
builder.begin("Rectangle");
builder.addVector( Vector(0.0,1.0) );
builder.addVector( Vector(0.0,1.0) );
builder.addVector( Vector(0.0,1.0) );
builder.addVector( Vector(0.0,1.0) );
builder.end("Rectangle");

Mais là, tu sens bien que ça complexifie. Il faut que le CShapeBuilder fasse appel lui même à des builders. Du coup tu vas introduire un CRectangleBuilder et ajouter

Code :

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

1
2
 
CWorld::getShapeBuilder()

et

Code :

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

1
2
 
CWorldRegisterShapeBuilder( builderName, concreteBuilder )

Puis, tu vas te dire : Mais pourquoi ne pas faire un CVectorBuilder... Alors, tu vas l'introduire et au final : Tu auras une architecture in-buvable, ré-utilisable à souhait mais donc les 3/4 sera utilisé une et une seule fois.

Tout ça pour dire : A quoi bon ajouter ces niveaux d'abstractions si le besoin n'est pas là? As-tu besoins de créer des instances en fonction d'une chaine de caractères représentant le nom de la classe?


Si je peux me permettre un conseil : Il faut partir de tes besoins pour former ton architecture, plus que d'essayer de caser tous les design patterns de l'univers.

"Keep it Simple, Stupid". Commence par une architecture triviale en te laissant suffisamment de porte ouverte pour la modifier (refactoring).

(Les fabriques échappent un peu à la règle dans la mesure où il n'est pas aisé de refactorer les new sans produire un "break change")

Cdlt