Discussion :

[olivier_78]

Bonjour,

J'ai une classe du genre:

Code :

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

1
2
3
4
5
6
7
8
 
template<typename T>
class Test
{
  public:
 
    My_Type foo(const My_type& value);
};

En fait j'aimerais faire en sorte que:
si T = int, alors My_type = int,
si T = vector<int>, alors My_type = int,

en gros si T est un nombre alors My_Type = T
si T est un vecteur de nombre, alors My_Type = nombre.

J'ai essayé avec std:conditional<std::is_arithmetic, .....
sans succès.

Si vous avez une idée, ça m'intéresse :-)

Un grand merci par avance en tout cas.

Olivier

[cob59]

On y arrive généralement avec une classe de traits, même si ça peut être un peu verbeux :

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
#include <vector>
 
// Comportement par défaut, pour les types qui ne sont pas concernés par les spécialisation de TestTraits qui vont suivre
template <class T>
struct TestTraits {
    // Commenter si aucun comportement par défaut n'est souhaité :
    typedef T type;
};
 
// Spécialisation pour le type int
template <>
struct TestTraits<int> {
    typedef int type;
};
 
// Spécialisation partielle, pour un vector
template <class T>
struct TestTraits<std::vector<T>> {
    typedef T type;
};
 
template<typename T>
struct Test
{
    typedef typename TestTraits<T>::type My_Type;
    My_Type foo(const My_Type& value);
};

[olivier_78]

Super,

J'avais un peut regardé ce type de class mais je n'avais pas un exemple simple me permettant de comprendre, donc merci beaucoup?.

C'est vrai que c'est très verbeux, ca aurait été pas mal de pouvoir écrire quelque chose comme int::value_type, ca aurait été un appel générique avec les vecteur.

Je vais creuser ma formation des class trait.

Encore merci.

[Bousk]

Bonjour,

sans passer par des traits, ne peut-on avoir une syntaxe comme telle:

Code :

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

1
2
3
4
5
template<class content, class type = content >
class Test
{
  type foo(const content& value);
};

Code absolument pas testé.

Mais à l'utilisation j'aime bien l'idée:

Code :

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

1
2
Test<int> testint;
Test<vector<int>, int> testvectorint;