Y a-t-il un moyen d'accéder à des bits individuels avec une union?

Je suis en train d'écrire un programme C. Je veux une variable que je peux accéder à un char, mais je peux aussi accès aux bits de. Je pensais que je pouvais utiliser une union comme ça...

typedef union 
{
    unsigned char status;
    bit bits[8];
}DeviceStatus;

mais le compilateur n'aime pas cela. Apparemment, vous ne pouvez pas utiliser les bits dans une structure.
Que puis-je faire à la place?

source d'informationauteur PICyourBrain

  1. 19

    Sûr, mais vous voulez vraiment utiliser une structure pour définir les bits comme ce

    typedef union
{
  struct
  {
    unsigned char bit1 : 1;
    unsigned char bit2 : 1;
    unsigned char bit3 : 1;
    unsigned char bit4 : 1;
    unsigned char bit5 : 1;
    unsigned char bit6 : 1;
    unsigned char bit7 : 1;
    unsigned char bit8 : 1;
  }u;
  unsigned char status;
}DeviceStatus;

    Puis vous pouvez y accéder pour DeviceStatus ds; vous pouvez accéder à ds.u.bit1. Aussi, certains compilateurs va effectivement vous permettre de disposer de anonyme les structures à l'intérieur de l'union, de sorte que vous pouvez accéder à ds.bit1 si vous omettre l'u à partir de la définition de type.

  2. 4

    Vous avez un couple de possibilités. On serait d'utiliser Boolean mathématiques pour obtenir les bits:

    int bit0 = 1;
int bit1 = 2;
int bit2 = 4;
int bit3 = 8;
int bit4 = 16;
int bit5 = 32;
int bit6 = 64;
int bit7 = 128;

if (status & bit1)
    //whatever...

    Une autre est d'utiliser bitfields:

    struct bits { 
   unsigned bit0 : 1;
   unsigned bit1 : 1;
   unsigned bit2 : 1;
//...
};

typedef union {
    unsigned char status;
    struct bits bits;
} status_byte;

some_status_byte.status = whatever;
if (status_byte.bits.bit2)
    //whatever...

    La première est (au moins sans doute) plus portable, mais quand vous avez affaire avec les bits d'état, les chances sont que le code n'est pas même légèrement portable de toute façon, de sorte que vous ne se soucient pas beaucoup parler...

  3. 2

    Comme cela a déjà été dit, vous ne pouvez pas l'adresse de la mémoire plus petit qu'un octet en C. je voudrais écrire une macro:

    #define BIT(n) (1 << n)

    et l'utiliser pour accéder à l'bits. De cette façon, votre accès est le même, quelle que soit la taille de la structure, vous accédez. Vous pouvez écrire votre code comme:

    if (status & BIT(1)) {
   //Do something if bit 1 is set
} elseif (~status | BIT(2) {
   //Do something else if bit 2 is cleared
} else  {
   //Set bits 1 and 2
   status |= BIT(1) | BIT(2)
   //Clear bits 0 and 4
   status &= ~(BIT(0) | BIT(4))
   //Toggle bit 5 
   status ^= BIT(5)
}

    Cela vous donne l'accès à proximité de votre système, utilisez [] au lieu de ().

  4. 1
    typedef union
{
  unsigned char status;
  struct bitFields
  {
    _Bool bit0 : 1;
    _Bool bit1 : 1;
    _Bool bit2 : 1;
    _Bool bit3 : 1;
    _Bool bit4 : 1;
    _Bool bit5 : 1;
    _Bool bit6 : 1;
    _Bool bit7 : 1;
  } bits;
}DeviceStatus;
  5. 0

    La plus petite unité adressable en C est toujours un octet (appelé char en C). Vous ne pouvez pas accéder à un bit directement. Le plus proche de façon à obtenir à l'accès aux bits serait de définir un type de données appelé bitpointer et de définir certaines fonctions ou macros:

    #include <stdbool.h>

typedef struct bitpointer {
    unsigned char *pb; /* pointer to the byte */
    unsigned int bit; /* bit number inside the byte */
} bitpointer;

static inline bool bitpointer_isset(const bitpointer *bp) {
    return (bp->pb & (1 << bp->bit)) != 0;
}

static inline void bitpointer_set(const bitpointer *bp, bool value) {
    unsigned char shifted = (value ? 1 : 0) << bp->bit;
    unsigned char cleared = *bp->pb &~ (1 << bp->bit);
    *(bp->pb) = cleared | shifted;
}

    Je recommande contre les syndicats, car il est de mise en œuvre définies par si ils sont remplis msb-lsb ou lsb-msb (voir la norme ISO C99, 6.7.2.1p10).

  6. 0

    Vous pouvez le faire en mettant les bits dans une structure à l'intérieur de l'union, mais il peut ou peut ne pas fonctionner, en fonction de votre mise en œuvre. Le langage de définition ne précise pas dans quel ordre les bits séparés seront en adéquation avec les bits de la unsigned char; pire, il n'a pas la même garantie que les pièces se chevauchent avec le unsigned char (le compilateur peut décider de placer les bits séparés en direction de la plus importante côté d'un mot et la unsigned char vers le moins significatif de côté ou vice versa).

    La technique habituelle dans votre situation est l'utilisation des opérations bit à bit. Définir des constantes nommées d'après la signification des bits, par exemple,

    #define FLAG_BUSY 0x01
#define FLAG_DATA_AVAILABLE 0x02
#define FLAG_TRANSMISSION_IN_PROGRESS 0x04
...
#define FLAG_ERROR 0x80

    Puis à lire et à écrire des bits individuels:

    if (status & FLAG_BUSY) ... /* test if the device is busy */
status &= ~FLAG_ERROR; /* turn off error flag */
status |= FLAG_TRANSMISSION_IN_PROGRESS /* turn on transmission-in-progress flag */