Question

所以，我有一些代码，类似于以下代码，将结构添加到结构列表中：

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

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

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

    // and set list to be equal to the new head of the list
    list = newNode; // This line works, but list only changes inside of this function
}

这些结构定义如下：

typedef struct Bar
{
    // this isn't too important
} Bar;

#define EMPTY_LIST NULL

typedef struct BarList
{
    Bar * val;
    struct  BarList * nextBar;
} BarList;

然后在另一个文件中，我执行以下操作：

BarList * l;

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

然而，在此之后，我仍然指向EMPTY_LIST，而不是barPush内部创建的修改版本。如果我想修改它，或者是否需要其他暗咒语，我是否必须将列表作为指针传递给指针？

Answer 1

如果要执行此操作，则需要传入指针指针。

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

Answer 2

通用答案：将指针传递给您想要更改的内容。

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

Answer 3

请记住，在C中，一切都按值传递。

你传入一个指向指针的指针，就像这个

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

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

}

Answer 4

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

Answer 5

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

Answer 6

修改另一个函数中的指针需要一个称为多重间接的概念，我将在后面解释，因为@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 的指针，那么它将指向它，但调用者（main）函数中的指针变量作为参数传递给to 函数 allocater() 仍然指向在函数调用之前指向的相同数据（即 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() 使用此调用

allocater(&ptrMain);

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

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

这在以下程序中使用。

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

// 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);) 的地址传递给 trueAllocer，以便稍后更改 ptrMain 需要指向的位置在 trueAllocater() 或其他函数中，为此，该函数需要接受具有正确间接级别的间接指针，这是在参数声明中添加另一个 * 以我目前对传递的变量的理解。

也就是说，我们需要将 trueAllocater() 函数参数作为 int ** 来自 int * 中的 withIndirection.c 而不是 noIndirection.c 所以间接级别将被统计。

当调用者的参数变量 ptrMain 的实际地址被传递给函数时。临时 ptrTrueAllocater 参数变量函数指向调用者（ptrMain）函数中指针变量main的地址，而不是指针变量ptrMain（程序中的NULL）指向的地址在函数中（main）。

如果我们取消引用 ptrTrueAllocater 变量，ptrMain 指向的地址将被泄露，因为 ptrTrueAllocater 临时变量指向调用者（main）{{1 }} 变量本身不是它的内容。

解引用的ptrMain变量的内容将是调用者(ptrTrueAllocater)的变量(main)指向的数据的地址，所以我们必须做一个额外的解引用才能得到最终的数据。

所以我们必须取消引用一次以获取它指向的 ptrMain 的地址，以便更改需要指向和取消引用的 ptrMain 两次以获取 ptrMain 所指向的实际数据，即 ptrMain。

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

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

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

声明中每次添加 * 都会增加指针间接级别每次取消引用都会降低指针间接级别，从而接近数据。

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

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

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

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

6 个答案: