[Metaprog] Bloquer la compilation quand un paramètre de template est trop grand

Bonjour.

Dans son tutoriel sur la métaprogrammation, Laurent Gomila propose l'implémentation de la factorielle suivante :

Code:

---

1 2 3 4 5 6 7 8

template<unsigned int N> struct Factorielle { enum {Value = N * Factorielle<N - 1>::Value}; }; template<> struct Factorielle<0> { enum {Value = 1}; };

---

Je me demandais comment bloquer la compilation "message d'erreur" quand N est supérieur à 11 (car 12! dépasse 2^32)

Merci

EDIT :
J'en profite pour glisser une autre question. L'implémentation de la puissance entière est la suivante :

Code:

---

1 2 3 4 5 6 7 8

template <int N> inline double Puissance(double x) { return x * Puissance<N - 1>(x); } template <> inline double Puissance<0>(double x) { return 1.0; }

---

Pour travailler avec tous les types de données est-ce que l'implémentation suivante fonctionnerai :

Code:

---

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

template <int N, class T> inline T Puissance(T x) { return x * Puissance<N - 1>(x); } template <> inline T Puissance<0>(T x) { return (T)(1); }   int main () { double a = 3.15; double b; a = Puissance<10>(b); }

---

C'est à dire où dans l'utilisation que je fais de Puissance, le "class T" est détecté automatiquement et je n'ai pas à le spécifié ?

Salut,

Tout simplement, en spécialisant partiellement ta classe template pour une valeur donnée sans fournir la valeur énumérée attendue:

Code:

---

1 2 3 4 5

template < > struct Factorielle <12> { // rien dans le corps };

---

Quand le compilateur croisera la valeur 12 (ente autres quand il tentera de gérer 13), il réagira comme s'il s'agissait de traiter

Code:

---

1 2 3 4

struct Factorielle { enum {Value = 13 * Factorielle<12>::Value}; };

---

mais comme Factorielle<12>::value n'existe pas, il te le fera savoir par un message spécifique (mais peut etre un peu cryptique :D)

Une autre solution sur un compilateur récent : static_assert.

Code:

---

1 2 3 4 5

template<unsigned int N> struct Factorielle { static_assert(N<12, "Désolé, nombre trop gros"); enum {Value = N * Factorielle<N - 1>::Value}; };

---

Bonjour,

Pour répondre à la seconde question, je pense que oui.
Mais il faudra indiquer le paramètre template T dans la spécialisation.

Code:

---

1 2 3 4

template <class T> inline T Puissance<0>(T x) { return (T)(1); }

---

Ok, merci beaucoup.

Oui effectivement j'avais zappé le "class T" dans la spécialisation.

Une question : le static_assert c'est une nouveauté de C++2011 ? Est-ce que ça a un coût à l'exécution ou est-ce que tout est traité à la compilation (cout nul à l'exécution) ?

Oui c'est une nouveauté du C++11.
Aucun cout à l’exécution. Le but de static_assert est de faire échouer la compilation en reportant le message d'erreur passé en second paramètre si la condition est fausse.

Et si static_assert n'est pas disponible, Il est toujours possible d'utiliser BOOST_STATIC_ASSERT(), qui a un fonctionnement similaire.

Sinon, pour ce cas précis, on peut aussi faire dériver la classe struct Factorielle d'une classe FactorielCheck<bool> qui, pareil est définie pour true mais pas pour false.

Code:

---

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

template <class bool> struct check_factorielle; template <> struct check_factorielle<true> { };   template <unsigned int N> struct factorielle : factorielle_check<(N < MAX_N)> { enum { value = N * factorielle<N-1>::value }; }; template <> struct factorielle<0> { enum { value = 1 }; };

---

Citation:

---

Envoyé par Emmanuel Deloget

Et si static_assert n'est pas disponible, Il est toujours possible d'utiliser BOOST_STATIC_ASSERT(), qui a un fonctionnement similaire.

Sinon, pour ce cas précis, on peut aussi faire dériver la classe struct Factorielle d'une classe FactorielCheck<bool> qui, pareil est définie pour true mais pas pour false.

Code:

---

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

template <class bool> struct check_factorielle; template <> struct check_factorielle<true> { };   template <unsigned int N> struct factorielle : factorielle_check<(N < MAX_N)> { enum { value = N * factorielle<N-1>::value }; }; template <> struct factorielle<0> { enum { value = 1 }; };

---

---

C'est ca qui est bien avec la meta prog!!! il y a toujours plusieurs moyens d'arriver à un résultat donné :D

Ceci dit, ta méthode est encore meilleure, car le compilo refusera d'office toute valeur supérieure à MAX_N sans meme essayer de calculer, alors que la mienne ne refuserait qu'une seule valeur, et le compilo aura déjà essayé de calculer les constante pour tout N supérieur :P