[C++] C ++ - enum contre const contre #define


Answers

enum est une constante de temps de compilation avec des informations de débogage sans allocation de stockage.

const est affecté à un stockage, selon qu'il est optimisé par le compilateur avec une propagation constante.

#define n'a aucune allocation de stockage.

Question

À la fin de l'article ici: http://www.learncpp.com/cpp-tutorial/45-enumerated-types/ , il mentionne ce qui suit:

Enfin, comme pour les variables constantes, les types énumérés apparaissent dans le débogueur, ce qui les rend plus utiles que les valeurs définies à cet égard .

Comment la phrase audacieuse ci-dessus est-elle réalisée?

Merci.




Le compilateur stocke les informations enum dans le fichier binaire lorsque le programme est compilé avec certaines options.

Lorsqu'une variable est d'un type enum, un débogueur peut afficher le nom d'enum. Ceci est mieux montré avec un exemple:

enum E {
    ONE_E = 1,
};

int main(void)
{
    enum E e = 1;

    return 0;
}

Si vous compilez cela avec gcc -g vous pouvez essayer ce qui suit dans gdb :

Reading symbols from test...done.
(gdb) b main
Breakpoint 1 at 0x804839a: file test.c, line 8.
(gdb) run
Starting program: test 

Breakpoint 1, main () at test.c:7
7               enum E e = 1;
(gdb) next
9               return 0;
(gdb) print e
$1 = ONE_E
(gdb) 

Si vous utilisiez un define, vous n'auriez pas un type correct pour donner e , et vous devrez utiliser un entier. Dans ce cas, le compilateur imprime 1 au lieu de ONE_E .

L' -g demande à gdb d'ajouter des informations de débogage au binaire. Vous pouvez même voir qu'il est là en émettant:

xxd test | grep ONE_E

Je ne pense pas que cela fonctionnera dans toutes les architectures, cependant.




Je réponds trop tard mais je sens que je peux ajouter quelque chose - enum vs const contre #define

enum -

  1. Ne nécessite pas de valeurs d'assertion (si vous voulez juste avoir des valeurs séquentielles 0, 1, 2 ..) alors que dans le cas de #defines vous devez manuellement gérer des valeurs qui pourraient causer des erreurs humaines à un moment donné
  2. Cela fonctionne tout aussi bien pendant le débogage en ligne que la valeur d'enum peut être regardée dans la fenêtre de la montre
  3. Vous pouvez avoir une variable de type enum à laquelle vous pouvez affecter une énumération

    typedef nombres enum {DFAULT, CASE_TRUE, CASE_OTHER,};

    int main (void) {numéros nombre = CASE_TRUE; }

const -

  1. Il est stocké en permanence dans la zone de lecture seule de la mémoire mais peut être accédé en utilisant une adresse qui n'est pas possible dans le cas de #define
    1. Vous avez le type check dans votre main si vous utilisez const plutôt que #define
  2. définit sont la directive de pré-traitement, mais const est le temps de compilation par exemple

    const char * nom = "vikas";

Vous pouvez accéder au nom et utiliser son adresse de base pour lire tel que vikas [3] pour lire "a" etc.

#defines - sont des directives de préprocesseur stupides qui font le remplacement textuel