如何修改已在 C 中传递到函数中的指针？

是的，您必须传入指向指针的指针。C 按值传递参数，而不是按引用传递参数。

请记住，在 C 语言中，一切都是通过值传递的。

将指针传入指针，如下所示

int myFunction(int** param1, int** param2) {

// now I can change the ACTUAL pointer - kind of like passing a pointer by reference 

}

如果要执行此操作，则需要将指针传递到指针。

void barPush(BarList ** list,Bar * bar)
{
    if (list == NULL) return; // need to pass in the pointer to your pointer to your list.

    // if there is no move to add, then we are done
    if (bar == NULL) return;

    // allocate space for the new node
    BarList * newNode = malloc(sizeof(BarList));

    // assign the right values
    newNode->val = bar;
    newNode->nextBar = *list;

    // and set the contents of the pointer to the pointer to the head of the list 
    // (ie: the pointer the the head of the list) to the new node.
    *list = newNode; 
}

然后像这样使用它：

BarList * l;

l = EMPTY_LIST;
barPush(&l,&b1); // b1 and b2 are just Bar's
barPush(&l,&b2);

乔纳森·莱夫勒（Jonathan Leffler）建议在评论中返回新的列表负责人：

BarList *barPush(BarList *list,Bar *bar)
{
    // if there is no move to add, then we are done - return unmodified list.
    if (bar == NULL) return list;  

    // allocate space for the new node
    BarList * newNode = malloc(sizeof(BarList));

    // assign the right values
    newNode->val = bar;
    newNode->nextBar = list;

    // return the new head of the list.
    return newNode; 
}

用法变为：

BarList * l;

l = EMPTY_LIST;
l = barPush(l,&b1); // b1 and b2 are just Bar's
l = barPush(l,&b2);

这是一个典型的问题。返回分配的节点或使用指针的指针。在 C 中，您应该将指向 X 的指针传递给要修改 X 的函数。在这种情况下，由于要修改指针，因此应将指针传递给指针。

一般答案：传递指向要更改的内容的指针。

在这种情况下，它将是指向要更改的指针的指针。

在另一个函数中修改指针需要一个称为多重间接的概念，我将在后面解释它，鉴于@geofftnz使用多个间接的剧透解决方案。我想做的是尽力用 C 解释多个间接。

考虑以下两个程序，我将演练代码。

以下程序不使用多个间接，因此失败。

程序有错误：

// filename: noIndirection.c
#include <stdio.h>
#include <stdlib.h>

void allocater(int *ptrTempAllctr)
{
    ptrTempAllctr = malloc(sizeof(int));
    if (ptrTempAllctr == NULL) {
        perror("in allocater() memory allocation error");
        exit(EXIT_FAILURE);
    }
}

int main() 
{
    int *ptrMain = NULL;
    allocater(ptrMain);
    if (ptrMain == NULL) {
        printf("ptrMain is points to NULL\n");
        return 1;
    }
    //free(ptrMain);  // we don't have to free because it will be invalid free.
    return 0;
}

考虑上面的 Program（），它有一个变量，它是一个指向 int 的指针。 如果它被传递给函数，则在函数 scope（body） 中会创建一个临时指针变量，因为函数的参数是临时变量，当它们超出范围时，它们会被删除。noIndirection.cptrMain

临时指针变量（这是一个参数）将指向 caller（） 函数的变量（指向 ）作为参数传递给函数时所指向的内容。ptrTempAllctrmainptrMainNULL

如果我们使用或分配另一个指向临时变量的指针，那么它将指向它，但 caller（） 函数中作为参数传递给 to 函数的指针变量仍然指向它在函数调用之前指向的相同 data（即 ）。malloc()ptrTempAllctrmainallocater()NULL

当 called（） 函数超出范围时，临时指针变量会从堆栈中弹出，并且内存未分配，我们最终会泄漏内存。 为了绕过这个限制，我们需要使用多个间接。allocater()

多重间接：

Multiple indirection when we use of pointer/s to pointer/s in varying level(with multiple `*`) eg: `int **pp, int ***ppp`, etc.

