Question

我正在调试一些代码，只是想确保我在我的struct中设置指向数组的指针的方式是正确的。

这是我想要做的一个例子：

typedef struct Foo
{
    uint32_t *bar;
} Foo

int main(void)
{
    Foo *foo;
    uint32_t *bar[20];

    foo = (Foo *)malloc(sizeof(Foo));
    *bar = malloc(sizeof(uint32_t) * 20);

    for(int i = 0; i < 20; i++)
    {
        bar[i] = (uint32_t*)malloc(sizeof(uint32_t));
    } 

    foo->bar = *bar;
}

Answer 1

代码

uint32_t *bar[20];

将bar声明为指向uint32_t的20个指针的数组，这可能不是您想要的。由于您使用malloc动态分配数组，因此应将bar声明为指针而不是数组：

uint32_t **bar;

Answer 2

您可能需要考虑使用单个malloc()而不是您正在使用的分段方法进行内存分配。例如，您可能需要考虑执行以下操作。

这会分配一次调用malloc()所需的内存，因此只需要调用free()即可释放内存。它更快，并且倾向于使堆更少碎片化并且更易于管理。

typedef struct
{
    uint32_t *bar[1];  // an array of size one that makes array syntax easy
} Foo;

Foo *FooCreateFoo (unsigned int nCount)
{
    // create an array of pointers to uint32_t values along with the
    // memory area for those uint32_t data values.
    Foo *p = malloc (sizeof(uint32_t *) * nCount + sizeof(uint32_t) * nCount);

    if (p) {
        // we have memory allocated so now initialize the array of pointers
        unsigned int iLoop;
        uint32_t *pData = p->bar + nCount;  // point to past the last array element
        for (iLoop = 0; iLoop < nCount; iLoop++) {
            // set the pointer value and initialize the data to zero.
            *(p->bar[iLoop] = pData++) = 0;
        }
    }

    return p;
}

int main(void)
{
    Foo *foo = FooCreateFoo (20);

    if (! foo) {
        //  memory allocation failed so exit out.
        return 1;
    }

    // ...  do things with foo by dereferencing the pointers in the array as in
    *(foo->bar[1]) += 3;  // increment the uint32_t pointed to by a value of 3

    free (foo);       // we be done with foo so release the memory
}

将struct中的指针设置为C中的数组

2 个答案: