Discussion :

[sphere369]

Bonjour,

J'ai un probleme avec le code ci-dessous.Je recois le message d'erreur ci-dessous. D'avance merci pour votre aide.

Sphere369

Message d'erreur:
1>ConsoleFactory.cpp
1>c:\cpp2006\chapter14\shapepatterns\05_abstractfactory\shapefactory.hpp(21) : error C4430: spécificateur de type manquant - int est pris en compte par défaut. Remarque*: C++ ne prend pas en charge int par défaut
1>c:\cpp2006\chapter14\shapepatterns\05_abstractfactory\shapefactory.hpp(21) : warning C4183: 'ShapeFatory'*: type de retour manquant*; fonction membre retournant 'int' prise par défaut

ConsoleFactory.cpp :

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
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
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
#include "ConsoleFactory.hpp"
#include "Point.hpp"
#include "Line.hpp"
#include "Circle.hpp"
 
ConsoleFactory::ConsoleFactory(): ShapeFactory()
{ // Default constructor
}
 
ConsoleFactory::ConsoleFactory(const ConsoleFactory& source): ShapeFactory(source)
{ // Copy constructor
}
 
ConsoleFactory::~ConsoleFactory()
{ // Destructor
}
 
Point* ConsoleFactory::CreatePoint() 
{ // Create point
 
	double x, y;
 
	std::cout << "Creating a point" << std::endl;
 
	// Input point
	std::cout<<"Input x: ";
	std::cin>>x;
	std::cout<<"Input y: ";
	std::cin>>y;
 
	return new Point(x, y);
}
 
Line* ConsoleFactory::CreateLine() 
{ // Create line
 
	double x1, x2, y1, y2;
 
	std::cout << "Creating a line" << std::endl;
 
	// Input start- and endpoint
	std::cout<<"Input x1: ";
	std::cin>>x1;
	std::cout<<"Input y1: ";
	std::cin>>y1;
	std::cout<<"Input x2: ";
	std::cin>>x2;
	std::cout<<"Input y2: ";
	std::cin>>y2;
 
	return new Line(Point(x1, y1), Point(x2, y2));
}
 
Circle* ConsoleFactory::CreateCircle() 
{ // Create circle
 
	double x, y, r;
 
	std::cout << "Creating a circle" << std::endl;
 
	// Input centerpoint and radius
	std::cout<<"Input x: ";
	std::cin>>x;
	std::cout<<"Input y: ";
	std::cin>>y;
	std::cout<<"Input radius: ";
	std::cin>>r;
 
	return new Circle(Point(x, y), r);
}
 
 
ConsoleFactory& ConsoleFactory::operator = (const ConsoleFactory& source)
{ // Assignment
 
	// Exit if same object
	if (this==&source) return *this;
 
	// Call base assignment
	ShapeFactory::operator = (source);
 
	return *this;
}

ShapeFactory.hpp :

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
22
23
24
25
26
27
#ifndef ShapeFactory_hpp
#define ShapeFactory_hpp
 
#include "Shape.hpp"
#include "Point.hpp"
#include "Circle.hpp"
#include "Line.hpp"
 
class ShapeFactory
{
private:
public:
	// Constructors and destructor
	ShapeFactory();								// Default constructor
	ShapeFatory(const ShapeFactory& source);	// Copy constructor
	virtual ~ShapeFactory();					// Destructor
 
	virtual Point* CreatePoint() = 0;			// Create a point
	virtual Circle* CreateCircle() = 0;			// Create a circle
	virtual Line* CreateLine() = 0;				// Create a line
 
 
	// Operators
	ShapeFactory& operator = (const ShapeFactory& source);
};
 
#endif // ShapeFactory_hpp

ShapeFactory.cpp :

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
#include "ShapeFactory.hpp"
 
ShapeFactory::ShapeFactory()
{ // Default constructor
}
 
ShapeFactory::ShapeFatory(const ShapeFactory& source)
{ // Copy constructor
}
 
ShapeFactory::~ShapeFactory()
{ // Destructor
}
 
ShapeFactory& ShapeFactory::operator = (const ShapeFactory& source)
{ // Assignment
 
	return *this;
}

