C语言中的位场结构阵列

如何创建大小可变的位字段数组？ 下面的代码是我尝试过的，但不起作用

#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;
}

#包括
int main（）
{
int n=4；
结构咬合{
无符号a1:2；
无符号a2:2；
:
:
无符号a（n-1）：2；
无符号a（n）：2；
}比特；
对于（i=1；i记住数组总是从0位置开始

您可以这样做：

#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;
}

#包括
类型定义结构
{
无符号整数x:1；
}一,；
int main（）{
int n=10；
一个xx[n]；
int i；
对于（i=0；i记住数组总是从0位置开始

您可以这样做：

#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;
}

#包括
类型定义结构
{
无符号整数x:1；
}一,；
int main（）{
int n=10；
一个xx[n]；
int i；
对于（i=0；i，
struct
的成员不能在运行时定义

您可以使用
char
数组和一些宏来模拟位数组

#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 */

  ...

#定义位数组（数组，位）\
无符号字符数组[位/8+1]
#定义SetBit（数组，n）\
do{array[n/8]|=（1>（n%8））&1）
内部主（空）
{
位数组（位，42）；/*定义42位并初始化为所有0
（实际上，这为（42/8+1）*8位分配了内存）*/
SetBit（位，2）；/*设置位2*/
int bit2=GetBit（位，2）；/*获取位2*/
...


根据您的代码，2位字的情况类似：

#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));
  }
}

#包括
#包括
#包括
#定义Define2BitWordArray（数组，两个\u位\u字）\
无符号字符数组[两个\u位\u字/4+1]
#定义Set2BitWord（数组，n，值）\
do{array[n/4]|=（无符号字符）（（value&0x11）>（2*（n%4））&0x11）
内部主（空）
{
尺寸n=10；
定义2位字数组（位，n）；/*定义10个2位字
（实际上，这是分配内存的
用于（10/4+1）*4两位）*/
memset（位，0，位大小）；/*将所有位设置为0*/
对于（size_t i=0；i
无法在运行时定义
结构的成员

您可以使用
char
数组和一些宏来模拟位数组

#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 */

  ...

#定义位数组（数组，位）\
无符号字符数组[位/8+1]
#定义SetBit（数组，n）\
do{array[n/8]|=（1>（n%8））&1）
内部主（空）
{
位数组（位，42）；/*定义42位并初始化为所有0
（实际上，这为（42/8+1）*8位分配了内存）*/
SetBit（位，2）；/*设置位2*/
int bit2=GetBit（位，2）；/*获取位2*/
...


根据您的代码，2位字的情况类似：

#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));
  }
}

#包括
#包括
#包括
#定义Define2BitWordArray（数组，两个\u位\u字）\
无符号字符数组[两个\u位\u字/4+1]
#定义Set2BitWord（数组，n，值）\
do{array[n/4]|=（无符号字符）（（value&0x11）>（2*（n%4））&0x11）
内部主（空）
{
尺寸n=10；
定义2位字数组（位，n）；/*定义10个2位字
（实际上，这是分配内存的
用于（10/4+1）*4两位）*/
memset（位，0，位大小）；/*将所有位设置为0*/
对于（size_t i=0；i
如果要对未限制大小的数据（实际上限制为大小除以8的最大值）上的一个或多个特定位进行操作。在本例中为Little endian

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;
}

void setbit（void*obj，大小\u t位）
{
uint8_t*p=obj；
p[bit>>3]|=（1>3]&=（1>3]&=（1>3]！=（！！值3+！！（nbits&7））；
做
{
nbits--；
assignbit（buff，bit+nbits，getbit（obj，bit+nbits））；
}while（nbits）；
返回buff；
}
如果要对未限制大小的数据（实际上限制为大小除以8的最大值）上的一个或多个特定位进行操作。在本例中为Little endian

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;
}

void setbit（void*obj，大小\u t位）
{
uint8_t*p=obj；
p[bit>>3]|=（1>3]&=（1>3]&=（1>3]！=（！！值3+！！（nbits&7））；
做
{
nbits--；
assignbit（buff，bit+nbits，getbit（obj，bit+nbits））；
}while（nbits）；
返回buff；
}
您使用的平台上的内存是否有限？是否没有可变大小的位域数组。是的内存有限，这就是我想限制int使用的大小的原因。您使用的平台上的内存是否有限？是否没有可变大小的位域数组。是的内存有限，这就是我想限制int使用的大小的原因nt。这不是位字段数组。这是具有（无用）位字段成员的结构类型的对象数组。这不是位字段数组。这是具有（无用）位字段成员的结构类型的对象数组。