Discussion :

[j-jorge]

Bonjour,

J'ai parfois vu l'utilisation d'un type enum pour stocker une valeur dans le cadre de la méta-programmation et je me demandais pourquoi utiliser cela plutôt qu'une constante membre statique du type de la donnée.

Dans l'exemple ci-dessous, val_enum et val_static servent tous les deux à stocker une valeur. Le premier utilise pour cela une énumération tandis que l'autre utilise une constante statique. Je ne vois que deux différences en pratique. D'une part, le compilateur m'affiche des avertissements lorsque je compare les valeurs énumérées. D'autre part, je me dis que les membres statiques peuvent éventuellement consommer un peu de mémoire dans le programme compilé, sinon je ne pourrais y faire référence comme à la fin du main() ci-dessous.

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
38
39
40
41
42
43
44
45
46
#include <iostream>
 
template<int N>
struct val_enum
{
  typedef int value_type;
 
  enum
    {
      value = N
    };
};
 
template<int N>
struct val_static
{
  typedef int value_type;
 
  static const int value = N;
};
 
template<typename Val1, typename Val2>
struct max_value
{
  enum
    {
      value_enum = (Val1::value > Val2::value) ? Val1::value : Val2::value
    };
 
  static const typename Val1::value_type value_static =
    (Val1::value > Val2::value) ? Val1::value : Val2::value;
};
 
int main()
{
  std::cout << max_value< val_enum<3>, val_enum<5> >::value_enum << std::endl;
  std::cout << max_value< val_static<5>, val_static<3> >::value_enum << std::endl;
 
  std::cout << max_value< val_enum<3>, val_enum<5> >::value_static << std::endl;
  std::cout << max_value< val_static<5>, val_static<3> >::value_static << std::endl;
 
  const int& a = val_static<1>::value;
  std::cout << a << std::endl;
 
  return 0;
}

Mes questions sont donc : dans quels cas faut-il préférer l'énumération à la variable membre statique*? et dans quels cas les constantes membres statiques consomment de la mémoire*?

[Lavock]

Désolé, je ne maitrise que très peu la méta-prog, mais je peux répondre à ta dernière question :

Tout le temps. Là ou un enum peut être remplacé par un #define (en un peu mieux car il à un type), une variable static est présente en mémoire sous son nom. Généralement, si elle est constante, elle est stocké dans le segment de code. Donc cela alourdie ton executable. S'il s'agit d'une dll critique, c'est pas glop. Sinon, c'est peut être pas super important.

Après, je dirai que en méta-prog j'ai plus souvent vu des enum. Mais c'est peut-être un hasard.

Ensuite, je dirai qu'avec les enum structuré de c++0x, la balance devrait pesait définitivement en faveur des enums... Mais là, je m'avance beaucoup au vue de ma maitrise du sujet >< !

[3DArchi]

Bonjour,

Mes questions sont donc : dans quels cas faut-il préférer l'énumération à la variable membre statique*? et dans quels cas les constantes membres statiques consomment de la mémoire*?

Certains (vieux) compilateurs ne supportaient pas l'initialisation en ligne de variable static constante entière :

Code :

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

1
2
3
4
 
struct toto{
   static const int valeur=0; // certains compilo rejettent cette ligne
}

C'est pour ça que parfois on trouve un enum :

Code :

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

1
2
3
4
 
struct toto{
   enum{ valeur=0}; // tjrs OK
}

Cela a récemment été abordé : [Metaprog] static const vs enum

[j-jorge]

Cela a récemment été abordé : [Metaprog] static const vs enum

Ça m'apprendra à chercher sur le forum

Merci