Discussion :

[Snark]

Bonjour à tous,

Voilà, j'ai un gros soucis de C++, qui vise les plus experts d'entre vous, même si le principe est simple.
Je voudrais rendre un operateur d'une classe utilisable sans qu'il soit "auto-défini".
Un exemple sera plus simple à comprendre :

Code C :

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
template<typename T>
class XX
{
  public:
    XX() {}
    T* operator()() { return new T; }
};
 
class YY
{
  public:
    YY() {}	
    template<typename T>
    T* operator()() { return new T; }
};
 
int main()
{
  int* x = XX<int>()();
  int* y = YY()<int>();
 
  return 0;
}

Donc, ici, la classe XX est utilisable tel quel pour remplir la variable x.
Par contre, ça ne m'interesse pas, et je voudrais pouvoir utiliser la surcharge par template uniquement sur la fonction (et non sur toute la classe), c'est à dire, la forme de YY.

Il n'y a pas de soucis avec la définition de classe, par contre, un appel direct de la forme ci-dessus ne compile même pas. Cette syntaxe fonctionne :

Code :

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

int* y = YY().operator()<int>();

Mais je perd l'intérêt de l'opérateur.... Quel syntaxe utiliser pour rendre cela possible ?

Merci.
Snark.

[loufoque]

Code :

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

int* y = YY().operator()<int>();

Est ici la seule syntaxe possible.

[JolyLoic]

Je ne vois pas franchement mieux que :

Code :

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

1
2
3
4
5
6
7
8
9
10
11
12
13
 
int * const IntTag = NULL;
double * const DoubleTag = NULL;
 
class YY
{
  public:
    YY() {}	
    template<typename T>
    T* operator(T *tag)() { return new T; }
};
 
int* y = YY()(IntTag);

Ou alors abandonner la classe YY et l'opérateur () pour avoir une simple fonction template YY.

[Snark]

Ha zut, bon, ben, dommage...

Je ne peux pas utiliser de fonction toute bête (enfin, c'est surtout une histoire de lisibilité de code au final). En faîte, mon exemple est mal choisi, car ce qui m'intéresse, c'est surtout la récupération de l'opérateur [].

[3DArchi]

En général, c'est la technique fournie par JolyLoic qui est employé : tu rajoutes un paramètre supplémentaire de type template (non utilisé) qui sert au compilateur à déterminer quelle surcharge de template il doit utiliser/instancier:

Code :

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

1
2
3
4
5
6
7
8
9
10
11
 
class YY
{
  public:
    YY() {}	
    template<typename T>
       T* operator[](T const& ) { return new T; }
}
 
...
YY()[int()];