Cómo usar enum en lenguaje C

El programa enum en el lenguaje de programación C se usa para definir valores constantes integrales, lo cual es muy útil para escribir programas limpios y legibles. Los programadores normalmente utilizan la enumeración para definir constantes integrales con nombre en sus programas para proporcionar una mejor legibilidad y capacidad de mantenimiento del software. Este artículo discutirá la enumeración en detalle.

Sintaxis

enumeración
Enumeration_Constant_Element-1,
Enumeration_Constant_Element-2,
Enumeration_Constant_Element-3,
.. ,
Enumeration_Constant_Element-n,
;

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:

enum Error
IO_ERROR,
ERROR DE DISCO,
ERROR DE RED
;

La palabra clave "enum" siempre debe usarse para definir el tipo de enumeración. Por lo tanto, siempre que desee definir un tipo de enumeración, debe utilizar la palabra clave "enum" antes . Después de la palabra clave "enum", debe utilizar 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 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:

enum Error
IO_ERROR = 2,
ERROR DE DISCO,
NETWORK_ERROR = 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 al siguiente valor integral del elemento de enumeración anterior NETWORK_ERROR (i.mi., 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ón Error 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 * /
enum Error
IO_ERROR,
ERROR DE DISCO,
ERROR DE RED
;
int main ()

enumeración Error Hw_Error; / * Creando variable de enumeración * /
printf ("Estableciendo Hw_Error en IO_ERROR \ n");
Hw_Error = IO_ERROR;
printf ("Valor de Hw_Error =% d \ n", Hw_Error);
printf ("\ nConfigurando Hw_Error en DISK_ERROR \ n");
Hw_Error = DISK_ERROR;
printf ("Valor de Hw_Error =% d \ n", Hw_Error);
printf ("\ nConfigurando Hw_Error en NETWORK_ERROR \ n");
Hw_Error = NETWORK_ERROR;
printf ("Valor de Hw_Error =% d \ n", Hw_Error);
return 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 lo 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 1^{S t} y 3^rd elementos de enumeración (i.mi., IO_ERROR y NETWORK_ERROR, respectivamente), pero hemos omitido la inicialización explícita para el 2^{Dakota del Norte} y 4^th elementos. Ahora es responsabilidad del compilador asignar los valores predeterminados a los 2^{Dakota del Norte} y 4^th elementos de enumeración (i.mi., 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 * /
enum Error
IO_ERROR = 2,
ERROR DE DISCO,
NETWORK_ERROR = 8,
PRINT_ERROR
;
int main ()

/ * Declarar variable de enumeración * /
enum Error Hw_Error;
printf ("Estableciendo Hw_Error en IO_ERROR \ n");
Hw_Error = IO_ERROR;
printf ("Valor de Hw_Error =% d \ n", Hw_Error);
printf ("\ nConfigurando Hw_Error en DISK_ERROR \ n");
Hw_Error = DISK_ERROR;
printf ("Valor de Hw_Error =% d \ n", Hw_Error);
printf ("\ nConfigurando Hw_Error en NETWORK_ERROR \ n");
Hw_Error = NETWORK_ERROR;
printf ("Valor de Hw_Error =% d \ n", Hw_Error);
printf ("\ nConfigurando Hw_Error en PRINT_ERROR \ n");
Hw_Error = PRINT_ERROR;
printf ("Valor de Hw_Error =% d \ n", Hw_Error);
return 0;

Ejemplo 3: Definición de enumeración mediante expresión constante

En este ejemplo, aprenderá a utilizar la expresión constante para definir el valor constante de los elementos de enumeración.

#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:
a. IO_ERROR y
B. ERROR DE RED
Esta es una forma inusual de definir los elementos enum; sin embargo, esto
programa demuestra que esta forma de inicialización de elementos enum es posible en c.
* /
enum Error
IO_ERROR = 1 + 2 * 3 + 4,
ERROR DE DISCO,
NETWORK_ERROR = 2 == 2,
PRINT_ERROR
;
int main ()

/ * Declarar variable de enumeración * /
enum Error Hw_Error;
printf ("Estableciendo Hw_Error en IO_ERROR \ n");
Hw_Error = IO_ERROR;
printf ("Valor de Hw_Error =% d \ n", Hw_Error);
printf ("\ nConfigurando Hw_Error en DISK_ERROR \ n");
Hw_Error = DISK_ERROR;
printf ("Valor de Hw_Error =% d \ n", Hw_Error);
printf ("\ nConfigurando Hw_Error en NETWORK_ERROR \ n");
Hw_Error = NETWORK_ERROR;
printf ("Valor de Hw_Error =% d \ n", Hw_Error);
printf ("\ nConfigurando Hw_Error en PRINT_ERROR \ n");
Hw_Error = PRINT_ERROR;
printf ("Valor de Hw_Error =% d \ n", Hw_Error);
return 0;

Ejemplo 4: ámbito de enumeración

En este ejemplo, aprenderá cómo funciona la regla de alcance 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.

#incluir
int main ()

/ * Definir el tipo de enumeración * /
enumeración Error_1
IO_ERROR = 10,
ERROR DE DISCO,
NETWORK_ERROR = 3,
PRINT_ERROR
;

/ * Definir el tipo de enumeración en el ámbito interno * /
enumeración Error_1
IO_ERROR = 20,
ERROR DE DISCO,
NETWORK_ERROR = 35,
PRINT_ERROR
;
/ * Declarar variable de enumeración * /
enumeración Error_1 Hw_Error;
printf ("Estableciendo Hw_Error en IO_ERROR \ n");
Hw_Error = IO_ERROR;
printf ("Valor de Hw_Error =% d \ n", Hw_Error);
printf ("\ nConfigurando Hw_Error en DISK_ERROR \ n");
Hw_Error = DISK_ERROR;
printf ("Valor de Hw_Error =% d \ n", Hw_Error);
printf ("\ nConfigurando Hw_Error en NETWORK_ERROR \ n");
Hw_Error = NETWORK_ERROR;
printf ("Valor de Hw_Error =% d \ n", Hw_Error);
printf ("\ nConfigurando Hw_Error en PRINT_ERROR \ n");
Hw_Error = PRINT_ERROR;
printf ("Valor de Hw_Error =% d \ n", Hw_Error);

return 0;

Comparación entre enumeración y macro

Enum

Macro

La regla de alcance es aplicable para la enumeración.

La regla de alcance no es aplicable para 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.

Esto 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.