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

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

<块引用>

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

首先，仅仅因为函数参数可能有一个双指针（即xPIDConfig_t **pxPIDConfig）并不意味着变量需要用双指针分配内存，即如果函数eg被这样调用：{ {1}} 这通常意味着需要以某种方式更改被传递的对象，需要传递的地址，而不是对象本身。此外，如果对象本身是一个指针（例如指向 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

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 中正确地将双指针（指向指针的指针）用于结构数组？

3 个答案: