CODEWITHSUNDEEP
cbit-manipulation
Douglas Adolph
Douglas Adolph

Reputation: 101

I need to write a C program that uses a Union structure to set the bits of an int

Here are the instructions:

Define a union data struct WORD_T for a uint16_t integer so that a value can be assigned to a WORD_T integer in three ways: (1) To assign the value to each bit of the integer, (2) To assign the value to each byte of the integer, (3) To assign the value to the integer directly.

I know I need to do something different with that first struct, but I'm pretty lost in general. Here is what I have: 

#include <stdio.h>
#include <unistd.h>
#include <stdlib.h>
#include <sys/types.h>

#define BIT(n) (1 << n)
#define BIT_SET(var, mask) (n |= (mask) )
#define BIT_CLEAR(var, mask) (n &= ~(mask) )
#define BIT_FLIP(var, mask) (n ^= (mask) )

union WORD_T{
    struct{
        uint16_t integerVar:16

    };
    struct{
        unsigned bit1:0;
        unsigned bit2:0;
        unsigned bit3:0;
        unsigned bit4:0;
        unsigned bit5:0;
        unsigned bit6:0;
        unsigned bit7:0;
        unsigned bit8:0;
        unsigned bit9:0;
        unsigned bit10:0;
        unsigned bit11:0;
        unsigned bit12:0;
        unsigned bit13:0;
        unsigned bit14:0;
        unsigned bit15:0;
        unsigned bit16:0;
    };

    void setIndividualBit(unsigned value, int bit) {
        mask = BIT(value) | BIT(bit);
        BIT_SET(n, mask);
    }
};

Upvotes: 2

Views: 845

Answers (2)

Lundin
Lundin

Reputation: 213690

The most obvious problem is that :0 means "a bit-field of zero bits" which doesn't make any sense. You should change this to 1 and then you can assign individual bits through code like the_union.the_struct.bit1 = 1;.

This format is an alternative to the bit set/clear macros you wrote.

Your union should look like:

typedef union
{
  uint16_t word;
  uint8_t  byte[2];
  struct{
     uint16_t bit1:1;
  ...

However. This is a really bad idea and your teacher should know better than to give such assignments. Bit-fields in C are a bag of worms - they are very poorly specified by the standard. Problems:

  • You can't know which bit that is the MSB, it is not defined.
  • You can't know if there will be padding bits/bytes somewhere.
  • You can't even use uint16_t or uint8_t because bit-fields are only specified to work with int.

And so on. In addition you have to deal with endianness and alignment. See Why bit endianness is an issue in bitfields?.

Essentially, code using bit-fields like this will rely heavily on the specific compiler. It will be completely non-portable.

All of these problems could be avoided by dropping the bit-field and use bitwise operators on a uint16_t instead, like you did in your macros. With bitwise operators only, your code will turn deterministic and 100% portable. You can even use them to dodge endianess, by using bit shifts.

Upvotes: 3

Brad Cooley
Brad Cooley

Reputation: 373

Here's the union definition:

union WORD_T
{
    uint16_t word;

    struct
    {
        uint8_t byte0;
        uint8_t byte1;
    };

    struct
    {
        uint8_t bit0:1;
        uint8_t bit1:1;
        uint8_t bit2:1;
        uint8_t bit3:1;
        uint8_t bit4:1;
        uint8_t bit5:1;
        uint8_t bit6:1;
        uint8_t bit7:1;
        uint8_t bit8:1;
        uint8_t bit9:1;
        uint8_t bit10:1;
        uint8_t bit11:1;
        uint8_t bit12:1;
        uint8_t bit13:1;
        uint8_t bit14:1;
        uint8_t bit15:1;
    };
};

To assign to the individual components, do something similar to the following:

union WORD_T data;

data.word = 0xF0F0; // (3) Assign to entire word

data.byte0 = 0xAA; // (2) Assign to individual byte

data.bit0 = 0; // (1) Assign to individual bits
data.bit1 = 1;
data.bit2 = 1;
data.bit2 = 0;

Upvotes: 2

Related Questions