c - 对函数调用中的单指针和双指针参数感到困惑

Question

我试图更深入地了解 C 函数中的指针参数。我编写了一个测试程序来尝试查看将单指针与双指针传递给函数然后对其进行修改之间的区别。

我有一个有两个功能的程序。第一个函数modifyMe1将单个指针作为参数并将 a 属性更改为 7。第二个函数modifyMe2将双指针作为参数并将 a 属性更改为 7。

我希望第一个函数modifyMe1是“按值传递”，也就是说，如果我传入我的结构指针，C 将创建它所指向的数据的副本。而对于后者，我正在做一个“按引用传递”，它应该修改适当的结构。

然而，当我测试这个程序时，这两个函数似乎都修改了适当的结构。我知道我对指针的性质存在误解，这肯定是论据。有人可以帮我解决这个问题吗？

谢谢！

这是我所拥有的：

#include <stdio.h>
#include <stdlib.h>

struct myStructure {
    int a;
    int b;
};

void modifyMe1(struct myStructure *param1) {
    param1->a = 7;
}

void modifyMe2(struct myStructure **param1) {
    (*param1)->a = 7;
}

int main(int argc, char *argv[]) {
    struct myStructure *test1;

    test1 = malloc(sizeof(test1));
    test1->a = 5;
    test1->b = 6;

    modifyMe1(test1);

    printf("a: %d, b: %d\n", test1->a, test1->b);

    // set it back to 5
    test1->a = 5;
    printf("reset. a: %d, b: %d\n", test1->a, test1->b);

    modifyMe2(&test1);

    printf("a: %d, b: %d\n", test1->a, test1->b);


    free(test1);
    return 0;
}

我的输出是：

$ ./a
a: 7, b: 6
reset. a: 5, b: 6
a: 7, b: 6

score 22 · Accepted Answer

您可以在 C 中以不同的方式传递参数（Captain Obvious，是的）。

按价值。然后将其复制到堆栈中。所以函数在函数框架中有变量的本地副本。对参数的任何更改都不会更改传递的值。这就像“只读”模式
```
void fooByValue(myStructure_t arg) {
    printf("passed by value %d %d\n", arg.a, arg.b);
    arg.a = 0;
}
```
通过指针。然后传递这个变量的地址的副本（所以是的，它仍然是按值传递的，但是你传递的是地址的值，而不是整个参数的值）。所以这就像“读写”模式。由于您可以通过其地址访问传递的变量，因此您可以在函数外部更改此变量的值。
```
void fooByPtr(myStructure_t *arg) {
    printf("passed by pointer %d %d\n", arg->a, arg->b);
    arg->a = 0;
}
```
但！您仍然无法修改指针。

因此，如果要修改指针，则应将指针传递给指针。这就像“读写修改”模式：

void fooByDblPtr(myStructure_t **arg) {
    *arg = (myStructure_t*) malloc(sizeof(myStructure_t));
    (*arg)->a = 10;
    (*arg)->b = 20;
}

如果那只是指针，那么就会有内存泄漏：

void fooByDblPtr(myStructure_t *arg) {
    arg = (myStructure_t*) malloc(sizeof(myStructure_t));
    (arg)->a = 10;
    (arg)->b = 20;
}

因为在这里您将新地址分配给地址的本地副本，并且此参数将在函数完成后被销毁。

UPD。例如，我们有

void fooByPtr(myStructure_t *arg) {
    printf("addr inside foo before %p\n", arg);
    arg = (myStructure_t*) malloc(sizeof(myStructure_t));
    (arg)->a = 10;
    (arg)->b = 20;
    printf("addr inside foo after %p\n", arg);
}

void main() {
    myStructure_t *x = NULL;
    x = malloc(sizeof(myStructure_t));
    x->a = 10;
    x->b = 20;
    printf("x addr before = %p\n", x);
    fooByPtr(x);
    printf("x addr after = %p\n", x);
    free(x);
}

分配内部函数内存并将指针分配给局部变量。调用者仍然保持旧值。函数调用后，我们丢失了内存地址，因此无法释放。

简短的结论：有一个简单的规则 - 如果需要更改参数，请将指针传递给它。因此，如果要更改指针，请将指针传递给指针。如果要更改双指针，请将指针传递给指向指针的指针。

通过指针传递参数也快得多，因为您不需要复制堆栈上的所有值（当然，如果值大于指向该值的指针，否则通过指针传递只读是没有意义的）。但这很危险，因为它可以在函数内部进行修改。因此，您可以使用 const 关键字来保护定义它的参数
```
void constFoo(const myStructure_t *arg) {
    arg->a = 10;    //compilation error
    arg->b = 20;    //compilation error
}
```
这在您使用 3rd 方库时非常有用：函数签名告诉您函数是否可以修改您的参数。尽管 const 是可选的，但每次可能时都编写 const 关键字是合适的
传递数组。通常，还发送数组大小（因此，size_t）作为参数。您将数组作为指针传递。
```
void foo (int *buf, size_t nbuf) {
    ....
}
```
有时您可以找到开发人员发送指向对象而不是数组的指针的代码，例如
```
void foo (int *buf, size_t size) {
    size_t i;
    for (i = 0; i < size; i++) {
        printf("%d ", buf[i]);
    }
}

int main(int argc, char **argv) {
    int a = 10;
    int buf[1] = { 10 };
    foo(buf, 1);
    foo(&a, 1);
}
```
在这种情况下，一个元素的数组和指向元素的指针的行为相似（尽管它们并不相同）。

score 3 · Accepted Answer

使用常规参数，假设int您获得
带有指针参数的本地副本，假设您可以使用双指针参数int*修改它所指向的内容，假设您可以修改指针本身，即“重新指向”它。
int**

score 1 · Accepted Answer

添加另一个功能：

void modifyMe0(struct myStructure param1)
{
    param1.a = 7;
}

这会按值传递结构。函数中所做的修改不会反映在传递给的参数中modifyMe0()。

像这样添加调用代码：

printf("Before 0: a = %d, b = %d\n", test1->a, test1->b);

modifyMe0(*test1);

printf("After  0: a = %d, b = %d\n", test1->a, test1->b);

请注意，调用代码中的 before 和 after 值是相同的。您还可以将打印添加到您的modifyMeN()函数中，以证明在其中修改了值。

当您将指向结构的指针传递给被调用函数时，可以修改调用函数中结构的值。当你将结构体按值传递给被调用函数时，调用函数中结构体的值不会被修改。

您可以创建另一个函数：

void modifyMe3(struct myStructure **p1)
{
    free(*p1);
    *p1 = malloc(sizeof(*p1));
    (*p1)->a = -3;
    (*p1)->b = -6;
}

像这样添加调用代码：

printf("Before 3: address = %p, a = %d, b = %d\n", (void *)test1, test1->a, test1->b);

modifyMe0(*test1);

printf("After  3: address = %p, a = %d, b = %d\n", (void *)test1, test1->a, test1->b);

请注意，结构的地址在调用后发生了变化modifyMe3()。

c - 对函数调用中的单指针和双指针参数感到困惑

3 回答 3

Related

Reference