如何在标准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

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

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

Answer 3

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

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

首先，仅仅因为函数参数可能有一个双指针（即xPIDConfig_t **pxPIDConfig）并不意味着该变量需要使用双指针分配内存，即如果函数eg被这样调用：funcChangeParam(&pxPIDConfig);这通常意味着被传递的对象需要以某种方式进行更改，需要传递 的地址，而不是对象本身。此外，如果对象本身是一个指针（例如指向 struct 对象的多个实例的指针。）那么用于传递对象以进行修改的函数将使用诸如 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

调用函数内部对对象成员的引用可以使用以下符号。例如：

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