Casting enum définition de unsigned int

Selon cette SORTE de poste:

Quelle est la taille d'un enum en C?

les types enum ont signed int type.

Je voudrais convertir un enum définition de signed int à unsigned int.

Par exemple, sur ma plate-forme d'un unsigned int 32-bits de large.
Je veux créer un enum:

typedef enum hardware_register_e
{
    REGISTER_STATUS_BIT = (1U << 31U)
} My_Register_Bits_t;

Mon compilateur se plaint que la définition ci-dessus est hors de portée (ce qui est pour un signed int).

Comment dois-je déclarer unsigned int enum valeurs?

Edit 1:

La préférence n'est pas de l'étendre à d'64 bits (car le code réside
dans un système embarqué).
En raison des limites des compétences, le C++ n'est pas autorisé pour ce projet. 🙁

Edit 2:

Compilateur est IAR Embedded Workbench pour ARM7.

Pour être clair, est le C++, une option?
Je le souhaite. Je peux créer un type réel si ils nous permettent d'utiliser C++. 🙁
REGISTER_STATUS_BIT = ~0x7fffffff?
Est-ce portable? Veuillez soumettre une réponse.
est tout aussi portable que -2147483648. Ils évaluent de la même séquence de bits. Les mêmes restrictions que j'ai présenté dans ma réponse s'appliquent.

OriginalL'auteur Thomas Matthews | 2012-07-03

2

Malheureusement ISO standard C (c99 6.4.4.3) stipule que l'énumération des constantes de type int. Si vous compilez le ci-dessus avec, par exemple,gcc -W -std=c89 -pedantic, il émet un avertissement ISO C restricts enumerator values to range of ‘int’ [-pedantic]. Certains incorporé compilateurs ne peuvent pas accepter le code.

Si votre compilateur est de la variété de plus en plus pointilleuses, vous pouvez contourner le problème en utilisant
```
typedef enum hardware_register_e
{
    REGISTER_STATUS_BIT = -2147483648   /* 1<<31, for 32-bit two's complement integers */
} hardware_register_t;
```
mais il ne fonctionne correctement que si int est de 32 bits en complément à deux type de votre architecture. Il est sur tous les 32-bits et 64 bits des architectures j'ai déjà utilisé ou entendu parler.

Modifiées afin d'ajouter: ARM7 utilise 32 bits en complément à deux int type, de sorte que le ci-dessus devrait fonctionner correctement. Je ne vous recommandons de garder le commentaire expliquant que la valeur réelle est 1<<31. Vous ne savez jamais si quelqu'un des ports le code, ou utilise un autre compilateur. Si le nouveau compilateur émet un avertissement, le commentaire sur la même ligne devrait le rendre simple à résoudre. Personnellement, je préfère placer le code dans un conditionnelle, peut-être
```
typedef enum hardware_register_e
{
#ifdef __ICCARM__
    REGISTER_STATUS_BIT = -2147483648   /* 1<<31, for 32-bit two's complement integers */
#else
    REGISTER_STATUS_BIT = 1 << 31
#endif
} hardware_register_t;
```
IAR types enum sont différents. voir "--enum-est-int" dans l'aide. Néanmoins, je ne pouvais pas trouver un moyen de faire enum un type non signé
Si vous activez l'IAR extensions de langage (à l'aide de la -e option de ligne de commande), puis vous pouvez utiliser, par exemple, typedef enum hardware_register_e { REGISTER_STATUS_BIT = 0x80000000UL } hardware_register_t; auquel cas l'enum sera de type unsigned long. Voir les pages 169 et 211 de la ET Développement C/C++ Guide pour les BRAS. J'ai ajouté une réponse plus détaillée à la question vous avez demandé, je pense que vous faites référence.

OriginalL'auteur Nominal Animal
4

Selon cette SORTE de post:
Quelle est la taille d'un enum en C?
les types enum ont signé le type int.

La chose est enum types peut être int type, mais ils ne sont pas int dans C. Sur gcc ¹⁾, enum types sont unsigned int par défaut.

enum constantes sont int mais enum types de mise en œuvre définies.

Dans votre cas, la enum constante est int mais vous êtes en lui donnant une valeur qui ne rentre pas dans un int. Vous ne pouvez pas avoir unsigned int enum constantes en C comme C dit qu'ils sont int.

_{1) gcc définie par l'implémentation d'un type enum documentation: "Normalement, le type unsigned int si il n'y a pas de valeurs négatives dans l'énumération, sinon int" dans http://gcc.gnu.org/onlinedocs/gcc/Structures-unions-enumerations-and-bit_002dfields-implementation.html}

Ce qui signifie que dans le contexte de cette question?
Peut le enum constante d'être déclaré comme unsigned?
non, ils sont toujours de type int.
Downvoter, merci d'expliquer votre downvote!
Gcc semble soutenir enums plus qu'un int: voir stackoverflow.com/a/9524663/318716.

OriginalL'auteur ouah
1

Vérifier si votre compilateur disposait d'une option ou d'un pragma pour faire des énumérations non signé. Si elle ne le fait pas, alors vous aurez juste à utiliser une plaine unsigned int (ou d'une largeur fixe de type comme uint32_t) au lieu d'un enum, avec #defines utilisé pour définir les valeurs qu'elle peut prendre.

Depuis que je suis en utilisant le code dans un intégré à l'appareil médical, je m'attendais à quelque chose de plus sûr que #defines.
Je ne pense pas que IAR ont de tels pragma ou une option. Je vais envoyer une question à leur prise en charge et de mise à jour

OriginalL'auteur Adam Rosenfield
1

Vous ne pouvez pas (au moins de façon portable), modifier le type d'enum. La norme est clair qu'une énumération constante est de type int. Pour se débarrasser de l'avertissement, vous pouvez utiliser un cast:
```
typedef enum hardware_register_e
{
    REGISTER_STATUS_BIT = (int)(1U << 31U)
} My_Register_Bits_t;
```
Alternatives Possibles

Si cela n'a pas à être dans un en-tête, vous pouvez utiliser un const objet de type au lieu de la constante d'énumération:
```
const unsigned int REGISTER_STATUS_BIT = (1U << 31);
```
Sinon, vous pouvez utiliser une définition:
```
#define REGISTER_STATUS_BIT (1U << 31)
```
Cela peut conduire à des erreurs d'édition de liens, n'est pas recommandée.
Seulement si elle est définie dans l'en-tête.
où d'autre pouvez-vous définir un enum?
Il dépend de l'endroit où vous l'utilisez, ou vous définissez toujours dans les en-têtes? =)
const ne permet pas de définir des constantes en C, mais en lecture seule des objets.

OriginalL'auteur vitaut

Vous devez vous connecter pour publier un commentaire.