我们使用 address-of（） 运算符分配它们。&

多个间接指针类型变量的作用是，允许我们使 指向指针变量本身的指针，用于修复上述程序。 这允许我们使用此调用将 的地址传递给ptrMainallocater()

allocater(&ptrMain);

因此，上面的程序不允许我们这样做，请参阅实现此多重间接的程序。noIndirection.cwithIndirection.c

在这种情况下，我们需要指向 int pointer（） 的指针作为函数的函数参数来解决上述错误的程序（noIndirection.c）。int **ptrMainallocater()

这在以下程序中使用。

以下程序使用多个间接来解决先前程序中的错误。

// filename: withIndirection.c
#include <stdio.h>
#include <stdlib.h>

void trueAllocater(int **ptrTrueAllocater)
{
    *ptrTrueAllocater = (int *) malloc(sizeof(int));
    if (ptrTrueAllocater == NULL) {
        perror("in trueAllocater() memory allocation error");
        exit(EXIT_FAILURE);
    }
}

int main(void) 
{
    int *ptrMain = NULL;
    trueAllocater(&ptrMain);
    if (ptrMain == NULL) {
        printf("memory not allocated\n");
        return EXIT_FAILURE;
    }

    printf("memory allocated and assigned to ptrMain");
    printf(" from trueAllocater\n");

    free(ptrMain);
    return EXIT_SUCCESS;
}

从现在开始，请参阅程序以供参考。withIndirection.c

为了解决我们的问题，我们需要将指针变量 （） 的地址传递给 trueAllocater，以便稍后更改它需要指向的位置或其他函数， 为此，函数需要接受具有正确间接级别的间接指针， 这是在参数声明中添加另一个 *，以达到我目前对传递的变量的理解。ptrMaintrueAllocater(&ptrMain);ptrMaintrueAllocater()

通过手段，我们需要将函数参数设置为 from in 而不是 in，因此间接级别将被统计。trueAllocater()int **int *withIndirection.cnoIndirection.c

当调用方的参数变量的地址被传递给函数时，变量的实际地址。临时参数变量 函数指向 caller（） 函数中指针变量的地址，而不是 function（） 中指针变量（在程序中）指向的地址。ptrMainptrTrueAllocaterptrMainmainptrMainNULLmain

如果我们取消引用变量，则指向的地址将被显示，因为临时变量指向的是 caller（） 变量本身，而不是它的内容。ptrTrueAllocaterptrMainptrTrueAllocatermainptrMain

取消引用的变量的内容将是调用者（）的变量（）指向的数据的地址， 因此，我们必须执行一次额外的取消引用才能获得最终数据。ptrTrueAllocatermainptrMain

因此，我们必须取消引用一次才能获得它所指向的地址，以便更改需要指向的位置并取消引用 两次来获得实际数据，即 .ptrMainptrMainptrMainNULL

@PaulWicks您打算更改，因此您必须取消引用一次才能分配或更改其指向的位置。

使用指针进行多个间接的目的是创建多维数组并传递需要指向某物的指针参数。

我们需要根据我们必须操作的类型来更改变量，如下所示：

在声明中每添加一个 * 都会增加指针间接级别 每次取消引用都会降低接近数据的指针间接级别。

我们可以通过将地址返回给分配给所需指针变量的调用方函数来解决此问题。

是的，我们可以使用这种多间接变量语法来创建一个或 多维数组。如果初学者花时间，一开始会让初学者感到困惑 阅读大量代码，他们将能够找到它们之间的区别。

如果我错了，请纠正我，请提供反馈并让我知道是什么 多个间接指针的其他用途。 为我糟糕的英语道歉。 这些资源帮助我了解了多种间接性。https://boredzo.org/pointers/#function_pointers https://cseweb.ucsd.edu/~ricko/rt_lt.rule.html

main() {
    node *x;
    newNode(&x);

}

void newNode(node **a)
{
    *a = (node *)malloc(sizeof(node));
    //.........
}