Gestion des exceptions (meta-programmation)

Version imprimable

Bonjour

Je me demande si il existe des instructions pour déclencher une erreur ou un avertissement du compilateur.

Exemple:
Code:

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 template<int T> class MaClasse { public: MaClasse(){} ~MaClasse(){} }; template<> class MaClasse<5> { public: MaClasse(){/* instruction déclenchant une erreur ou un avertissement à la compilation */} ~MaClasse(){} };
Dans l'exemple ci-dessus toute les valeurs entières peuvent être passé en paramètre template sauf la valeur 5 qui déclenche une erreur ou un avertissement.

Mon but est de gérer les exceptions comme avec try/throw/catch, mais à la compilation et non à l'exécution.

Il y a l'instruction #error qui déclenche une erreur à la compilation mais comme celle-ci est une commande du préprocesseur je ne crois pas qu'elle puisse m'aider.

Ces instructions existent-elles et sinon, comment fait-on pour gérer les "meta-exceptions"?

Merci de prendre le temps de me répondre.

08/03/2009, 08h31
loufoque

Ce ne sont pas des exceptions, puisqu'il s'agit d'erreurs non recoverables.
Cherche static_assert...
08/03/2009, 10h32
JolyLoic

Ou BOOST_STATIC_ASSERT sur les compilateurs qui n'implémentent pas encore static_assert, qui est une fonctionnalité de la prochaine norme C++, après tout.
08/03/2009, 22h17
Kalith

Sans avoir à utiliser boost : click.
09/03/2009, 10h06
3DArchi

Bonjour,
Tu peux aussi utiliser boost enable_if (et son pendant, disable_if) .

À moins que je sois dans l'erreur, ce qui n'est pas improbable car je suis mauvais en anglais, tout les liens que vous m'avez donnés nécessitent soit la bibliothèque Boost ou le mot-clé static_assert...

Je suis allé sur la FAQ pour apprendre ce qu'est la bibliothèque Boost et elle me semble très utile, apprendre à m'en servir est une des prochaines choses que je ferai.

J'ai vérifié et mon EDI ne semble pas connaître le mot static_assert.

Donc, la seule solution sans Boost ni static_assert que j'ai trouvé est celle-ci:
Code:

1 2 3 4 5 6 7 8 9 10 11 12 13 14 template<bool> struct Test{}; template<> struct Test<true>{ static void Do(){}; }; template<int T> class MaClasse { public: MaClasse(){ Test<T != 5>::Do(); } ~MaClasse(){} };
Cette technique n'est pas très élégante...
Premièrement, je ne peux déclencher que des erreurs, pas d'avertissements et deuxièmement, j'aurais aimé envoyer un message au compilateur expliquant la nature du problème, comme avec les assertions statiques.

Si boost fonctionne avec des compilateurs qui n'implémente pas static_assert, ce que je cherche à faire est possible sans boost ni static_assert, mais peut-être est-ce long et compliqué à implémenter.
Sinon, j'aimerais bien savoir comment le faire moi-même.

Merci de pardonner ma manie de réinventer la roue.

Bonjour,
Effectivement tu aurais tout intérêt à t'intéresser à Boost plutôt qu'à réinventer la roue :mouarf:

Cependant, en m'inspirant fortement du code boost, voilà une (mauvaise) façon de faire :

Code:

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
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
 
namespace mon_check_a_moi
{
   template<bool> struct check_{};
   template<> struct check_<true>
   {
      template<class T> check_(T const &);
   };
}
#ifdef _MSC_VER
#    define MON_CAT(a, b) MON_CAT_OO((a, b))
#    define MON_CAT_OO(par) MON_CAT_I ## par
#    define MON_CAT_I(a, b) MON_CAT_II(a ## b)
#    define MON_CAT_II(res) res
#else
#  define MON_CAT(a, b) MON_CAT_I(a,b)
#  define MON_CAT_I(a, b) a ## b
#endif
 
 
#define MY_CHECK(condition,message)\
   struct message;\
   struct MON_CAT(message,__LINE__)\
   { \
       static int ************ (message::************ erreur_()) (); \
   }; \
   enum{\
      MON_CAT(erreur,__LINE__) = sizeof(mon_check_a_moi::check_<condition>(MON_CAT(message,__LINE__)::erreur_()))\
}
 
 
template<int T> class MaClasse
{
public:
   MY_CHECK(T!=5,T_DOIT_ETRE_DIFFERENT_DE_5);
 
   MY_CHECK(T!=2,T_DOIT_ETRE_DIFFERENT_DE_2);
 
	MaClasse(){
	}
	~MaClasse(){}
};
 
int main()
{
   MaClasse<4> a;
 
   MaClasse<5> a2;
   MaClasse<2> a2;
 
return 0;
}