如何在标准 C 中正确使用双指针（指向指针的指针）结构数组？

Question

我有一个结构数组作为函数参数，数组的大小是动态的。我的同事说我必须使用双指针，因为结构数组中包含的值将被覆盖。

将成为双指针的参数如下:

xPIDConfig_t **pxPIDConfig

下面是 xPIDConfig_t 的结构：

typedef struct
{
    ePIDType_t ePIDType;
    /* Common fields for the different types of PID */
    float fLowerSaturationLimit;
    float fUpperSaturationLimit;
    float fOldInput;
    float fIError;
    uint32_t ulDeltaTime;
    eBool_t bSaturationEnable;
    eBool_t bAntiWindupEnable;
    eBool_t bNegativeErrorEmptyIError;
    
    union
    {
        /* Parallel PID fields */
        struct
        {
            float fProportionalGain;
            float fIntegralGain;
            float fDerivativeGain;
        }xParallelPID;
        /* Non-interactive PID fields */
        struct
        {
            float fControllerGain;
            uint32_t ulIntegralTime;
            uint32_t ulDerivativeTime;
        }xNonInteractivePID;
    }xUniqueFields;
}xPIDConfig_t;

pxPIDConfig 数组的大小会有所不同。

但我不确定如何分配那个双指针，甚至不知道如何使用包含双指针的函数。

我只是想知道是否有人有一个很好的代码示例来说明如何使用具有可变大小的双指针数组的函数？以及如何在函数内正确更改数组本身包含的值？

现在这就是我在函数中更改值的方式：

pxPIDConfig->ePIDType = ePIDType;
pxPIDConfig->fOldInput = 0;
pxPIDConfig->fIError   = 0;
pxPIDConfig->ulDeltaTime       = ulDeltaTime;
pxPIDConfig->bSaturationEnable = bIsSaturationEnable;
pxPIDConfig->bAntiWindupEnable = bIsAntiWindupEnable;
pxPIDConfig->bNegativeErrorEmptyIError = bNegativeErrorEmptyIError;

当指针为双精度时，我是否必须使用双精度'->'？这让我很困惑。

谢谢大家的帮助

/***************** 编辑 ************************** **********

我的函数现在可以正常工作，但我被告知我需要使用内存分配，因为我的数组大小会根据我要实现的循环数而变化。

这是我的函数的参数：

eError_t eControlCascadeInit( uint8_t ucNumberOfLoops, ePIDType_t *pePIDType, xPIDConfig_t **pxPIDConfig, float *pfLowerLimit, float *pfUpperLimit, uint32_t *pulDeltaTime, \
                            eBool_t *pbIsSaturationEnable, eBool_t *pbIsAntiWindupEnable, eBool_t *pbNegativeErrorEmptyIError, \
                            float *pfPGain, float *pfIGain, float *pfDGain, float *pfCGain, uint32_t *pulITime, uint32_t *pulDTime )

它们都是大小为 ucNumberOfLoops 的数组。它们都是只读数组，除了 pxPIDConfig 是只写的。该函数使用通过数组传递给函数的参数初始化数组中存在的所有 xPIDConfig_t。

array[0] 包含正在初始化的第一个 PID 控制器的参数。

array[ 1 ] 包含正在初始化的第二个 PID 控制器的参数等等...

函数中的所有参数都是这样。

希望它能让我的问题更清楚？

Answer 1

这里有一个如何使用双指针的例子，来改变函数中的指针：

void allocate(xPIDConfig_t **array, size_t size)
{
    *array = malloc(sizeof(**array) * size);

    /* some examples how to access the struct members vi double pointer -*

    (*array) -> ulDeltaTime = 100;
    (**array).ulDeltaTime = 100;
    (*(array + 5)) -> ulDeltaTime = 100;
    array[5] -> ulDeltaTime = 100;
    (*array[5]).ulDeltaTime = 100;

}

int main(void)
{
    xPIDConfig_t *array;

    allocate(&array, 100);
    printf("%s\n", array ? "success" : "failure");
    free(array);
}

Answer 2

仅限于解决有关您的标题问题的假设和问题：

"How to use double pointers (pointer to pointer) for an array of structures properly in standard C"

首先，仅仅因为函数参数可能有一个双指针（即xPIDConfig_t **pxPIDConfig）并不意味着变量需要用双指针分配内存，即如果函数eg被这样调用: funcChangeParam(&pxPIDConfig); 这通常意味着传递的 object 需要以某种方式更改，要求传递的地址，而不是 object 本身。另外，如果object本身是一个指针，（比如指向一个structobject的几个实例的指针。）那么函数用来传递object进行修改将使用 void funcChangeParam(xPIDConfig_t **pxPIDConfig); 等参数进行原型化（注意此处的双指针。）

所以用这个函数原型使内存分配看起来像这样：

void funcChangeParam(xPIDConfig_t **pxPIDConfig); //allocate memory for multiple instances of struct xPIDConfig_t *pxPIDConfig = malloc(countOfInstances * sizeof(*pxPIDConfig); if(pxPIDConfig) { //use pxPIDConfig funcChangeParam(&pxPIDConfig);pass pointer to multiple instances of struct

并且在调用函数中对 object 成员的引用可以使用以下表示法。例如：

//in a loop or other construct where i is defined from 0 to countOfInstances - 1 (*pxPIDConfig)[i].ePIDType = ePIDType;//modification of assignment per your example //etc. //The following is a trivial example for illustration purposes. //Code here uses a simplified struct, function //prototype, and simple calling example, the concept //of which easily translates to what you are //asking about. typedef struct { int num; }test_s; void change(test_s **new); int main(){ test_s *test = malloc(10*sizeof *test); change(&test); return 0; } void change(test_s **new) { for(int i=0;i<10;i++) { (*new)[i].num = (i+1)*3; //init all instances to some value } }

Answer 3

如果函数将数组重新分配为不同的大小，则只需要双指针。如果大小没有变化，您可以只传递一个指向数组元素（通常是第一个元素）的指针，以及函数所需的任何大小或索引。例如：

extern void frobPidConfig(xPIDConfig_t *);

// 'frob' the xPIDConfig_t array elements from index a to b
void frobSomePidConfigs(xPIDConfig_t *pidconfigs, unsigned int a, unsigned int b)
{
    unsigned int i;
    for (i = a; i <= b; i++)
    {
        frobPidConfig(&pidConfigs[i]);
        // Example of member access:
        pidConfigs[i].ulDeltaTime = 42;
    }
}

调用代码示例：

    xPIDConfig_t *pidConfigs;
    unsigned int n = 10; // or whatever...
    pidConfigs = calloc(sizeof *pidConfigs, n);
    if (!pidConfigs)
    {
        // Allocation error
        exit(1);
    }
    /* ... */
    frobSomePidConfigs(pidConfigs, 2, 5);

另一方面，如果函数需要重新分配数组并初始化任何新元素，可以使用像这样的双指针来完成：

extern void initPidConfig(xPIDConfig_t *);

void reallocPidConfigs(xPIDConfig_t **pidConfigs, unsigned int oldSize, unsigned int newSize)
{
    unsigned int i;
    // Reallocate to new size
    xPIDConfig_t *realloced = realloc(*pidConfigs, sizeof **pidConfigs * newSize);
    if (newSize && !realloced)
    {
        // allocation error
        exit(EXIT_FAILURE);
    }
    *pidConfigs = realloced;
    // Initialize any additional elements
    for (i = oldSize; i < newSize; i++)
    {
        initPidConfig(*pidConfigs + i); // or: initPidConfig(&(*pidConfigs)[i]);
        // Examples of member access:
        (*pidConfigs)[i].bSaturationEnable = true;
        (*pidConfigs + i)->bAntiWindupEnable = true;
    }
}

调用代码示例：

    xPIDConfig_t *pidConfigs = NULL;
    // Note: realloc of the NULL pointer in *pidConfigs is OK.
    reallocPidConfigs(&pidConfigs, 0, 10);
    frobSomePidConfigs(pidConfigs, 2, 5);

如何在标准 C 中正确使用双指针（指向指针的指针）结构数组？

How to use double pointers (pointer to pointer) for an array of structures properly in standard C?

c

double

struct

pointers

structure