Sintaxis
enumeración <Nombre del tipo de enumeración> {Enumeration_Constant_Element-1,
Enumeration_Constant_Element-2,
Enumeration_Constant_Element-3,
…….........,
Enumeration_Constant_Element-norte,
};
El valor predeterminado de Enumeration_Constant_Element-1 es 0, el valor de Enumeration_Constant_Element-2 es 1, el valor de Enumeration_Constant_Element-3 es 2 y el valor de Enumeration_Constant_Element-n es (n-1).
Profundización en Enum
Ahora, dado que conocemos la sintaxis para definir el tipo de enumeración, veamos un ejemplo:
enumeraciónError{
IO_ERROR,
ERROR DE DISCO,
ERROR DE RED
};
La palabra clave enum siempre debe usarse para definir el tipo de enumeración. Entonces, siempre que desee definir un tipo de enumeración, debe usar la palabra clave enum antes. Después de la palabra clave enum, debe usar un identificador válido para definir el.
En el ejemplo anterior, el compilador asignará IO_ERROR al valor integral: 0, DISK_ERROR al valor integral: 1 y NETWORK_ERROR al valor integral: 2. De forma predeterminada, al primer elemento enum siempre se le asigna el valor 0, al siguiente al elemento enum se le asigna el valor 1, y así sucesivamente.
Este comportamiento predeterminado se puede cambiar si es necesario asignando el valor integral constante explícitamente, de la siguiente manera:
enumeraciónError{IO_ERROR= 2,
ERROR DE DISCO,
ERROR DE RED= 8 ,
PRINT_ERROR
};
En este caso, el programador asigna explícitamente IO_ERROR a un valor de 2, el compilador asigna DISK_ERROR a un valor de 3, el programador asigna explícitamente NETWORK_ERROR al valor de 8, y PRINT_ERROR le asigna el siguiente valor. valor integral del elemento de enumeración anterior NETWORK_ERROR (es decir, 9) por el compilador.
Entonces, ahora comprende cómo definir un tipo de enumeración definido por el usuario en C. ¿Es posible declarar una variable de tipo enum (como podemos declarar una variable de tipo entero)? ¡Sí lo es! Puede declarar la variable enum de la siguiente manera:
enumeraciónError Hw_Error;Nuevamente, enum es la palabra clave aquí, Error es el tipo de enumeración y Hw_Error es una variable de enumeración.
Ahora veremos los siguientes ejemplos para comprender los diversos usos de enum:
- Ejemplo 1: uso de la definición de enumeración predeterminada
- Ejemplo 2: uso de la definición de enumeración personalizada
- Ejemplo 3: definición de enumeración usando expresión constante
- Ejemplo 4: ámbito de enumeración
Ejemplo 1: uso de definición de enumeración predeterminada
En este ejemplo, aprenderá a definir el tipo de enumeración con valores constantes predeterminados. El compilador se encargará de asignar los valores predeterminados a los elementos de enumeración. A continuación, verá el programa de ejemplo y la salida correspondiente.
#incluir/ * Definir el tipo de enumeración * /
enumeraciónError{
IO_ERROR,
ERROR DE DISCO,
ERROR DE RED
};
En tprincipal()
{
enumeraciónError Hw_Error; / * Creando variable de enumeración * /
printf ('Estableciendo Hw_Error en IO_ERROR orte');
Hw_Error=IO_ERROR;
printf ('Valor de Hw_Error =% d orte',Hw_Error);
printf (' orteEstableciendo Hw_Error en DISK_ERROR orte');
Hw_Error=ERROR DE DISCO;
printf ('Valor de Hw_Error =% d orte',Hw_Error);
printf (' orteEstableciendo Hw_Error en NETWORK_ERROR orte');
Hw_Error=ERROR DE RED;
printf ('Valor de Hw_Error =% d orte',Hw_Error);
regreso 0;
}
Ejemplo 2: uso de definición de enumeración personalizada
En este ejemplo, aprenderá a definir el tipo de enumeración con un valor constante personalizado. Además, este ejemplo le ayudará a comprender cómo se puede realizar la inicialización de constantes personalizadas en cualquier orden aleatorio. En este ejemplo, hemos definido explícitamente el valor constante para el 1S ty 3rdelementos de enumeración (es decir, IO_ERROR y NETWORK_ERROR, respectivamente), pero hemos omitido la inicialización explícita para el 2Dakota del Nortey 4thelementos. Ahora es responsabilidad del compilador asignar los valores predeterminados a los 2Dakota del Nortey 4thelementos de enumeración (es decir, DISK_ERROR y PRINT_ERROR, respectivamente). DISK_ERROR se asignará a un valor de 3 y PRINT_ERROR se asignará a un valor de 9. A continuación, verá el programa de ejemplo y la salida.
#incluir/ * Definir el tipo de enumeración - Inicialización personalizada * /
enumeraciónError{
IO_ERROR= 2,
ERROR DE DISCO,
ERROR DE RED= 8,
PRINT_ERROR
};
En tprincipal()
{
/ * Declarar variable de enumeración * /
enumeraciónError Hw_Error;
printf ('Estableciendo Hw_Error en IO_ERROR orte');
Hw_Error=IO_ERROR;
printf ('Valor de Hw_Error =% d orte',Hw_Error);
printf (' orteEstableciendo Hw_Error en DISK_ERROR orte');
Hw_Error=ERROR DE DISCO;
printf ('Valor de Hw_Error =% d orte',Hw_Error);
printf (' orteEstableciendo Hw_Error en NETWORK_ERROR orte');
Hw_Error=ERROR DE RED;
printf ('Valor de Hw_Error =% d orte',Hw_Error);
printf (' orteEstableciendo Hw_Error en PRINT_ERROR orte');
Hw_Error=PRINT_ERROR;
printf ('Valor de Hw_Error =% d orte',Hw_Error);
regreso 0;
}
Ejemplo 3: Definición de enumeración mediante expresión constante
En este ejemplo, aprenderá a usar la expresión constante para definir el valor constante de los elementos enum.
#incluir/ * Definir el tipo de enumeración - inicialización personalizada usando expresión constante
La expresión constante se usa aquí en el caso de:
una. IO_ERROR y
B. ERROR DE RED
Esta es una forma inusual de definir los elementos enum; sin embargo, esto
El programa demuestra que esta forma de inicialización de elementos de enumeración es posible en c.
*/
enumeraciónError{
IO_ERROR= 1 + 2 * 3 + 4,
ERROR DE DISCO,
ERROR DE RED= 2 == 2,
PRINT_ERROR
};
En tprincipal()
{
/ * Declarar variable de enumeración * /
enumeraciónError Hw_Error;
printf ('Estableciendo Hw_Error en IO_ERROR orte');
Hw_Error=IO_ERROR;
printf ('Valor de Hw_Error =% d orte',Hw_Error);
printf (' orteEstableciendo Hw_Error en DISK_ERROR orte');
Hw_Error=ERROR DE DISCO;
printf ('Valor de Hw_Error =% d orte',Hw_Error);
printf (' orteEstableciendo Hw_Error en NETWORK_ERROR orte');
Hw_Error=ERROR DE RED;
printf ('Valor de Hw_Error =% d orte',Hw_Error);
printf (' orteEstableciendo Hw_Error en PRINT_ERROR orte');
Hw_Error=PRINT_ERROR;
printf ('Valor de Hw_Error =% d orte',Hw_Error);
regreso 0;
}
Ejemplo 4: ámbito de enumeración
En este ejemplo, aprenderá cómo funciona la regla de ámbito para enum. Se podría haber usado una MACRO (#define) para definir una constante en lugar de la enumeración, pero la regla de alcance no funciona para MACRO.
#incluirEn tprincipal()
{
/ * Definir el tipo de enumeración * /
enumeraciónError_1{
IO_ERROR= 10,
ERROR DE DISCO,
ERROR DE RED= 3,
PRINT_ERROR
};
{
/ * Definir el tipo de enumeración en el ámbito interno * /
enumeraciónError_1{
IO_ERROR= 20,
ERROR DE DISCO,
ERROR DE RED= 35,
PRINT_ERROR
};
/ * Declarar variable de enumeración * /
enumeraciónError_1 Hw_Error;
printf ('Estableciendo Hw_Error en IO_ERROR orte');
Hw_Error=IO_ERROR;
printf ('Valor de Hw_Error =% d orte',Hw_Error);
printf (' orteEstableciendo Hw_Error en DISK_ERROR orte');
Hw_Error=ERROR DE DISCO;
printf ('Valor de Hw_Error =% d orte',Hw_Error);
printf (' orteEstableciendo Hw_Error en NETWORK_ERROR orte');
Hw_Error=ERROR DE RED;
printf ('Valor de Hw_Error =% d orte',Hw_Error);
printf (' orteEstableciendo Hw_Error en PRINT_ERROR orte');
Hw_Error=PRINT_ERROR;
printf ('Valor de Hw_Error =% d orte',Hw_Error);
}
regreso 0;
}
Comparación entre enumeración y macro
| Enum | Macro |
| La regla de alcance se aplica a la enumeración. | La regla de alcance no es aplicable a Macro. |
| La asignación de valor predeterminada de Enum ocurre automáticamente. Enum es muy útil para definir una gran cantidad de constantes. El compilador toma la inicialización de valor constante predeterminado. | Los valores de la macro constante siempre deben ser mencionados explícitamente por el programador. Este podría ser un proceso tedioso para una gran cantidad de constantes, ya que el programador siempre debe definir manualmente cada valor constante al definir la macro. |
Conclusión
El programa enum en C podría considerarse un método opcional para programas independientes o proyectos de pequeño tamaño, ya que los programadores siempre pueden usar macro en lugar de una enumeración. Sin embargo, los programadores experimentados tienden a usar enum sobre macro para proyectos de desarrollo de software a gran escala. Esto ayuda a escribir programas limpios y legibles.