Bit field structure arrays in C

Question

How can I create a bit-field array with variable size? The following code is what I tried, which didn't work.

#include <stdio.h>
int main()
{
    int n=4;
    struct bite{
        unsigned a1:2;
        unsigned a2:2;
            :
            :
        unsigned a(n-1):2;
        unsigned a(n):2;
    }bits;

    for(i=1;i<=n;i++)
        bits.a[i]=i;

    for(i=1;i<=n;i++)
        printf("%d ",bits.a[i]);

    return 0;
}

Answer 1

The members of a struct cannot be defined at runtime.

You could simulate a bit array using a char array and some macros.

#define BitArray(array, bits) \
  unsigned char array[bits / 8 + 1]

#define SetBit(array, n) \
  do { array[n / 8] |= (1 << (n % 8)) } while (0)
#define GetBit(array, n) \
  ((array[n / 8] >> (n % 8)) & 1)

int main(void)
{
  BitArray(bits, 42); /* Define 42 bits and init to all 0s
                               (in fact this allocates memory for (42/8 + 1) * 8 bits). */

  SetBit(bits, 2); /* Set bit 2. */
  int bit2 = GetBit(bits, 2); /* Get bit 2 */

  ...

---

Similar for 2-bit words are per your code:

#include <stdlib.h>
#include <stdio.h>
#include <string.h>

#define Define2BitWordArray(array, two_bit_words) \
  unsigned char array[two_bit_words / 4 + 1]

#define Set2BitWord(array, n, value) \
  do { array[n / 4] |= (unsigned char)((value & 0x11) << (2 * (n % 4))); } while (0)
#define Get2BitWord(array, n) \
  ((array[n / 4] >> (2 * (n % 4))) & 0x11)

int main(void)
{
  size_t n = 10;
  Define2BitWordArray(bits, n); /* Define 10 two-bits words
                                  (in fact this allocates memory 
                                  for (10/4 + 1) * 4 two-bit bits). */
  memset(bits, 0, sizeof bits); /* Set all bits to 0. */

  for(size_t i = 0; i < n; i++) /* C array's indexes are 0-based. */
  {
    Set2BitWord(bits, i, i);
  }

  for(size_t i = 0; i < n; i++)
  {
    printf("%d ", Get2BitWord(bits, i));
  }
}

Answer 2

if you want to operate on the particular bit or bits on data which has not limited size (actually limited to the max value of the size_t divided by 8). Little endian in this example

void setbit(void *obj, size_t bit)
{
    uint8_t *p = obj;

    p[bit >> 3] |= (1 << (bit & 7));
}

void resetbit(void *obj, size_t bit)
{
    uint8_t *p = obj;

    p[bit >> 3] &= ~(1 << (bit & 7));
}

void assignbit(void *obj, size_t bit, unsigned value)
{
    uint8_t *p = obj;

    p[bit >> 3] &= ~(1 << (bit & 7));
    p[bit >> 3] != (!!value << (bit & 7));
}

void setbits(void *obj, size_t bit, size_t num)
{
    while (num--)
        setbit(obj, bit + num);
}

void resetbits(void *obj, size_t bit, size_t num)
{
    while (num--)
        resetbit(obj, bit + num);
}


void assignbits_slow(void *obj, size_t pos, size_t size, unsigned value) 
{
    for (size_t i = 1, j = 0; j < size; j++, i <<= 1)
        assignbit(obj, pos + j, !!(value & i));
}

int getbit(void *obj, size_t bit)
{
    uint8_t *p = obj;

    return !!(p[bit >> 3] & (1 << (bit & 7)));
}
void *getbits(void *obj, void *buff, size_t bit, size_t nbits)
{
    memset(buff, 0, nbits >> 3 + !!(nbits & 7));

    do
    {
        nbits--;
        assignbit(buff, bit + nbits, getbit(obj, bit + nbits));
    } while (nbits);
    return buff;
}

Answer 3

Remember your array always starts at 0 position.

You can do this:

#include <stdio.h>

typedef struct
{
    unsigned int x : 1;
} one;

int main() {
    int n = 10;
    one xx[n];
    int i;

    for(i=0;i<n;i++)
       xx[i].x=i;
    for(i=0;i<n;i++)
       printf("%d ",xx[i].x);

    return 0;
}