La enumeración es un tipo de datos básico en lenguaje C, que puede hacer que los datos sean más concisos y fáciles de leer.
enum colors
{
red,blue,yellow
}clo;
int main(void)
{
clo=red;
printf("%d\n",clo); //0
clo=yellow;
printf("%d\n",clo); //2
return 0;
}
El valor predeterminado del primer miembro de enumeración es un número entero 0 y el valor de los miembros de enumeración posteriores se agrega al miembro anterior en 1. En este ejemplo, definimos el valor del primer miembro de enumeración como 1 y el segundo como 2
enum DAY
{
MON, TUE=3, WED, THU
};
Para los elementos de enumeración que no especifican un valor, el valor del elemento anterior más uno. En otras palabras, el valor de MON es 0, el valor de TUE es 3, el valor de WED es 4 y el valor de THU es 5
¿Cómo atravesar tipos enumerados?
En el lenguaje C, los tipos de enumeración se tratan como tipos int o unsigned int, por lo que no hay forma de recorrer los tipos de enumeración de acuerdo con la especificación del lenguaje C.
Si desea atravesar el tipo de enumeración, el tipo de enumeración debe ser continuo para lograr un cruce condicional.
#include <stdio.h>
enum DAY
{
MON=1, TUE, WED, THU, FRI, SAT, SUN
} day;
int main(void)
{
// 遍历枚举元素
for (day = MON; day <= SUN; day++) {
printf("枚举元素：%d \n", day);
}
}
Combinar con interruptor
enum colors
{
red,blue,yellow
};
int main(void)
{
enum colors clo;
scanf("%d",&clo);
switch(clo)
{
case red:
printf("你喜欢红色\n");
break;
case blue:
printf("你喜欢蓝色\n");
break;
case yellow:
printf("你喜欢黄色\n");
break;
default:
printf("没有你喜欢的颜色\n");
}
return 0;
}
Ocupar memoria:
citado por agregar una descripción de enlace. El
tipo de enumeración se refiere a una colección de constantes enteras nombradas. Es decir, el tipo de enumeración es esencialmente una colección de un conjunto de constantes, pero estas constantes tienen sus propios nombres. El tipo de enumeración es un tipo de datos definido por el usuario.
Las variables de enumeración son variables definidas por tipos de enumeración. El tamaño de la variable de enumeración, es decir, el tamaño de la memoria ocupada por el tipo de enumeración. Debido a la asignación de variables de enumeración, solo se puede almacenar una constante en la estructura de enumeración a la vez. Por lo tanto, el tamaño de la variable de enumeración es esencialmente el tamaño del espacio de memoria ocupado por la constante (la constante es de tipo int, y el tipo int en el compilador principal actual es generalmente 4 bytes en máquinas de 32 bits y 64 bits máquinas), enumeración Lo mismo ocurre con el tamaño de la memoria ocupada por los tipos.
Además, puede utilizar el tamaño del indicador incorporado del compilador para calcular el tamaño de la variable de enumeración (o tipo de enumeración) para la verificación.
例子：
int main()
{
enum number {
one = 1,
two = 2,
three = 3,
foure = 4,
};
enum number num1;
printf("int sizeof:%d\n",sizeof(int));//int类型占用几个字节；
printf("enum number sizeof:%d\n",sizeof(enum number));//枚举结构enum number占用几个字节；
printf(" variable num1 sizeof:%d\n",sizeof(num1));//定义后的枚举变量占用几个字节；
num1 = three;
printf("after 'num1 = three' ,variable num1 sizeof:%d\n",sizeof(num1));//赋值后的枚举变量占用几个字节；
}
Llegue a una pregunta: Calcule el espacio de memoria ocupado por un objeto de clase
class A
{
int i;
union U
{
char buff[13];
int j;
}u;
void foo(){
};
typedef char* (*f) (void*);
enum {
red,blue,pink} color;
};
int main(void)
{
A a;
printf("%d\n",sizeof(a));
return 0;
}
Análisis simple:
- Dar forma a i ocupa 4 bytes
- Unión U, el tipo de datos más grande ocupa 4 bytes, el miembro más grande ocupa 13 bytes y la alineación de la memoria es un múltiplo de 16.
- La función foo () no ocupa espacio
- El tipo char * no define variables y no ocupa espacio
- enum ocupa 4 bytes,
por lo que ocupa 24 bytes