Discussion :

[benlaug]

Bonjour à tous,

Me voilà (oui, encore une fois ), confronté à un problème face à C++. Mon problème est le suivant : j'ai une classe

Code :

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

Image<T>

Je voudrais faire une méthode usine pour l'instancier et renvoyer l'instance à partir d'un enum donné en argument (classique). Donc par exemple :

Code :

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

1
2
3
 
template <typename T>
Image<T>* factoryMethod(myEnum arg);

Mon GRAND problème, c'est que avec ce genre de construction, l'appelant va devoir paramétrer explicitement l'appel de la fonction, ce qui bien sûr enlève tout l'intérêt de la méthode usine.

Donc par exemple :

Code :

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

factoryMethod<int>(IMAGE_TYPE);

fonctionnera contrairement à :

Code :

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

factoryMethod(IMAGE_TYPE);

Ma question est tout simplement, est-ce qu'il existe une technique pour résoudre ce problème ?

Merci beaucoup,

Benjamin

[Flob90]

Qu'est ce qui détermine le choix du type ? Est-ce lié à l'argument passé ? Si c'est le cas cet argument est-il déterminé à la compilation ou au runtime ?

[benlaug]

Qu'est ce qui détermine le choix du type ? Est-ce lié à l'argument passé ? Si c'est le cas cet argument est-il déterminé à la compilation ou au runtime ?

Le choix du type est directement lié à la constante passée en argument. L'utilisateur fournira explicitement cet argument à la méthode usine lorsqu'il l'appellera. Je dirais donc à la compilation.

[Klaim]

Si le type de retour peut être n'importe quoi, il va falloir soit que l'utilisateur ait une interface, soit qu'il connaisse déjà le type final.

[screetch]

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
enum ImageTypeEnum
{
  IMAGE_FLOAT_RGBA,
  IMAGE_GRAYSCALE, // je ne sais pas plus
};
 
template<ImageTypeEnum type>
struct ImageTypeEnumToImageType;
 
template< >
struct ImageTypeToType<IMAGE_FLOAT_RGBA>
{
    typedef float ImageType[4];
};
 
template< >
struct ImageTypeToType<IMAGE_GRAYSCALE>
{
    typedef int ImageType;
};
 
 
struct Factory
{
  template< ImageTypeEnum imageType >
  static Image< ImageTypeEnumToImageType<imageType>::ImageType > factoryMethod();
};
 
Image<int> image = Factory::factoryMethod<IMAGE_GRAYSCALE>();
Image<float[4]> image = Factory::factoryMethod<IMAGE_FLOAT_RGBA>();
// ne compilera pas:
Image<int> image = Factory::factoryMethod<IMAGE_FLOAT_RGBA>();

a partir du moment ou tu passes en dynamique (un paramètre de méthode) tu n'as plus la possibilité de faire du template (qui est compilé en statique). En transformant ton paramètre de méthode en paramètre de template, tu retombes sur tes pieds.

[benlaug]

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
enum ImageTypeEnum
{
  IMAGE_FLOAT_RGBA,
  IMAGE_GRAYSCALE, // je ne sais pas plus
};
 
template<ImageTypeEnum type>
struct ImageTypeEnumToImageType;
 
template< >
struct ImageTypeToType<IMAGE_FLOAT_RGBA>
{
    typedef float ImageType[4];
};
 
template< >
struct ImageTypeToType<IMAGE_GRAYSCALE>
{
    typedef int ImageType;
};
 
 
struct Factory
{
  template< ImageTypeEnum imageType >
  static Image< ImageTypeEnumToImageType<imageType>::ImageType > factoryMethod();
};
 
Image<int> image = Factory::factoryMethod<IMAGE_GRAYSCALE>();
Image<float[4]> image = Factory::factoryMethod<IMAGE_FLOAT_RGBA>();
// ne compilera pas:
Image<int> image = Factory::factoryMethod<IMAGE_FLOAT_RGBA>();

a partir du moment ou tu passes en dynamique (un paramètre de méthode) tu n'as plus la possibilité de faire du template (qui est compilé en statique). En transformant ton paramètre de méthode en paramètre de template, tu retombes sur tes pieds.

Un grand merci, c'est exactement le type de solution que je cherchais. Je n'ai plus qu'à l'arranger à ma sauce. Encore merci .