Questions sur les "factories"

Je me remets à C++ après quelques années de Python intensif, et c'est
dur, je suis très rouillé...

alors que normalement je m'attends d'après l'exemple à avoir des
ProductA1 ou ProductA2 à la place des AbstractProductA.

Le plus bizarre c'est que le schéma Factory semble bien fonctionner avec
les produits B et pas avec les produits A.

Sinon une autre question : pourquoi la fonction typeid(variable).name()
ne donne-t-elle pas un type de classe ou de variable bien propre comme
dans la plupart des docs mais rajoute quelques chiffres ? Par exemple,
pourquoi obtiens-je "9ProductB1" à la place de "ProductB1" ?

Bonsoir,

Je me remets à C++ après quelques années de Python intensif, et c'est
dur, je suis très rouillé...

J'essaie de comprendre et de traduire en C++ le premier programme décrit
à la page http://www.dofactory.com/Patterns/PatternAbstract.aspx mais,
à l'exécution, j'obtiens (j'ai rajouté quelques autres affichages par
rapport à l'exemple) :

Env received 16ConcreteFactory1 as factory.
Env creating Product 16AbstractProductA
Env creating Product 9ProductB1
P9ProductB1 interacts with P16AbstractProductA
In Environment, 16AbstractProductA interacts with 9ProductB1
Env received 16ConcreteFactory2 as factory.
Env creating Product 16AbstractProductA
Env creating Product 9ProductB2
9ProductB2 interacts with 16AbstractProductA
In Environment, 16AbstractProductA interacts with 9ProductB2

(avec g++ 3.4)

alors que normalement je m'attends d'après l'exemple à avoir des
ProductA1 ou ProductA2 à la place des AbstractProductA.

Le plus bizarre c'est que le schéma Factory semble bien fonctionner avec
les produits B et pas avec les produits A.

Je ne vois pas trop ce que je rate, mais c'est sans doute tout simple...

Sinon une autre question : pourquoi la fonction typeid(variable).name()
ne donne-t-elle pas un type de classe ou de variable bien propre comme
dans la plupart des docs mais rajoute quelques chiffres ? Par exemple,
pourquoi obtiens-je "9ProductB1" à la place de "ProductB1" ?


Mon code :

----------------------------------------------------------------------
#include<iostream>
using namespace std;
#include<typeinfo>

//http://www.dofactory.com/Patterns/PatternAbstract.aspx

// Abstract Factory pattern -- Structural example

//////////////////////////////////////////////////////////////
// Products


// "AbstractProductA"

class AbstractProductA
{
};

// "AbstractProductB"

class AbstractProductB
{
public:
// Methods
virtual void Interact( AbstractProductA* a )=0;
};

// "ProductA1"

class ProductA1 : public AbstractProductA
{
int a1;
};

// "ProductB1"

class ProductB1 : public AbstractProductB
{
public:
// Methods
virtual void Interact( AbstractProductA* a ) //const
{
//Console.WriteLine( this + " interacts with " + a );
cout<<typeid(this).name()<<" interacts with "<< typeid(a).name() <<
endl;

}
};

// "ProductA2"

class ProductA2 : public AbstractProductA
{
int a2;
};

// "ProductB2"

class ProductB2 : public AbstractProductB
{
public:
// Methods
virtual void Interact( AbstractProductA* a )
{
//Console.WriteLine( this + " interacts with " + a );
cout<<typeid(*this).name()<<" interacts with "<< typeid(*a).name() <<
endl;

}
};


//////////////////////////////////////////////////////////////
// "AbstractFactory"

class AbstractFactory
{
public:
// Methods
virtual AbstractProductA* CreateProductA() = 0;
virtual AbstractProductB* CreateProductB() = 0;
};

// "ConcreteFactory1"

class ConcreteFactory1 : public AbstractFactory
{
public:
// Methods
//virtual AbstractProductA* CreateProductA()
virtual ProductA1* CreateProductA()
{
return new ProductA1();
}
//virtual AbstractProductB* CreateProductB()
virtual ProductB1* CreateProductB()
{
return new ProductB1();
}
};

// "ConcreteFactory2"

class ConcreteFactory2 : public AbstractFactory
{
public:
// Methods
//virtual AbstractProductA* CreateProductA()
virtual ProductA2* CreateProductA()
{
return new ProductA2();
}

//virtual AbstractProductB* CreateProductB()
virtual ProductB2* CreateProductB()
{
return new ProductB2();
}
};

// "Client" - the interaction environment of the products

class Environment
{
private:
// Fields
AbstractProductA* AbstractProductA_;
AbstractProductB* AbstractProductB_;

public:
// Constructors
Environment( AbstractFactory* factory )
{
cout<<"Env received "<<typeid(*factory).name()<<" as factory.n";
AbstractProductA_ = factory->CreateProductA();
cout<<"Env creating Product
"<<typeid(*AbstractProductA_).name()<<endl;

AbstractProductB_ = factory->CreateProductB();
cout<<"Env creating Product
"<<typeid(*AbstractProductB_).name()<<endl;

}

// Methods
void Run()
{
AbstractProductB_->Interact( AbstractProductA_ );
cout<<"In Environment, ";
cout<<typeid(*AbstractProductA_).name()
<<" interacts with "
<< typeid(*AbstractProductB_).name() << endl;

}
};

/// <summary>
/// ClientApp test environment
/// </summary>
int main(){
AbstractFactory* factory1 = new ConcreteFactory1();
Environment* e1 = new Environment( factory1 );
e1->Run();

AbstractFactory* factory2 = new ConcreteFactory2();
Environment* e2 = new Environment( factory2 );
e2->Run();

return 0;
}
----------------------------------------------------------------------



Merci beaucoup par avance pour toute piste,

--
DW

Je me remets à C++ après quelques années de Python intensif,
et c'est dur, je suis très rouillé...

Je serai curieux de savoir ce qui te fait passer de python à
C++.

alors que normalement je m'attends d'après l'exemple à avoir
des ProductA1 ou ProductA2 à la place des AbstractProductA.

Le plus bizarre c'est que le schéma Factory semble bien
fonctionner avec les produits B et pas avec les produits A.

La différence de comportement s'explique par le fait que les
produits B sont polymorphiques alors que les produits A ne le
sont pas. (AbstractProductA ne comporte aucune méthode
virtuelle alors que AbstractProductB en possède une.)

Sinon une autre question : pourquoi la fonction
typeid(variable).name() > ne donne-t-elle pas un type de

classe ou de variable bien propre comme > dans la plupart des
docs mais rajoute quelques chiffres ? Par exemple, > pourquoi
obtiens-je "9ProductB1" à la place de "ProductB1" ?

Je ne sais pas ce que tu entends par "la plupart des docs"
mais je pense que le comportement de typeid(...).name() n'est
pas standard. Les implémentations doivent garantir l'unicité
du nom à priori.

Encore que là, il faut voir ce qui se passe entre différentes
compilations.

Je serai curieux de savoir ce qui te fait passer de python à C++.

Les deux langages s'adressent à de différents domaines d'application,
je crois. Python, c'est un langage de script ; il est hors question de
s'en servir pour la majorité de mes applications. En revanche, pour
les petits boulots d'appoint, il ne me vient pas à l'ésprit de me
lancer dans toutes les complexités de la compilation et des fichiers
make.