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

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

乔纳森·莱弗勒在评论中建议将新的榜首回归：

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中，一切都是按值传递的。
将指针传递给指针，如下所示

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

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

}

是的，你必须传入一个指向指针的指针。C通过值传递参数，而不是通过引用。

这是一个经典的问题。要么返回分配的节点，要么使用指针的指针。在C语言中，你应该将一个指向X的指针传递给一个你想修改X的函数。在这种情况下，既然你想修改一个指针，你就应该将一个指针传递给一个指针。

修改另一个函数中的指针需要一个叫做多重间接的概念，我会在后面解释它，剧透解决方案given @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;
}

考虑上面的程序（noIndirection.c），它有一个变量ptrMain，它是一个指向int的指针。如果它被传递给一个函数，在函数作用域（主体）中创建一个临时指针变量，因为函数的参数是临时变量，当它们超出作用域时会被删除。
临时指针变量ptrTempAllctr（它是一个参数）将指向调用方（main）函数的变量ptrMain（它指向NULL）在作为参数传递给函数时所指向的内容。
如果我们使用malloc()或将另一个指针分配给临时变量ptrTempAllctr，那么它将指向它，但作为参数传递给函数allocater()的调用方（main）函数中的指针变量仍然指向在函数调用之前指向的相同数据（即NULL）。
当被调用的（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（&）运算符分配它们。
多个间接指针类型变量的作用是，允许我们创建一个指向指针变量本身的指针，以修复上述程序。这允许我们使用此调用将ptrMain的地址传递给allocater()
x1米15英寸
因此，上面的程序noIndirection.c不允许我们这样做，请参见程序withIndirection.c来实现这种多重间接。
在这种情况下，我们需要指向int指针（int **ptrMain）的指针作为allocater()函数的函数参数，以解决上述有缺陷的程序（noIndirection.c）。
这在下面的程序中使用。
下面的程序使用多重间接来解决前一个程序中的bug。

// 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以供参考。
要解决这个问题，我们需要传递指针变量ptrMain的地址（trueAllocater(&ptrMain);）到trueAllocater，以便将ptrMain更改为稍后在trueAllocater()或另一个函数中需要指向的位置，为此，该函数需要接受具有正确间接级别的间接指针，也就是在我目前对传递的变量的理解中添加另一个 *。
通过方法，我们需要将trueAllocater()函数参数从withIndirection.c中的int *设置为int **，而不是noIndirection.c，以便满足间接寻址级别。
当调用程序的参数变量ptrMain的实际地址被传递给函数时，函数中的临时参数变量ptrTrueAllocater指向指针变量ptrMain在调用程序中的地址（main）函数，而不是函数（main）中指针变量ptrMain（在程序中为NULL）所指向的对象。
如果我们取消引用ptrTrueAllocater变量，ptrMain指向的地址将被显示，因为ptrTrueAllocater临时变量指向调用者（main）ptrMain变量本身，而不是它的内容。
取消引用的ptrTrueAllocater变量的内容将是调用者（main）的变量（ptrMain）所指向的数据的地址，因此我们必须执行一次额外的取消引用以获得最终数据。
因此，我们必须解引用一次以获得它所指向的ptrMain的地址，以便改变ptrMain需要指向的位置，并且解引用两次以获得ptrMain所指向的实际数据，即NULL。
@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));
    //.........
}