[Dalini71]

Salut,

Truc bête : enlève l'espace entre le mot-clé operator et le symbole =.

[sphere369]

Non, cela ne change rien...(ce qui est d'ailleurs normale).

[mehdi_me85]

Je ne suis pas un expert, mais est ce que tu es sur que l'espace ne change rien ?

à mon avis dans ce cas si. Le compilateur peut le comprendre comme un = de (a = b), mais si tu fait "operateur=" c'est peut être différent.

Si tu as déjà essayé, ne prend pas en considération cette intervention

[koala01]

Salut,

J'entrevois déjà plusieurs problèmes...

D'abord, il n'est pas forcément utile ni nécessaire de disposer d'une instance de fabrique...

De plus, une fabrique est, en toute logique, sensée pouvoir fabriquer... plusieurs objets de types forts proche, et seule elle devrait savoir exactement comment s'y prendre (tu ne devrais avoir à la limite qu'à appeler la fonction create quel que soit le type que tu souhaites créer (sinon, tu perds tout le bénéfice d'utilisation de la fabrique )

Tu en viendrais donc à une structure proche de

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
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
/* la classe de base de tes formes 
 */
class Shape
{
    public:
        virtual void draw() const = 0;
        virtual ~Shape();
};
/* peut on réellement considérer le point comme une forme ?? */
class Point : public Shape
{
    public:
        virtual void draw() const;
};
class Line : public Shape
{
    public:
        virtual void draw() const;
};
class Circle : public Shape
{
    public:
        virtual void draw() const;
};
/* il est tout aussi faux, d'un point de vue OO
 * de dire qu'un carré est un rectangle particulier
 * que de dire qu'un rectangle est un carré particulier (même si
 * la du point de vue de la géométrie, la première assertion est vraie)
 * car LSP est mis à mal... Par contre, ce sont tous deux des formes ;)
 */
class Rectangle : public Shape
{
    public:
        virtual void draw() const;
};
class Square : public Shape
{
    public:
        virtual void draw() const;
};

NOTA: j'ai fait l'impasse sur les constructeurs et les destructeurs

Et ta fabrique pourrait prendre la forme de

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
22
23
24
25
26
27
28
29
30
31
/* Nous pourrions envisager de créer une fabrique sur le pattern "singleton"
 * mais nous pouvons aussi décider de simplement utiliser des
 * fonctions statiques ;)
 */
class ShapeFactory
{
    public:
        /* Tout ce que l'on sait, c'est qu'il faut appeler create ;) 
         */
        static Shape* create() const;
    private:
       /* nous n'avons absolument pas besoin d'appeler explicitement
        * les différentes versions de create ;)
        */
      static Point* createPoint() const;
      static Line* createLine() const;
      static Circle createCircle() const;
      static Rectangle* createRectangle() const;
      static Square* createSquare() const;
      /* Comme on ne travaille absolument pas avec une instance
       * de ShapeFactory (ou qu'avec une insance unique de ShapeFactory
       * si on l'utilise sous la forme d'un singleton)
       * il ne sert à rien de permettre la copie et l'affectation de cette
       * fabrique..
       *
       * nous déclarons le constructeur par copie et l'opérateur d'affectation
       * privé et nous ne les définissons pas
       */
       ShapeFactory(ShapeFactory const& );
       ShapeFactory& operator=(ShapeFactory);
};

qui serait implémentée sous une forme proche de

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
22
23
24
25
26
27
28
29
30
Shape* ShapeFactory::create() const
{
    /* il faut d'abord déterminer le type d'objet à créer */
    std::cout<<"Veuillez preciser le type de forme a creer "<<std::endl
             << std::endl
             <<" 1 - un point"<< std::endl
             <<" 2 - une ligne"<< std::endl
             <<" 3 - un cercle"<< std::endl
             <<" 4 - un rectangle"<< std::endl
             <<" 5 - un carre"<< std::endl<< std::endl
             <<"Votre choix ? ";
      int choix;
      cin>> choix;
      /* les choix possibles */
      switch(choix)
      {
          case 1:
              return createPoint();
          case 2:
              return createLine();
          case 3:
              return createCircle();
          case 4:
              return createRectangle();
          case 5:
              return createSquare();
      }
      /* si on s'est trompé dans le choix */
      return NULL;
}

(les autres fonctions de ShapeFactory auront pour but de demander les informations nécessaires à la création de la forme ad-hoc et de renvoyer un pointeur sur cette forme )

Le tout étant utilisé sous une forme proche de

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
22
23
24
25
int main()
{
    /* Nous demandons la création de plusieurs formes...
     * Nous n'en savons pas plus à son sujet car toutes les décisions
     * importantes dépendent de ShapeFactory
     * et nous les plaçons dans un tableau de formes
     */
    std::vector<Shape*> tab;
    /* on en veut dix ici */
    for(size_t i=0;i<10;++i)
        tab.push_back(ShapeFactory::create());
    /* Nous n'avons même pas besoin de savoir quelles formes ont 
     * été créées...
     * nous savons demander à ce qu'elles soient tracées ;)
     */
    for(size_t i=0;i<10;++i)
        tab[i]->draw();
    /* comme j'ai utilisé des pointeurs nus (je n'aurais pas du),
     * il faut veiller à libérer correctement la mémoire avant de quitter 
     */
 
    for(size_t i=0;i<10;++i)
        delete tab[i];
    return 0;
}

De cette manière, nous remarquons que seule ShapeFactory doit avoir connaissance des différents type de forme réellement utilisés, et qu'elle prend seule la responsabilité de choisir laquelle sera créée

La version "singleton" pourrait sans doute être basée sur le clonage, avec une forme proche de

Code :

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

1
2
3
4
5
6
7
8
9
10
class Shape
{
    public:
        virtual void draw() const = 0;
        /* clone sera redéfinie pour chaque type de forme
         * de manière à demander les informations propre à la forme à créer 
         */
        virtual Shape* clone() const = 0;
        virtual ~Shape();
};

et la fabrique prendrait une forme proche de

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
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
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
class ShapeFactory
{
    public:
        static ShapeFactory& instance()
        {
            if(!inst)
                inst=new ShapeFactory;
            return *inst;
        }
        /*  les gens sont divisés sur la présence de cette fonction */
        static void destroy()
        {
            delete inst;
            inst=NULL;
        }
        Shape* create();
    private:
        /* nous ne laissons personne d'autre que la fabrique  accéder à 
         * son constructeur et à son destructeur
         */
        ShapeFactory();
        ~ShapeFactory();
        /* et nous déclarons sans les définir le constructeur par copie 
         * et l'opérateur d'affectation de manière à éviter leur utilisation
         */
        ShapeFactory& operator=(ShapeFactory);
        ShapeFactory(ShapeFactory const &);
        ShapeFactory* inst;
        std::map<int, Shape*> allshapes;
};
/* dans le fichier d'implémentation */
ShapeFactory* ShapeFactory::inst= 0;
/* dans le constructeur, nous remplissons la map des différentes formes
 */
ShapeFactory::ShapeFactory()
{
   allshapes[1] = new Point;
   allshapes[2] = new Line;
   allshapes[3] = new Circle;
   allshapes[4] = new Rectangle;
   allshapes[5] = new Square;
}
/* et nous veillons à libérer correctement la mémoire dans le destructeur */
ShapeFactory::~ShapeFactory()
{
    for(std::map<int, Shape*>::iterator it=allshapes.begin();
        it!=allshapes.end(); ++it)
        delete (*it).second;
}
/* pour créer une forme, il faut choisir laquelle on souhaite */
Shape* ShapeFactory::create()
{
    /* il faut d'abord déterminer le type d'objet à créer */
    std::cout<<"Veuillez preciser le type de forme a creer "<<std::endl
             << std::endl
             <<" 1 - un point"<< std::endl
             <<" 2 - une ligne"<< std::endl
             <<" 3 - un cercle"<< std::endl
             <<" 4 - un rectangle"<< std::endl
             <<" 5 - un carre"<< std::endl<< std::endl
             <<"Votre choix ? ";
      int choix;
      cin>> choix;
      std::map<int, Shape*>::iterator it= allshapes.find(choix);
     /*  si on n'a pas touvé la bonne forme, on renvoie NULL */
     if(it==allshapes.end())
        return NULL;
     /* dans tous les autres cas, on renvoie le résultat de clone */
     return (*it).second->clone();
}

La seule différence notable au niveau de l'utilisation vient du fait qu'il faudra passer par ShapeFactory::instance().create pour obtenir la forme, mais pour le reste, tout est pareil :

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
22
23
24
25
int main()
{
    /* Nous demandons la création de plusieurs formes...
     * Nous n'en savons pas plus à son sujet car toutes les décisions
     * importantes dépendent de ShapeFactory
     * et nous les plaçons dans un tableau de formes
     */
    std::vector<Shape*> tab;
    /* on en veut dix ici */
    for(size_t i=0;i<10;++i)
        tab.push_back(ShapeFactory::instance()::create());
    /* Nous n'avons même pas besoin de savoir quelles formes ont 
     * été créées...
     * nous savons demander à ce qu'elles soient tracées ;)
     */
    for(size_t i=0;i<10;++i)
        tab[i]->draw();
    /* comme j'ai utilisé des pointeurs nus (je n'aurais pas du),
     * il faut veiller à libérer correctement la mémoire avant de quitter 
     */
 
    for(size_t i=0;i<10;++i)
        delete tab[i];
    return 0;
}

[sphere369]

Je ne suis pas un expert, mais est ce que tu es sur que l'espace ne change rien ?

à mon avis dans ce cas si. Le compilateur peut le comprendre comme un = de (a = b), mais si tu fait "operateur=" c'est peut être différent.

Si tu as déjà essayé, ne prend pas en considération cette intervention

Salut Mehdi,

J'ai annulé l'espace mais cela n'a rien donné: toujours le même bug .


Salut Koala,
Merci pour ton précieux aide. Tu viens de me sortir une grosse épine du pied. Je suis entrain d'essayer de comprendre l'utilité des designs patterns et surtout leur fonctionnement

Au fait comment as tu fais pour voir si vite/facilement que ce je voulais faire était d'utiliser le pattern fabrique/factory? Est ce uniquement du à l'experience?

[koala01]

Salut Mehdi,

J'ai annulé l'espace mais cela n'a rien donné: toujours le même bug .


Salut Koala,
Merci pour ton précieux aide. Tu viens de me sortir une grosse épine du pied. Je suis entrain d'essayer de comprendre l'utilité des designs patterns et surtout leur fonctionnement

Au fait comment as tu fais pour voir si vite/facilement que ce je voulais faire était d'utiliser le pattern fabrique/factory? Est ce uniquement du à l'experience?

C'est surement du à l'expérience, mais ce pourrait aussi être du fait du code que tu présentais (et surtout du nom de ta classe ShapeFactory), voire, tout simplement du à une certaine habitude de "lire entre les lignes"...

Va savoir...

Et non, je ne suis pas extra lucide

[sphere369]

Reconnaitre un pattern dans un code n'est pas chose triviale même au niveau des experts donc, ouf (un chapitre de moins a omettre pour mes entretiens (je suis entrain de postuler a des postes de financiers nécessitant de fortes connaissances en C++ et en finance, +boost + histoire de l'art + psychologie,etc...))... (bref par ce temps de crise je fais tout pour ressembler au mouton a 15 pattes tant demandé...).

Encore merci pour tout.

Sphere369

[Goten]

Reconnaitre un pattern dans un code n'est pas chose triviale même au niveau des experts donc, ouf (un chapitre de moins a omettre pour mes entretiens (je suis entrain de postuler a des postes de financiers nécessitant de fortes connaissances en C++ et en finance, +boost + histoire de l'art + psychologie,etc...))... (bref par ce temps de crise je fais tout pour ressembler au mouton a 15 pattes tant demandé...).

Encore merci pour tout.

Sphere369

Faut avouer que le nom de la classe, plus les méthodes données faisant vraiment pensé à ce pattern. Expert ou pas d'ailleurs;