Sintaxe
enum <Nome do tipo enum> {Enumeration_Constant_Element-1,
Enumeration_Constant_Element-2,
Enumeration_Constant_Element-3,
…… .........,
Enumeration_Constant_Element-n,
};
O valor padrão de Enumeration_Constant_Element-1 é 0, o valor de Enumeration_Constant_Element-2 é 1, o valor de Enumeration_Constant_Element-3 é 2 e o valor de Enumeration_Constant_Element-n é (n-1).
Mergulhe profundamente em Enum
Agora, como conhecemos a sintaxe para definir o tipo de enumeração, vejamos um exemplo:
enumErro{
IO_ERROR,
DISK_ERROR,
ERRO DE REDE
};
A palavra-chave enum deve sempre ser usada para definir o tipo de enumeração. Portanto, sempre que quiser definir um tipo de enumeração, você deve usar a palavra-chave enum antes. Após a palavra-chave enum, você deve usar um identificador válido para definir o.
No exemplo acima, o compilador atribuirá IO_ERROR ao valor integral: 0, DISK_ERROR ao valor integral: 1 e NETWORK_ERROR ao valor integral: 2. Por padrão, o primeiro elemento enum é sempre atribuído o valor 0, o próximo enum-element recebe o valor 1 e assim por diante.
Este comportamento padrão pode ser alterado, se necessário, atribuindo o valor integral constante explicitamente, da seguinte maneira:
enumErro{IO_ERROR= 2,
DISK_ERROR,
ERRO DE REDE= 8 ,
PRINT_ERROR
};
Neste caso, o IO_ERROR é explicitamente atribuído a um valor de 2 pelo programador, DISK_ERROR é atribuído a um valor de 3 pelo compilador, NETWORK_ERROR é explicitamente atribuído ao valor de 8 pelo programador e PRINT_ERROR é atribuído ao próximo valor integral do elemento enum anterior NETWORK_ERROR (ou seja, 9) pelo compilador.
Portanto, agora você entende como definir um tipo de enumeração definido pelo usuário em C. É possível declarar uma variável do tipo enum (como podemos declarar uma variável do tipo inteiro)? Sim, ele é! Você pode declarar a variável enum da seguinte maneira:
enumErro Hw_Error;Novamente, enum é a palavra-chave aqui, Error é o tipo de enum e Hw_Error é uma variável de enum.
Veremos agora os seguintes exemplos para entender os vários usos de enum:
- Exemplo 1: uso de definição de enum padrão
- Exemplo 2: uso de definição de enum personalizado
- Exemplo 3: definição de enum usando expressão constante
- Exemplo 4: escopo enum
Exemplo 1: uso de definição de enum padrão
Neste exemplo, você aprenderá como definir o tipo de enumeração com valores constantes padrão. O compilador se encarregará de atribuir os valores padrão aos elementos enum. Abaixo, você verá o programa de exemplo e a saída correspondente.
#incluir/ * Defina o tipo de enum * /
enumErro{
IO_ERROR,
DISK_ERROR,
ERRO DE REDE
};
inta Principal()
{
enumErro Hw_Error; / * Criando variável enum * /
printf ('Definindo Hw_Error para IO_ERROR n');
Hw_Error=IO_ERROR;
printf ('Valor de Hw_Error =% d n',Hw_Error);
printf (' nDefinindo Hw_Error para DISK_ERROR n');
Hw_Error=DISK_ERROR;
printf ('Valor de Hw_Error =% d n',Hw_Error);
printf (' nDefinindo Hw_Error para NETWORK_ERROR n');
Hw_Error=ERRO DE REDE;
printf ('Valor de Hw_Error =% d n',Hw_Error);
Retorna 0;
}
Exemplo 2: uso de definição de enum personalizado
Neste exemplo, você aprenderá como definir o tipo de enumeração com um valor constante personalizado. Além disso, este exemplo o ajudará a entender como a inicialização das constantes personalizadas pode ser feita em qualquer ordem aleatória. Neste exemplo, definimos explicitamente o valor constante para 1ste 3rdelementos enum (ou seja, IO_ERROR e NETWORK_ERROR, respectivamente), mas pulamos a inicialização explícita para os 2WLe 4ºelementos Agora é responsabilidade do compilador atribuir os valores padrão aos 2WLe 4ºelementos enum (ou seja, DISK_ERROR e PRINT_ERROR, respectivamente). DISK_ERROR será atribuído a um valor de 3 e PRINT_ERROR será atribuído a um valor de 9. Abaixo, você verá o programa de exemplo e a saída.
#incluir/ * Defina o tipo de enum - inicialização personalizada * /
enumErro{
IO_ERROR= 2,
DISK_ERROR,
ERRO DE REDE= 8,
PRINT_ERROR
};
inta Principal()
{
/ * Declare enum variable * /
enumErro Hw_Error;
printf ('Definindo Hw_Error para IO_ERROR n');
Hw_Error=IO_ERROR;
printf ('Valor de Hw_Error =% d n',Hw_Error);
printf (' nDefinindo Hw_Error para DISK_ERROR n');
Hw_Error=DISK_ERROR;
printf ('Valor de Hw_Error =% d n',Hw_Error);
printf (' nDefinindo Hw_Error para NETWORK_ERROR n');
Hw_Error=ERRO DE REDE;
printf ('Valor de Hw_Error =% d n',Hw_Error);
printf (' nDefinindo Hw_Error para PRINT_ERROR n');
Hw_Error=PRINT_ERROR;
printf ('Valor de Hw_Error =% d n',Hw_Error);
Retorna 0;
}
Exemplo 3: definição de enum usando expressão constante
Neste exemplo, você aprenderá como usar a expressão constante para definir o valor constante para elementos enum.
#incluir/ * Defina o tipo de enum - inicialização personalizada usando expressão constante
expressão constante está sendo usada aqui em caso de:
uma. IO_ERROR e
b. ERRO DE REDE
Esta é uma maneira incomum de definir os elementos enum; entretanto, este
programa demonstra que esta forma de inicialização de elementos enum é possível em c.
* /
enumErro{
IO_ERROR= 1 + 2 * 3 + 4,
DISK_ERROR,
ERRO DE REDE= 2 == 2,
PRINT_ERROR
};
inta Principal()
{
/ * Declare enum variable * /
enumErro Hw_Error;
printf ('Definindo Hw_Error para IO_ERROR n');
Hw_Error=IO_ERROR;
printf ('Valor de Hw_Error =% d n',Hw_Error);
printf (' nDefinindo Hw_Error para DISK_ERROR n');
Hw_Error=DISK_ERROR;
printf ('Valor de Hw_Error =% d n',Hw_Error);
printf (' nDefinindo Hw_Error para NETWORK_ERROR n');
Hw_Error=ERRO DE REDE;
printf ('Valor de Hw_Error =% d n',Hw_Error);
printf (' nDefinindo Hw_Error para PRINT_ERROR n');
Hw_Error=PRINT_ERROR;
printf ('Valor de Hw_Error =% d n',Hw_Error);
Retorna 0;
}
Exemplo 4: enum Scope
Neste exemplo, você aprenderá como a regra de escopo funciona para enum. Um MACRO (#define) poderia ter sido usado para definir uma constante em vez do enum, mas a regra de escopo não funciona para MACRO.
#incluirinta Principal()
{
/ * Defina o tipo de enum * /
enumError_1{
IO_ERROR= 10,
DISK_ERROR,
ERRO DE REDE= 3,
PRINT_ERROR
};
{
/ * Defina o tipo de enum no escopo interno * /
enumError_1{
IO_ERROR= vinte,
DISK_ERROR,
ERRO DE REDE= 35,
PRINT_ERROR
};
/ * Declare enum variable * /
enumError_1 Hw_Error;
printf ('Definindo Hw_Error para IO_ERROR n');
Hw_Error=IO_ERROR;
printf ('Valor de Hw_Error =% d n',Hw_Error);
printf (' nDefinindo Hw_Error para DISK_ERROR n');
Hw_Error=DISK_ERROR;
printf ('Valor de Hw_Error =% d n',Hw_Error);
printf (' nDefinindo Hw_Error para NETWORK_ERROR n');
Hw_Error=ERRO DE REDE;
printf ('Valor de Hw_Error =% d n',Hw_Error);
printf (' nDefinindo Hw_Error para PRINT_ERROR n');
Hw_Error=PRINT_ERROR;
printf ('Valor de Hw_Error =% d n',Hw_Error);
}
Retorna 0;
}
Comparação entre enum e macro
| Enum | Macro |
| A regra de escopo é aplicável para enum. | A regra de escopo não é aplicável para Macro. |
| A atribuição de valor Enum padrão ocorre automaticamente. Enum é muito útil para definir um grande número de constantes. O compilador usa a inicialização de valor constante padrão. | Os valores das constantes da macro devem sempre ser mencionados explicitamente pelo programador. Este pode ser um processo tedioso para um grande número de constantes, uma vez que o programador deve sempre definir manualmente cada valor constante ao definir a macro. |
Conclusão
O programa enum em C pode ser considerado um método opcional para programas independentes ou projetos de pequeno porte, uma vez que os programadores sempre podem usar macro em vez de um enum. No entanto, programadores experientes tendem a usar enum em vez de macro para projetos de desenvolvimento de software em grande escala. Isso ajuda a escrever programas limpos e legíveis.