在函数调用中被单指针和双指针参数混淆

>按价值计算.然后将其复制到堆栈.因此函数在函数框架中具有变量的局部副本.对参数的任何更改都不会更改传递的值.它就像“只读”模式

void fooByValue(myStructure_t arg) {
    printf("passed by value %d %dn",arg.a,arg.b);
    arg.a = 0;
}

>通过指针.然后传递此变量的地址副本(所以是的,它仍然按值传递,但是传递地址的值,而不是整个参数的值).所以这就像“读写”模式.由于可以通过其地址访问传递的变量,因此可以在函数外部更改此变量的值.

void fooByPtr(myStructure_t *arg) {
    printf("passed by pointer %d %dn",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 %pn",arg);
    arg = (myStructure_t*) malloc(sizeof(myStructure_t));
    (arg)->a = 10;
    (arg)->b = 20;
    printf("addr inside foo after %pn",arg);
}

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

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

简短的结论：有一个简单的规则 – 如果需要更改参数,则将指针传递给它.所以,如果想要改变指针,则将指针传递给指针.如果想要更改双指针,则将指针传递给指针指针.
>通过指针传递参数也要快得多,因为您不需要复制堆栈上的所有值(当然,如果值大于指向此值的指针,否则通过指针传递给只读是没有意义的).但它很危险,因为它可以在功能内部进行修改.因此,您可以使用const关键字来保护定义它的参数

void constFoo(const myStructure_t *arg) {
    arg->a = 10;    //compilation error
    arg->b = 20;    //compilation error
}

当您使用第三方库时,这非常有用：函数签名告诉您函数是否可以修改您的参数.虽然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);
}

在这种情况下,一个元素的数组和指向元素的指针行为相似(但它们不相同).