definir - C++-enum vs. const vs.#define

como usar#define arduino

Question

Al final del artículo aquí: http://www.learncpp.com/cpp-tutorial/45-enumerated-types/ , menciona lo siguiente:

Finalmente, al igual que con las variables constantes, los tipos enumerados aparecen en el depurador, haciéndolos más útiles que los valores #defined en este aspecto .

¿Cómo se logra la oración en negrita anterior?

Gracias.

Answer 1

Al menos para Visual Studio 2008 que tengo a la mano, esta frase es correcta. Si usted tiene

#define X 3
enum MyEnum
{
    MyX = 3
};

int main(int argc, char* argv[])
{
    int i = X;
    int j = (int)MyX;
    return 0;
}

y estableces un breakpont en main , puedes pasar el mouse sobre "MyX" y ver que se evalúa a 3. No ves nada útil si pasas el cursor sobre X.

Pero esta no es una propiedad del lenguaje sino un comportamiento IDE. Las versiones siguientes pueden hacerlo de manera diferente, así como otros IDEs. Así que solo échale un vistazo a tu IDE para ver si esta oración aplica en tu caso.

Answer 2

Considera este código,

#define WIDTH 300

enum econst
{
   eWidth=300
};

const int Width=300;

struct sample{};

int main() 
{
        sample s;
        int x = eWidth * s; //error 1
        int y = WIDTH * s;  //error 2
        int z = Width * s;  //error 3
        return 0;
}

Obviamente, cada multiplicación da como resultado un error de compilación, pero vea cómo el GCC genera los mensajes para cada error de multiplicación:

prog.cpp: 19: error: no hay coincidencia para ''operator *'' en ''eWidth * s''
prog.cpp: 20: error: no hay coincidencia para ''operator *'' en ''300 * s''
prog.cpp: 21: error: no hay coincidencia para ''operator *'' en ''Ancho * s''

En el mensaje de error, no ve la WIDTH la macro que ha #defined , ¿verdad? Esto se debe a que cuando GCC intenta compilar la línea corresponde al segundo error, no ve WIDTH , solo ve 300, antes de que GCC compile la línea, el preprocesador ya ha reemplazado WIDTH por 300. Por otra parte mano, no hay tal cosa sucede con enum eWidth y const Width .

Vea el error usted mismo aquí: http://www.ideone.com/naZ3P

Además, lea el Item 2 : Prefer consts, enums, and inlines to #defines de Effective C ++ por Scott Meyers.

Answer 3

Consulte el siguiente artículo, buen resumen http://www.queryhome.com/26340/define-vs-enum-vs-constant

Answer 4

El compilador almacena información enum en el binario cuando el programa se compila con ciertas opciones.

Cuando una variable es de tipo enum, un depurador puede mostrar el nombre enum. Esto se ve mejor con un ejemplo:

enum E {
    ONE_E = 1,
};

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

    return 0;
}

Si compila eso con gcc -g puede probar lo siguiente en 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 utilizó un definir, no tendría un tipo adecuado para dar e , y tendría que usar un número entero. En ese caso, el compilador imprimirá 1 lugar de ONE_E .

La bandera -g le pide a gdb que agregue información de depuración al binario. Incluso puede ver que está allí emitiendo:

xxd test | grep ONE_E

Sin embargo, no creo que esto funcione en todas las arquitecturas.

Answer 5

Estoy respondiendo demasiado tarde, pero siento que puedo agregar algo: enum vs. const vs. #define

enum -

1. No requiere valores de asignación (si solo desea tener valores secuenciales 0, 1, 2 ..) mientras que en el caso de #defines necesita manualmente administrar valores que podrían ocasionar errores humanos en algún momento
2. Funciona tan variable como durante la depuración en línea, el valor de enum se puede ver en la ventana de observación

3. Puede tener una variable de tipo enum a la que puede asignar una enumeración

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

   int main (void) {number number = CASE_TRUE; }

const -

1. Se almacena de manera constante en el área de solo lectura de la memoria, pero se puede acceder usando una dirección que no es posible en caso de #define
   1. Tiene cheque de tipo en su mano si usa const en lugar de #define

2. define son directivas de preprocesamiento pero const es tiempo de compilación, por ejemplo

   const char * name = "vikas";

Puede acceder al nombre y usar su dirección base para leer, como vikas [3] para leer ''a'', etc.

#defines : son directivas de preprocesador tontas que reemplazan los textos

Answer 6

#define valores #define son reemplazados por el preprocesador con el valor en el que están declarados, por lo que en el depurador, solo ve el valor, no el nombre #defined, por ejemplo, si tiene #define NUMBER_OF_CATS 10, en el depurador podrá ver solo 10 (dado que el preprocesador ha reemplazado cada instancia de NUMBER_OF_CATS en su código con 10).

Un tipo enumerado es un tipo en sí mismo y los valores son instancias constantes de este tipo, por lo que el preprocesador lo deja solo y verá la descripción simbólica del valor en el depurador.

Answer 7

enum es una constante de tiempo de compilación con información de depuración sin asignación de almacenamiento.

const se asigna con un almacenamiento, dependiendo de si el compilador lo optimiza con propagación constante.

#define no tiene asignación de almacenamiento.