Bonjour tout le monde,

Je suis en train de voir comment faire une fabrique pour des patrons de classes:
Code : Sélectionner tout - Visualiser dans une fenêtre à part
1
2
3
4
template<typename PixelType, size_t ImageDim>
class Image
{
};
Je sais que ça ne fonctionne pas mais j'aimerai un quelque chose de ce style:
Code : Sélectionner tout - Visualiser dans une fenêtre à part
1
2
3
4
5
6
7
8
9
10
11
12
auto createImage(const char * pixelType, size_t ImageDim)
{
   switch(ImageDim){
     case 2:
     constexpr size_t dim = 2;
     switch(pixelType){
       case "short":
            return std::make_shared<Image<short, dim>>();
      // idem pour les autres types de données possibles (char, long, unsigned char....) et dimensions possibles (1D, 2D, 3D, 4D)
     }
   }
}
Ce que j'avais imaginé au début, c'est de faire une classe de base dont hérite la classe Image et créer des fabriques pour chaque possibilités d'image. Seulement, je ne peux pas modifier cette classe image... Du coup, j'ai eu une autre idée:
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
enum PixelType
{
  CHAR, 
  SHORT, 
  INT, 
  LONG
};
 
template<typename PType, size_t Dim>
class Image
{
};
 
class AbstractImage
{
};
 
template<typename PType, size_t ImageDim>
class ImageImpl : public AbstractImage, public Image<PType, ImageDim>
{
    public:
        ImageImpl() { std::cout << "Image<" << typeid(PType).name() << ", " << ImageDim << ">" << std::endl; }
};
 
class CreatorImage
{
public:
	virtual std::shared_ptr<AbstractImage> create() = 0;
};
 
template<class T>
class CreatorImageImpl : public CreatorImage
{
public:
	virtual std::shared_ptr<AbstractImage> create() { return std::make_shared<T>(); }
};
 
class FactoryImage
{
public:
	static void registerCreator(PixelType type, size_t dim, std::shared_ptr<CreatorImage> creator)
	{
		creatorMap()[dim][type] = creator;
	}
 
	std::shared_ptr<AbstractImage> create(PixelType type, size_t dim) const
	{
		return creatorMap().at(dim).at(type)->create();
	}
 
private:
	static std::map<size_t, std::map<PixelType, std::shared_ptr<CreatorImage>>> & creatorMap()
	{
	    static std::map<size_t, std::map<PixelType, std::shared_ptr<CreatorImage>>> map;
	    return map;
	}
};
 
int main()
{
    FactoryImage::registerCreator(PixelType::CHAR, 2, std::make_shared<CreatorImageImpl<ImageImpl<char, 2>>>());
    FactoryImage factory;
    factory.create(PixelType::CHAR, 2);
}
Ce code fonctionne, on peut ajouter plus ou moins autant de type que l'on souhaite, mais j'aime pas trop la map de map, le fait d'enregistrer des "Creator" et surtout de devoir surcharger une classe Abstraite (qui implique plus ou moins de redéfinir les fonctions présentent dans la classe Image pour plus de commodités).

Est-ce que quelqu'un à d'autres suggestions?

Merci