如何在C语言中初始化库中的数组大小？

我正在为环形缓冲区创建一个包含.h和.C文件的C库。理想情况下，您可以在主项目中使用类似于

ringbuff_init（int buff_size）的东西初始化这个环形缓冲区库和发送的大小将是缓冲区的大小。当C中的数组需要静态初始化时，我该怎么做

我已经尝试了一些动态分配数组的方法，但没有成功。这项任务在某种程度上是可能的吗

我想做的是这样的：

int buffSize[];

int main(void)
{
    ringbuffer_init(100);      // initialize buffer size to 100
}

void ringbuffer_init(int buff_size)
{ 
    buffSize[buff_size];
}

size_t buffSize;
int * buffer;

int main(void)
{
    ringbuffer_init(100);      // initialize buffer size to 100
}

void ringbuffer_init(size_t buff_size)
{ 
    buffSize = buff_size;
    buffer = malloc(buff_size * sizeof(int));
}

这显然无法编译，因为数组应该在声明时初始化。所以我的问题是，当你为一个类似于缓冲区的东西创建一个库时，你如何在主程序中初始化它（以便在缓冲区库的.h/.c文件中）将缓冲区大小设置为想要的大小？
你应该使用malloc函数进行动态内存分配

它用于动态分配具有指定大小的单个大内存块。它返回一个void类型的指针，该指针可以转换为任何形式的指针

例如：

// Dynamically allocate memory using malloc() 
buffSize= (int*)malloc(n * sizeof(int));

// Initialize the elements of the array
for (i = 0; i < n; ++i) { 
    buffSize[i] = i + 1; 
} 

// Print the elements of the array 
for (i = 0; i < n; ++i) { 
    printf("%d, ", buffSize[i]); 
} 

//使用malloc（）动态分配内存
buffSize=（int*）malloc（n*sizeof（int））；
//初始化数组的元素
对于（i=0；i
静态/全局数组不能具有动态大小

如果必须具有全局动态数组，请声明一个全局指针，并使用
malloc/calloc/realloc
调用对其进行初始化

您可能还希望将其大小存储在附带的整数变量中，因为应用于指针的
sizeof
不会给出指针可能指向的块的大小

int *buffer;
int buffer_nelems;

char *ringbuffer_init(int buff_size)
{ 
    assert(buff_size > 0);
    if ( (buffer = malloc(buff_size*sizeof(*buffer)) ) )
        buffer_nelems = buff_size;
    return buffer;
}

您希望使用动态内存分配。您最初尝试的直接翻译如下：

int buffSize[];

int main(void)
{
    ringbuffer_init(100);      // initialize buffer size to 100
}

void ringbuffer_init(int buff_size)
{ 
    buffSize[buff_size];
}

size_t buffSize;
int * buffer;

int main(void)
{
    ringbuffer_init(100);      // initialize buffer size to 100
}

void ringbuffer_init(size_t buff_size)
{ 
    buffSize = buff_size;
    buffer = malloc(buff_size * sizeof(int));
}

然而，这里的解决方案非常糟糕。让我在这里列出问题：

没有检查malloc的结果。如果分配失败，它可能返回NULL
缓冲区大小需要和缓冲区一起存储，否则无法从库代码中知道其大小。保持这些全局变量是不干净的
说到这里，这些全局变量绝对不是线程安全的。如果多个线程调用库的函数，则结果是不可预测的。您可能希望将缓冲区及其大小存储在从init函数返回的结构中
没有任何东西可以阻止您连续多次调用init函数，这意味着每次都会覆盖缓冲区指针，从而导致内存泄漏
最终必须使用
free
函数释放分配的内存
总之，您需要非常仔细地考虑您在库中公开的API，实现虽然不是非常复杂，但也不会是微不足道的

更正确的方法是：

typedef struct {
    size_t buffSize;
    int * buffer;
} RingBuffer;

int ringbuffer_init(size_t buff_size, RingBuffer * buf)
{
    if (buf == NULL)
        return 0;

    buf.buffSize = buff_size;
    buf.buffer = malloc(buff_size * sizeof(int));

    return buf.buffer != NULL;
}

void ringbuffer_free(RingBuffer * buf)
{
    free(buf.buffer);
}

int main(void)
{
    RingBuffer buf;
    int ok = ringbuffer_init(100, &buf);      // initialize buffer size to 100

    // ...

    ringbuffer_free(&buf);
}

即使这样也不是没有问题，因为如果对同一个缓冲区多次调用init函数，仍然存在潜在的内存泄漏，并且库的客户端不能忘记调用free函数。
您可能正在寻找动态内存分配（
malloc
，
free
等）您不需要强制转换
malloc
-您也不应该这样做-请参见