c-当我们将动态数组作为参数传递给函数时，为什么要使用双指针

Question

我对编程相对陌生，我正在尝试用指针理解一些概念。我大部分时间都得到了它，我正在查看普通内存分配，我知道我需要创建一个指针，malloc函数将返回分配空间的第一个地址，我们将其放入创建的指针中。这很有道理，因为这使得常向量和正则向量一样，对吧？因为静态向量也有向量的名称——指向第一个元素的指针。但是，为什么当我试图用realloc改变函数中向量的大小时，我明白我需要使用双指针作为参数。类似这样的东西：

void function(int **vector){
*vector=(*int)realloc(*vector, sizeof(int)*n);
}

有人能解释一下吗，谢谢！

Answer 1

当调用声明为void function(int *vector)的函数时，它只传递int *的值——只是指向向量(数组(第一个元素的指针。如果使用function(MyVector)调用此函数，则在函数内部，vector仅指传递的值的副本。它不引用MyVector，更改vector不会更改MyVector。

当一个声明为void function(int **vector)的函数被调用时，它会被传递一个int **的值——一个指向向量第一个元素的指针的指针。如果使用function(&MyVector)调用此函数，则在函数内部，vector指指向指针的指针副本。然而，由于它是指向指针的指针，因此*vector引用指向数组的第一个元素的指针。也就是说，*vector不仅仅是指针的副本，它还是实际的指针，即调用方中的MyVector。

因此，在第一个函数中，vector = realloc(…);不会改变调用方中的MyVector。在第二个函数中，*vector = realloc(…);确实更改了调用者中的MyVector。

Answer 2

如果您有这样的函数

void f( T item );

其中T是某种类型说明符，并像一样调用它

T object;
f( object );

然后该函数获取其参数的副本。你可以通过以下方式来想象

T object;
f( object );
//....
void f( /* T item */ )
{
T item = object;
// ...
}

因此，函数中副本的更改不会影响作为参数传递给函数的原始对象。

要更改原始对象，必须通过引用传递它。例如

void f( T *item )
{
*item = new_value;
//...
}
//...
T object;
f( &object );

如果您有一个类型为int的对象要在函数中更改，那么只需将类型说明符T替换为类型int，您就会得到。

void f( int *item )
{
*item = new_value;
//...
}
//...
int object;
f( &object );

如果对象的类型为int *，则用T代替int *，您将获得

void f( int **item )
{
*item = new_value;
//...
}
//...
int *object;
f( &object );

这是一个示范节目。

#include <stdio.h>
#include <stdlib.h>
void f( int *x )
{
*x = 20;
}
void g( int **p )
{
*p = malloc( sizeof( int ) );
**p = 30;
}
int main(void) 
{
int x = 10;
printf( "x = %dn", x );
f( &x );
printf( "x = %dn", x );
int *px = &x;
printf( "*px = %dn", *px );
g( &px );
printf( "*px = %dn", *px );
free( px );
return 0;
}

其输出为

x = 10
x = 20
*px = 20
*px = 30