Discussion :

[Aleph69]

Bonjour,

je viens de me décider à passer à la nouvelle norme et je regarde en ce moment le paramétrage variadique de classe. Je me demande dans quelle mesure il est possible d'attribuer des valeurs par défaut à ces petites bêtes. Je ne vois pas trop comment cela pourrait être possible et à ma connaissance on ne peut pas s'en sortir avec la spécialisation partielle vu que les valeurs par défaut ne sont pas autorisées dans ce cas.

Quelle est la solution?

Merci!

[germinolegrand]

Mmmh... s'en passer ?
La puissance des variadics c'est qu'ils peuvent être vides.
Dans la spécialisation où le paramètre variadic est vide, libre à toi de faire comme si on avait passé les valeurs par défaut.

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
 
template <class ... Args>
struct A;
 
template <class T1, class ... Args>
struct A<T1, Args...>
{
    using type = T1;
}
 
 
template <>
struct A<>
{
    using type = unsigned int;//ou ce que tu veux
}

edit: après si on souhaite avoir plusieurs paramètres par défaut, on peut faire un empilement de cette technique, mais ça devient très lourd...

edit2: et comme il y a plusieurs façon de faire (comme d'habitude), on peut également jouer avec l'opérateur sizeof... et quelques type_traits :

Code :

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

1
2
3
4
5
6
7
8
9
10
 
template <class ... Args>
struct A
{
    using type0 = std::conditional<(sizeof...(Args)> 0), std::tuple_element<0, std::tuple<Args...>>::type, int>;
 
    using type1 = std::conditional<(sizeof...(Args)> 1), std::tuple_element<1, std::tuple<Args...>>::type, unsigned int>;
 
    using type2 = std::conditional<(sizeof...(Args)> 2), std::tuple_element<2, std::tuple<Args...>>::type, short>;
}

Voilà, je pense que le dernier code correspond à ce que tu cherches à faire...

edit3: oui je sais il m'a fallu pas mal d'edit avant d'écrire une solution convenable

[Aleph69]

Bonjour,

merci pour ta réponse. En fait, j'ai du mal m'exprimer, je voulais bien parler de valeur par défaut, par exemple :

Code :

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

1
2
template<typename TYPE,size_t SIZE=0> class Array{TYPE val[SIZE];};
template<typename TYPE> class Array<TYPE,0>{TYPE* val;}

qui permet de gérer des allocations statiques et dynamiques. C'est pratique de mettre une valeur par défaut ici (en l'occurence zéro), cela permet d'écrire

Code :

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

1
2
Array<double,10> toto; // statique
Array<double> titi; // dynamique

plutôt que

Code :

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

1
2
Array<double,10> toto; // statique
Array<double,0> titi; // dynamique

[germinolegrand]

Imaginons qu'on puisse écrire template <size_t ... sizes = {2,3,4,5}>
Comment l'utiliserais-tu ?

[Aleph69]

Comme je le dis dans mon premier post, cela n'a pas de sens. Mais j'aimerais émuler ce comportement.

[Aleph69]

Je te donne un exemple de ce que je fais déjà en espérant que ça ne biaise pas trop les réponses. Pour le moment, j'émule déjà en quelque sorte ce comportement de la manière suivante :

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
template<typename TYPE, template<typename,size_t...> class Policy>,size_t... SIZES> 
class Array : public Policy<TYPE,... SIZES>
{};
 
template<typename TYPE, size_t SIZE=0> 
class Policy1
{
    TYPE val[SIZE];
};
template<typename TYPE> 
class Policy1<TYPE,0>
{
   size_t size;
   TYPE* val;
};
 
template<typename TYPE, size_t SIZE1,size_t SIZE2=0> 
class Policy2
{
    TYPE val[SIZE2];
};
template<typename TYPE,size_t SIZE1> 
class Policy2<TYPE,SIZE1,0>
{
   size_t size;
   TYPE* val;
};

Sauf que j'ai l'impression de gâcher : je me demande s'il n'y a pas plus intelligent avec les nouveaux outils à disposition.

[germinolegrand]

Dans ce cas on reprend mon 2e exemple :

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
 
 
namespace utils
{
 
template <size_t pos, class T, T ... args>
struct getv;
 
template <size_t pos, class T, T t1, T ... args>
struct getv<pos, T, t1, args...>
{
    static const T value = pos ? getv<pos - 1, T, args...>::value : t1;
};
 
}
 
 
template <size_t ... sizes>
struct A
{
    static const size_t s0 = sizeof...(sizes) > 0 ? utils::getv<0, size_t, sizes...>::value : 0;
    static const size_t s1 = sizeof...(sizes) > 1 ? utils::getv<1, size_t, sizes...>::value : 0;
    static const size_t s2 = sizeof...(sizes) > 2 ? utils::getv<2, size_t, sizes...>::value : 0;
};

edit: p.s: j'ai répondu sans voir ton nouveau message