Comment puis-je utiliser en toute sécurité les énumérations comme indicateurs en C ?

Surmonter les problèmes de sécurité des types lors du traitement des énumérations comme des indicateurs en C

En C#, l'application de l'attribut [Flags] aux énumérations permet de les traiter comme des indicateurs booléens. Cependant, la réplication de ce comportement en C nécessite une approche différente.

Une méthode consiste à définir des opérateurs au niveau du bit pour l'énumération :

enum AnimalFlags
{
    HasClaws = 1,
    CanFly = 2,
    EatsFish = 4,
    Endangered = 8
};

inline AnimalFlags operator|(AnimalFlags a, AnimalFlags b)
{
    return static_cast<AnimalFlags>(static_cast<int>(a) | static_cast<int>(b));
}

Cela permet des opérations au niveau du bit sur les énumérations, telles que :

seahwk.flags = CanFly | EatsFish | Endangered;

Cependant, des problèmes potentiels de sécurité de type surviennent lors de l'attribution de valeurs non énumérées à la variable enum. Pour résoudre ce problème, considérez ce qui suit :

struct AnimalFlagsGuard
{
    enum : AnimalFlags m_flags;
};

AnimalFlagsGuard seahawk;
seahwak.m_flags = CanFly | EatsFish | Endangered;

En enfermant l'énumération dans une structure, l'attribution de valeurs non énumérées est empêchée au niveau du type. Cette approche maintient la sécurité des types et permet une gestion plus structurée et encapsulée des énumérations en tant que drapeaux.

Ce qui précède est le contenu détaillé de. pour plus d'informations, suivez d'autres articles connexes sur le site Web de PHP en chinois!