C语言中作为参数的指针

假设a有一个指针作为参数，为什么它的值在函数的and之后不保持修改状态，我必须使用以下语法：

void function_name (int **p)
{
// code
}

总的来说（）：

---

我想指定使用指向结构类型的指针作为参数。

C按值传递参数。如果要修改函数中的某些内容并使修改在调用函数中生效，则必须传递指向调用函数中变量的指针。否则，对函数中变量所做的任何更改都只是局部更改，不会影响调用函数中变量的值

让我们从一个

int

类型变量开始

void foo(int x)
{
   x = 10;
}

int main()
{
   int a = 100;
   foo(a);  // Value of a does not change in this function
}

在上述程序中，

a

的值保留在

main

中的

100

。线路

x = 10;

在

foo

中，仅影响

foo

中变量的值。要使

foo

中的更改影响

main

中的值，需要将指针传递到

a

void foo(int* x)
{
   *x = 10;
}

int main()
{
   int a = 100;
   foo(&a);  // Value of a changes in this function
}

把这个比喻比作一个指针

void bar(int* x)
{
   x = malloc(10*sizeof(int));
}

int main()
{
   int* ptr = NULL;
   bar(ptr);  // Value of ptr does not change in this function
}

bar

为

10

int

s数组分配内存，并将内存分配给

x

，但该更改是本地的

main

未看到它。在

main

中，

ptr

仍然是

NULL

。要使

bar

中的更改影响

ptr

，必须将指向

ptr

的指针传递到

bar

void bar(int** x)
{
   *x = malloc(10*sizeof(int));
}

int main()
{
   int* ptr = NULL;
   bar(&ptr);  // Value of ptr changes in this function
}

---

C按值传递参数。如果要修改函数中的某些内容并使修改在调用函数中生效，则必须传递指向调用函数中变量的指针。否则，对函数中变量所做的任何更改都只是局部更改，不会影响调用函数中变量的值

让我们从一个

int

类型变量开始

void foo(int x)
{
   x = 10;
}

int main()
{
   int a = 100;
   foo(a);  // Value of a does not change in this function
}

在上述程序中，

a

的值保留在

main

中的

100

。线路

x = 10;

在

foo

中，仅影响

foo

中变量的值。要使

foo

中的更改影响

main

中的值，需要将指针传递到

a

void foo(int* x)
{
   *x = 10;
}

int main()
{
   int a = 100;
   foo(&a);  // Value of a changes in this function
}

把这个比喻比作一个指针

void bar(int* x)
{
   x = malloc(10*sizeof(int));
}

int main()
{
   int* ptr = NULL;
   bar(ptr);  // Value of ptr does not change in this function
}

bar

为

10

int

s数组分配内存，并将内存分配给

x

，但该更改是本地的

main

未看到它。在

main

中，

ptr

仍然是

NULL

。要使

bar

中的更改影响

ptr

，必须将指向

ptr

的指针传递到

bar

void bar(int** x)
{
   *x = malloc(10*sizeof(int));
}

int main()
{
   int* ptr = NULL;
   bar(&ptr);  // Value of ptr changes in this function
}

---

在C语言中，参数是按值传递的。这意味着，当您将参数传递给函数时，将生成该变量的副本。比如说

int main()
{
    int x = 6;
    repchar(x, 'r');

    printf("%d\n", x);
    return 0;
}
void repchar(int n, char c)
{
    while (--n >= 0)
        putchar(c);
}

该程序将字母r打印六次，然后在最后一次打印时打印出6，而不是-1。原因是调用

repchar

时，

x

被复制。这样，当

repchar

递减

n

时，调用方的副本不会更改

但是，如果我们传递一个指针，

n

将被修改

int main()
{
    int x = 6;
    repchar(&x, 'r');

    printf("%d\n", x);
    return 0;
}
void repchar(int *n, char c)
{
    while (--(*n) >= 0)
        putchar(c);
}

---

现在复制的不是变量，而是变量的地址。在repchar内部，

*n

正在倒计时。这将访问

n

引用的值，该值与

x

的地址相同，并将其递减。结果，最后一个printf将给出-1。

在C中，参数是按值传递的。这意味着，当您将参数传递给函数时，将生成该变量的副本。比如说

int main()
{
    int x = 6;
    repchar(x, 'r');

    printf("%d\n", x);
    return 0;
}
void repchar(int n, char c)
{
    while (--n >= 0)
        putchar(c);
}

该程序将字母r打印六次，然后在最后一次打印时打印出6，而不是-1。原因是调用

repchar

时，

x

被复制。这样，当

repchar

递减

n

时，调用方的副本不会更改

但是，如果我们传递一个指针，

n

将被修改

int main()
{
    int x = 6;
    repchar(&x, 'r');

    printf("%d\n", x);
    return 0;
}
void repchar(int *n, char c)
{
    while (--(*n) >= 0)
        putchar(c);
}

---

现在复制的不是变量，而是变量的地址。在repchar内部，

*n

正在倒计时。这将访问

n

引用的值，该值与

x

的地址相同，并将其递减。因此，最后一个printf将给出-1。

您可能希望共享

//code

中的内容。类似于。C是“按值传递”，因此传递给函数的任何参数都会复制其值。但是，即使复制了指针地址的值，它仍然指向内存中的同一区域，这意味着无论它是指针的哪一个副本，对指针对象所做的更改仍将传递给指向同一对象的任何人。也就是说，我们需要看看你在

//code

中做了什么，才能知道发生了什么……你能给出一个更具体的代码片段吗？请注意，在C中，指针是通过值传递的，而不是通过引用传递的。这取决于您是向

p

还是

*p

。C11标准草案n1570:6.5.2.2函数调用4参数可以是任何完整对象类型的表达式。在准备调用函数时，将计算参数，并为每个参数指定相应参数的值。93）函数可以更改其参数的值，但这些更改不会影响参数的值。您可能希望共享

//code

中的内容。类似于。C是“按值传递”，因此传递给函数的任何参数都会复制其值。但是，即使复制了指针地址的值，它仍然指向内存中的同一区域，这意味着无论它是指针的哪一个副本，对指针对象所做的更改仍将传递给指向同一对象的任何人。也就是说，我们需要看看你在

//code

中做了什么，才能知道发生了什么……你能给出一个更具体的代码片段吗？注意，在C中，指针是通过值传递的，而不是通过引用传递的。这取决于您是否编写了