Variadic template et non-type parameter

Bonjour,

J'ai plusieurs types, pour le moment tous simples (int, short, char, etc...) et pour chacun de ces types j'ai entre 1 et 5 valeurs considérées comme non valides.
C'est très majoritairement 1 valeur invalide, mais je sais aussi que ça va évoluer.

Du coup je me suis dis que les templates variadic pourraient m'aider a faire un code générique et évolutif.
En gros ce que je voudrais c'est quelque chose du genre :

Code:

---

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19

void mafonction(int value) { validator<int, 0, 7, 22> vld; // 0, 7 et 22 sont des valeur non valide if(vld.validate(value)) { // ... La valeur est valide } }     void autrefonction(short value) { validator<short, 0> vld; // seul 0 est non valide ici if(vld.validate(value)) { // ... La valeur est valide } }

---

Sur le coup ça ne m'a pas paru si compliqué, mais c'est la première fois que j'utilises des variadic template et je ne m'en sort pas.
J'ai écris ça :

Code:

---

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20

template <typename TValue, TValue First, TValue... Args> struct validator { bool validate(TValue value) { validator<TValue, Args...> vld; return value != First && vld.validate(value); } };     template <typename TValue, TValue First> struct validator { bool validate(TValue value) { return value != First; } };

---

Comme ça je me disais que s'il n'y a qu'une valeur c'est le second template qui s'en chargeait, s'il y a plus de valeur c'est le premier template qui s'en charge. Et comme il s'appel directement avec en passant "Other..." mais pas "First", du coup a chaque invocation il se "débarrasse" d'un paramètre, jusqu'a arriver au moment où il lui reste 1 paramètre, et du coup ce devrait être le second template qui prend la suite.

Sauf qu'évidemment ça ne marche pas comme ça, le premier template reste celui qui est appellé, jusqu'a ce qu'Other ne contienne plus rien et on se retrouve a appeller un validator<TValue>, qui n'est pas définit puisqu'il manque un paramètre.
Et la je bloque un peu...
J'ai testé 36 écritures différentes mais je n'arrive pas a trouver comment déclarer tout ça correctement.

Quelqu'un peut m'éclairer svp ?

Petite question bonus :
Il n'y a rien dans le standard qui permet d'obtenir une bonne valeur d'initialisation par défaut ? En gros int i = std::default<int>();, ce qui donnerait 0 pour tous les numériques, nullptr pour tous les pointeur, et l'appel au constructeur par défaut pour tous les objets (en supposant qu'il existe). J'ai créé une suite de template pour faire ça mais je les ai baclés et si ca existe dans le standard c'est con de pas les utiliser.

Bonjour, il manque la struct qui ne recoit plus d'argument.
Cela peut aussi bien marcher avec la surcharge de fonctions :

Code:

---

1 2 3 4 5 6 7 8 9 10 11

template<typename T> bool is_valid(const T num) { return true; }   template<typename T, T value, T... tail> bool is_valid(const T num) { return num != value && is_valid<T, tail...>(num); }

---

Code:

---

1 2 3 4 5 6

int main() { int n = 5; std::cout << is_valid<int, 2, 4, 6, 8>(n); return 0; }

---

Et je passe la question bonus :roll:

Merci du coup de main !
Ton exemple fonctionne bien effectivement. Je savais qu'on pouvait se contenter de fonctions mais le but est de pouvoir se servir de ce template en tant qu'arguments d'autres templates.
C'est pour ça que je le voulais sous la forme de structure, afin que le validateur soit un membre du template qui l'utilise.
Typiquement je voulais faire des trucs du genre :

Code:

---

1 2 3 4 5 6 7 8 9 10 11 12 13 14

template <typename TValue, typename TValidator = validator<TValue>> class wrapper { private: TValue value_; // ... bool is_valid() { TValidator vld; return vld.validate(value_); } // ... }

---

Si c'est une fonction je ne vois pas trop comment écrire l'équivalent...
D'ailleurs, si je reprend ton code et que j'ajoute juste struct {}; autour, ca ne marche plus. C'était une des solutions que j'avais déjà tenté.

Pour ta question, réfléchi à deux fois avant d'utiliser des templates pour ce genre de chose. Es-tu sur à 100% que tu n'auras jamais à lire ces valeurs d'un fichier ? Quelles ne changeront pas en cours d'exécution ? Que tu ne devras pas en désactiver certaines en cours d'exécution ?

Pour ta question bonus, tu peux simplement utiliser int a = int(); ou int a(); ou int a{}; (la dernière seulement en C++11). Voir http://en.cppreference.com/w/cpp/lan...initialization

Et en rajoutant ceci ?

Code:

---

1 2 3 4 5

template<typename T, T... tail> struct Validator { bool validate(const T value) { return is_valid<T, tail...>(value); } };

---

Oui, j'en suis sur, certain, sans le moindre doute possible. Ce que je veux c'est bel et bien du compile-time. Je ne maitrise pas encore les variadic mais je sais bien faire la différence entre le compile-time et le run-time. Si c'était au runtime que j'avais besoin de ça je serai parti sur complètement autre chose. ;)

Pour la question bonus :
je ne savais pas que je pouvais écrire "int()" pour que ca retourne 0 (je connais la forme {} du c++11, mais la non plus, je ne savais pas qu'appliqué a un type builtin et sans valeur spécifiée on obtient "0").

Ah bah oui ! Tout simplement... Je cherchais vraiment a me compliquer la vie...
Merci bien ca marche nickel comme je le voulais !