Cómo usar enum en el idioma C

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

Sintaxis

enumer
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).

Profundizar en enum

Ahora, dado que conocemos la sintaxis para definir el tipo de enumeración, veamos un ejemplo:

Error de enum
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. Por defecto, al primer elemento enum-elemento siempre se le asigna el valor 0, al siguiente elemento enume 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:

Error de enum
Io_error = 2,
ERROR DE DISCO,
Network_error = 8 ,
Print_error
;

En este caso, el programador se asigna explícitamente el IO_Error a un valor de 2, el programador se asigna a un valor de 3, Network_Error se asigna explícitamente al valor de 8 por el programador e print_Error se asigna a otro valor integral del elemento enum anterior network_error (i.mi., 9) por el compilador.

Entonces, ahora comprende cómo definir un tipo de enumeración definida por el usuario en C. ¿Es posible declarar una variable de tipo enum (ya que podemos declarar una variable de tipo entero)? Sí, lo es! Puede declarar la variable enum de la siguiente manera:

Error de enum hw_error;

Nuevamente, "enum" es la palabra clave aquí, "error" es el tipo enum, y "hw_error" es una variable enum.

Ahora veremos los siguientes ejemplos para comprender los diversos usos de Enum:

  • Ejemplo 1: Uso predeterminado de la definición de enum
  • Ejemplo 2: Uso de definición de enum personalizado
  • Ejemplo 3: Definición de enum usando expresión constante
  • Ejemplo 4: Alcance de enum

Ejemplo 1: Uso predeterminado de la definición de enum

En este ejemplo, aprenderá cómo definir el tipo de enumeración con valores constantes predeterminados. El compilador se encargará de asignar los valores predeterminados a los elementos enum. A continuación, verá el programa de ejemplo y la salida correspondiente.

#incluir
/ * Defina el tipo de enum */
Error de enum
Io_error,
ERROR DE DISCO,
ERROR DE RED
;
int main ()

Error de enum hw_error; /* Crear variable enum*/
printf ("configurar hw_error en io_error \ n");
Hw_error = io_error;
printf ("valor de hw_error = %d \ n", hw_error);
printf ("\ nsetting hw_error a disk_error \ n");
Hw_error = disk_error;
printf ("valor de hw_error = %d \ n", hw_error);
printf ("\ nsetting hw_error a network_error \ n");
Hw_error = network_error;
printf ("valor de hw_error = %d \ n", hw_error);
regresar 0;

Ejemplo 2: Uso de definición de enum personalizado

En este ejemplo, aprenderá cómo definir el tipo de enumeración con un valor constante personalizado. Además, este ejemplo lo ayudará a comprender cómo se puede hacer la inicialización de las constantes personalizadas en cualquier orden aleatorio. En este ejemplo, hemos definido explícitamente el valor constante para el 1calle y 3rd Elementos enum (yo.mi., Io_error y network_error, respectivamente), pero hemos omitido la inicialización explícita para los 2Dakota del Norte y 4th elementos. Ahora es responsabilidad del compilador asignar los valores predeterminados a los 2Dakota del Norte y 4th Elementos enum (yo.mi., Disk_error e 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
/* Defina el tipo de enum - Inicialización personalizada*/
Error de enum
Io_error = 2,
ERROR DE DISCO,
Network_error = 8,
Print_error
;
int main ()

/* Declarar variable enum*/
Error de enum hw_error;
printf ("configurar hw_error en io_error \ n");
Hw_error = io_error;
printf ("valor de hw_error = %d \ n", hw_error);
printf ("\ nsetting hw_error a disk_error \ n");
Hw_error = disk_error;
printf ("valor de hw_error = %d \ n", hw_error);
printf ("\ nsetting hw_error a network_error \ n");
Hw_error = network_error;
printf ("valor de hw_error = %d \ n", hw_error);
printf ("\ nsetting hw_error a print_error \ n");
Hw_error = print_error;
printf ("valor de hw_error = %d \ n", hw_error);
regresar 0;

Ejemplo 3: Definición de enum usando expresión constante

En este ejemplo, aprenderá cómo usar la expresión constante para definir el valor constante de los elementos enum.

#incluir
/* Defina el tipo de enum - Inicialización personalizada utilizando la expresión constante
La expresión constante se está utilizando aquí en caso de:
a. 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 enum es posible en c.
*/
Error de enum
Io_error = 1 + 2 * 3 + 4,
ERROR DE DISCO,
Network_error = 2 == 2,
Print_error
;
int main ()

/* Declarar variable enum*/
Error de enum hw_error;
printf ("configurar hw_error en io_error \ n");
Hw_error = io_error;
printf ("valor de hw_error = %d \ n", hw_error);
printf ("\ nsetting hw_error a disk_error \ n");
Hw_error = disk_error;
printf ("valor de hw_error = %d \ n", hw_error);
printf ("\ nsetting hw_error a network_error \ n");
Hw_error = network_error;
printf ("valor de hw_error = %d \ n", hw_error);
printf ("\ nsetting hw_error a print_error \ n");
Hw_error = print_error;
printf ("valor de hw_error = %d \ n", hw_error);
regresar 0;

Ejemplo 4: Alcance de enum

En este ejemplo, aprenderá cómo funciona la regla de alcance para enum. Una macro (#define) podría haberse utilizado para definir una constante en lugar del enum.

#incluir
int main ()

/ * Defina el tipo de enum */
Error de enume_1
Io_error = 10,
ERROR DE DISCO,
Network_error = 3,
Print_error
;

/* Defina el tipo de enum en el alcance interno*/
Error de enume_1
Io_error = 20,
ERROR DE DISCO,
Network_error = 35,
Print_error
;
/* Declarar variable enum*/
Error de enum_1 hw_error;
printf ("configurar hw_error en io_error \ n");
Hw_error = io_error;
printf ("valor de hw_error = %d \ n", hw_error);
printf ("\ nsetting hw_error a disk_error \ n");
Hw_error = disk_error;
printf ("valor de hw_error = %d \ n", hw_error);
printf ("\ nsetting hw_error a network_error \ n");
Hw_error = network_error;
printf ("valor de hw_error = %d \ n", hw_error);
printf ("\ nsetting hw_error a print_error \ n");
Hw_error = print_error;
printf ("valor de hw_error = %d \ n", hw_error);

regresar 0;

Comparación entre enum y macro

Enumer Macro
La regla de alcance es aplicable para ENUM. La regla de alcance no es aplicable para macro.
La asignación de valor de ENUM predeterminada ocurre automáticamente.

Enum es muy útil para definir una gran cantidad de constantes. El compilador toma la inicialización de valor constante predeterminado.

El programador siempre debe mencionar explícitamente los valores macro constantes.

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 tamaño pequeño, ya que los programadores siempre pueden usar macro en lugar de un enum. 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.