Question

所以我目前有一个看起来像这样的结构：

typedef struct example {
    bool arr[]; //i would like this to be an array of booleans,
                //but i don't know the size right now; this is
                //probably wrong
} example_t;

我还有一个看起来像这样的创建函数：

example_t *newExample(int SIZE){
    example_t *example = malloc(sizeof(example_t));
    //initialize arr to a bool array of size SIZE, ideally all false!
    example->arr = ???
    return example;
}

从此，我可以做类似的事情：

 example_t *example = newExample(MAX);
 if ( example->arr[10] )
      ....

这是否可以在C中创建一个可变大小的布尔数组？

供参考：我需要将整数映射到char*或bool，因此我可以调用arr[num]并且可以获得字符串/单词或true / false值。两种方式，我不知道如何声明，然后用可变大小初始化。提前谢谢！

Answer 1

在C99中，您可以使用flexible array members，其中最后一个成员可以是没有给定维度的数组，但struct中必须至少有2个成员。

您可以使用指针（为了简洁起见，我使用的是int而不是bool）：

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

typedef struct example {
    int *arr;
} example_t;

static example_t *newExample(size_t SIZE)
{
    example_t *example = malloc(sizeof(example_t) + sizeof(int) * SIZE);

    example->arr = (int *)(example + 1);
    example->arr[5] = 5;
    return example;
}

int main(void)
{
    example_t *x = newExample(10);

    printf("%d\n", x->arr[5]);
    free(x);
    return 0;
}

但是这没有多大意义，为什么不添加包含元素数量的第一个成员呢？

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

typedef struct example {
    size_t size;
    int arr[];
} example_t;

static example_t *newExample(size_t SIZE)
{
    example_t *example = malloc(sizeof(example_t) + sizeof(int) * SIZE);

    example->size = SIZE;
    example->arr[5] = 5;
    return example;
}

int main(void)
{
    example_t *x = newExample(10);

    printf("%d\n", x->arr[5]);
    free(x);
    return 0;
}

使用此方法有一个优点：您可以将对象传递给任何函数，而无需为该大小传递额外的参数。

Answer 2

您可以通过在示例后添加额外内存来执行此操作：

size_t boolsize = 10 * sizeof(bool);

struct example *ptr = malloc(sizeof *ptr + boolsize);

这样你只需要调用一次malloc并且内存是连续布局的

Answer 3

如果您事先不知道数组的大小，可以简单地将其作为指针并稍后进行分配。

typedef struct example {
    bool* arr;  // <-- Pointer
    int size;   // <-- Size of the array
} example_t;

创建一个新数组遵循相同的步骤。

example_t* newExample(int size) {
    int i;
    example_t* example = malloc(sizeof(example_t));
    example->arr = malloc(sizeof(bool) * size);
    example->size = size;
    for(i = 0; i < size; i++)
      example->arr[i] = false;
    return example;
}

请勿忘记在使用后释放bool arr和struct本身的记忆！

Answer 4

允许结构的最后一个成员是一个未指定大小的数组，称为“灵活数组成员”，因此您的声明是正确的。*您有责任计算malloc的正确大小，所以在您的情况下，做：

example_t* example = malloc(sizeof(example_t) + SIZE * sizeof(bool));

如果您希望将其初始化为0（典型布尔类型中为false），请使用calloc：

example_t* example = calloc(1, sizeof(example_t) + SIZE * sizeof(bool));

或者使用memset：

在malloc之后初始化

memset(example, 0, sizeof(example_t) + SIZE * sizeof(bool));

*）只要您的结构中有其他成员在数组之前。否则结构将是无用的，你可以只分配普通数组：

bool *example = malloc(SIZE * sizeof(bool));

Answer 5

做这些事情：

结构定义：

typedef struct example {
    bool *arr; 
} example_t;

创建：

example_t *newExample(int SIZE){
    example_t *example = malloc(sizeof(example_t));
    example->arr = malloc(SIZE*sizeof(bool)) // allocate space for arr
    for(int i = 0;i < SIZE;i++)
        example->arr[i] = false; // initialize all of arr elements to false
    return example;
}

或者，您也可以在结构中保留一个变量来存储arr数组的大小（与*arr一起），这样您以后可以在访问arr时使用它阵列。

结构example的使用完成后，您必须手动使用free()。

在C中初始化一个可变大小的布尔数组

5 个答案: