Discussion :

[darkman19320]

Bonjour tout le monde,

J'ai une petite question dont je n'arrive pas à trouver de réponse sur le net: comment/peut-on utiliser std::enable_if avec les variadic templates pour activer ou non tel constructeur en fonction du nombre de paramètre?

Voici un petit exemple:

Code :

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

1
2
3
4
5
6
7
8
9
10
template<size_t SIZE = 3>
class Test
{
   public:
     template<typename... Args>
     Test(typename<std::enable_if<sizeof...(Args) <= SIZE, Args...>::type args) // J'ai essayé différentes syntaxe mais ça ne semble pas fonctionner
     {
      // blabla
     }
};

A l'heure actuelle, pour avoir le comportement voulu, j'utilise static_assert:

Code :

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

1
2
3
4
5
6
7
8
9
10
template<size_t SIZE = 3>
class Test
{
   public:
     template<typename... Args>
     Test(Args... args)
     {
        static_assert(sizeof...(Args) <= SIZE, "Trop d'arguments");
     }
};

C'est plus une question pour satisfaire ma curiosité sur tout ce qui tourne autour des variadic template qu'une réelle nécessité.

Merci d'avance

[jo_link_noir]

Mettre enable_if dans le paramètre template empêche la déduction automatique des types. Et comme on ne peut pas spécifier les types template d'un constructeur, cette solution n'en est pas viable (template variadique ou non).

Par contre, on peut mettre enable_if autre part:
- dans le type de retour (oups ) ou
- dans la liste des paramètres templates: template<class... Args, class = std::enable_if_t<sizeof...(Args) <= SIZE>> Test(Args... args).

[koala01]

Salut,

De manière générale, il y a deux situations possibles :
Soit tu veux adapter le comportement du constructeur par rapport au tydpe réel du paramètre template, en gardant le même nombre de paramètres du même type
Soit tu veux adapter le nombre (et le type éventuellement) des paramètres en fonction du paramètre template.

Dans le premier cas, il faudra placer std::enable_if dans la liste des paramètres, sous une forme proche de

Code :

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

1
2
3
4
5
6
7
8
9
10
11
12
template <typename T>
class MyClass{
public:
    template <typename U =  T>
    MyClass(Type1 p1, Type2 p2, std::enable_if< TestOnU::value>::type * = nullptr){  //(*)
       /* ... */
    }
    template <typename U =  T>
    MyClass(Type1 p1, Type2 p2, std::enable_if< OtherTestOnU::value>::type * = nullptr){ //(*)
       /* ... */
    }
};

parce que le nombre et le type des paramètres explicites demandés étant identique , les deux versions ne sont pas considérées comme étant des surcharges valides.

(*)TestOnU et OtherTestOnU seront sans doute différents type_traits tels que définis dans le fichier <type_traits> (ou des type_traits personnalisés)
Dans le deuxième cas tu peux placer std::enable_if dans la liste des paramètres template sous une forme qui pourrait être proche de

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
template<typename T, size_t SIZE>
class MathVector{
    using tab_t = std::array<T, SIZE>;
public:
    /* constructeur par défaut, commun à tous les types concrets */
    MathVector(){
        tab_.fill(T{});
    }
    /* pour un vecteur contenant deux valeurs uniquement */
    template <typename U,
                     std::enable_if<SIZE == 2>::type>
    MathVector(U v1, U v2):MathVector({v1,v2}){
    }
    /* pour un vecteur contenant trois valeurs uniquement */
    template <typename U,
                     std::enable_if<SIZE == 3>::type>
    MathVector(U v1, U v2, U v3):MathVector({v1,v2,v3}){
    }
    /* pour un vecteur contenant quatre valeurs uniquement */
    template <typename U,
                     std::enable_if<SIZE == 4>::type>
    MathVector(U v1, U v2, U v3, U v4):MathVector({v1,v2,v3, v4}){
    }
    MathVector(std::initializer_list const & l):tab_{l}{
    }
    T operator[](size_t index) const{
        assert(index < SIZE);
        return tab_[index],
    }
    T & operator[](size_t index) {
        assert(index < SIZE);
        return tab_[index],
    }
    /* sans doute d'autres trucs sympa, comme les fonctions begin et end, dans différentes versions */
private:
    tab_t tab_;
};

Dans ce cas, le nombre de paramètres attendus par le constructeur variant en fonction de la situation, chaque version est bel et bien à une surcharge valide

NOTA: j'ai écrit ce code "de mémoire" car j'en ai effectivement mis un semblable en place récemment, mais je ne garanti pas que les tests indiqués soient ceux qui sont effectivement nécessaires (en plus, je m'étais fait des type_traits du genre isVec2, isVec3 et isVec4 pour la facilité )

[jo_link_noir]

Il faut savoir qu'avec des variadiques, mettre enable_if dans les paramètres de fonction ne fonctionne pas. Le compilateur va ignorer la variadique à cause de la présence de valeur à droite et du coup on se retrouve avec une fonction variadique de taille 0.

[darkman19320]

Merci pour toutes vos réponses!

Je viens de tester avec les std::enable_if et j'obtiens bien le comportement souhaité: à savoir qu'il y ait une erreur de compilation si le nombre d'arguments n'est pas correct. Vu que je ne souhaite pas des comportements différents en fonction de la taille, je pense qu'il est plus sage pour moi d'utiliser les static_assert pour obtenir un message d'erreur plus compréhensible.