les enums être définie comme u_int8_t variables dans la structure

J'ai un enum dans une structure:

enum Days : uint8_t
{
  day1 =1,
  day2 =2,
  day2 =3
}

struct Hi
{
  Days days;
}

Sur la compilation, j'obtiens une erreur Scoped enums not available in this version.
J'ai besoin de tous mes énumérations d'être un uint8_t type et définie dans la structure.

  • Vous avez besoin de C++11. Quel compilateur utilisez-vous?
  • Pourquoi? Avez-vous une exigence que ce code compile pas pour les plates-formes qui ne sont pas exactement 8-bit unsigned integer? Une telle exigence serait très rare. uint_least8_t ou uint_fast8_t est presque certainement mieux. Donc, est unsigned char, ce qui est nécessaire à b au moins 8 bits de large et non signés.
  • J'ai besoin d'avoir des enums strictement 8 bits .
  • Qu'est-ce, en C ou en C++? Leurs concepts de énumérations sont tout à fait différents.
  • day2 est répété deux fois!
InformationsquelleAutor user2618994 | 2013-08-14
  1. 3

    Même avant C++11, si vous prenez soin de tous vos valeurs enum sont à moins de 128, il vous suffit de les stocker dans un u_int8_t variable. Cela peut nécessiter de casting quand ils sont utilisés, bien que. C'est une façon commune de serrer les valeurs de l'enum dans une structure, en particulier dans le code incorporé où la mémoire est serré. Cette technique améliore également vos données de cache hit ratio si votre code utilise un grand nombre de cas de ces structures.

    enum Days
{
Day1 =1,
Day2 =2,
Day3 =3
};
typedef uint8_t DaysTy;
//Totally optional, but allows you to send a 'DaysTy' to cout directly:
std::ostream& operator<<(std::ostream& s, const DaysTy& d)
{
const char* txt="ILLEGAL";
switch (d)
{
case Day1: txt = "Day1"; break;
case Day2: txt = "Day2"; break;
case Day3: txt = "Day3"; break;
}
s << txt;
return s;
}
struct Hi
{
DaysTy dayA;
DaysTy dayB;
DaysTy dayC;
//Totally optional, but allows you to send a 'Hi' struct to cout directly:
friend std::ostream& operator<<(std::ostream& s, const Hi& m);
};
//Totally optional, but allows you to send a 'Hi' struct to cout directly:
std::ostream& operator<<(std::ostream& s, const Hi& h)
{
s << '[' << h.dayA << ',' << h.dayB << ',' << h.dayC << ']';
return s;
}
int main()
{
Hi aHiObject;
aHiObject.dayA = Day3;
aHiObject.dayB = Day2;
aHiObject.dayC = Day1;
std::cout << "my Hi object: " << aHiObject << '\n';
if (aHiObject.dayA == Day1)
std::cout << "Its dayA is Day1.\n";
if (aHiObject.dayA == Day2)
std::cout << "Its dayA is Day2.\n";
if (aHiObject.dayA == Day3)
std::cout << "Its dayA is Day3.\n";
std::cout << "sizeof(aHiObject)      = " << sizeof(aHiObject) << " byte(s)\n"
"sizeof(aHiObject.dayA) = " << sizeof(aHiObject.dayA) << " byte(s)\n";
std::cout << "Value '3' as a uint8_t: " << (uint8_t)3 << '\n';
std::cout << "Value '3' as a DaysTy: "  << (DaysTy)3  << '\n';
std::cout << "Value '4' as a uint8_t: " << (uint8_t)4 << '\n';
std::cout << "Value '4' as a DaysTy: "  << (DaysTy)4  << '\n';
}

    L'exécution de ce code génère cette sortie:

    my Hi object: [Day3,Day2,Day1]
Its dayA is Day3.
sizeof(aHiObject)      = 3 byte(s)
sizeof(aHiObject.dayA) = 1 byte(s)
Value '3' as a uint8_t: Day3
Value '3' as a DaysTy: Day3
Value '4' as a uint8_t: ILLEGAL
Value '4' as a DaysTy: ILLEGAL

    ...qui, d'ailleurs, montre que Mike Seymour commentaire ci-dessous est correct. Néanmoins, cela démontre d'une façon, vous pouvez emballer vos valeurs enum dans u_int8_t types de variables.

    • Je suis à l'aide de C++03 et j'ai strictement besoins de tous les énumérations à u_int8_t que j'ai besoin de faire l'interface avec le système intégré de
    • Afin de se débarrasser de la : uint8_t après enum Days, et peut-être ajouter un typedef uint8_t DaysTy, et à chaque fois, vous devez créer une instance d'un Day, il suffit de définir la variable de type DaysTy. E. g.: DaysTy today = day1. (Je vous recommande la redéfinition de votre enum avec tous les bouchons de DAY1 = 1, etc, ou peut-être Day1 = 1, etc.) Lorsque vous utilisez par exemple une variable, vous pouvez trouver dans certaines circonstances que vous aurez besoin de le jeter comme Days pour éviter les avertissements du compilateur/erreurs.
    • Quel compilateur que vous utilisez?
    • gcc-version 4.6
    • Ce compilateur devrait être bon, même si c'est vieux de quelques années. Êtes-vous à activation de C++11 avec -std=c++0x?
    • J'ai besoin d'avoir des enums en tant que u_int8_t dans ma structure strictement que je fais affaire avec le matériel du système. –
    • Vous ne pouvez pas déclarer que la surcharge de operator<< depuis DaysTy est un alias pour un construit-dans l'arithmétique types, et les surcharges existent déjà pour tous.
    • Merci pour cette observation. Ma réponse maintenant le montre. Comme c'est un accessoire problème à la poste, je ne suis pas la peine de régler mon posté réponse, mais je suis en train de montrer ce que vous avez dit au sujet de.

    InformationsquelleAutor phonetagger
  2. 2

    Si vous êtes à la rédaction de C++, et vous pouvez mettre à jour la modernité d'un compilateur (ou peut-être activer le C++11 dans votre compilateur) puis votre code est bien.

    Si vous êtes à la rédaction de C ou historique, C++, alors vous ne pouvez pas ces langues n'ont tout simplement pas vous permettre de spécifier la taille d'une énumération. Vous aurez à utiliser uint8_t où vous avez besoin d'une taille explicite, et de les convertir si nécessaire:

    struct Hi {
uint8_t days;
};
Hi hi;
hi.days = static_cast<uint8_t>(day1);
Days d = static_cast<Days>(hi.days);
    • J'ai besoin d'avoir des enums en tant que u_int8_t dans ma structure strictement que je fais affaire avec le matériel du système.
    • Alors un uint8_t dans votre structure pour la compatibilité matérielle, et de les convertir vers et à partir de l'énumération pour y accéder. Ou réparer votre compilateur.
    • j'avais défini u_int8_t jours dans ma structure, mais il affiche une erreur,
    • Probablement parce que vous n'êtes pas en utilisant des conversions explicites entre le recensement et les types d'entiers. Voir ma réponse mis à jour.
    • Le code semble bon. Mais comment exprimer toutes les énumérations de uin8_t et ont un objet lié à l'enum qui est uin8_t
    • Je ne sais pas ce que tu veux dire par "un objet lié à l'enum". Vous aurez besoin d'utiliser uint8_t lorsque vous avez besoin d'une taille particulière, Days où vous voulez la commodité de l'énumération, et les conversions nécessaires. Ou de mise à jour de votre compilateur.

    InformationsquelleAutor Mike Seymour