将指针数组作为参数传递给C中的函数

我已经写了一段代码，但我不确定它是如何工作的。 我想创建一个指针数组，并将其作为参数传递给函数，如下所示：

int main()
{

    int *array[10] = {0};

    for(int i = 0; i < 3; i++)
    {
        array[i] = (int *)malloc(3*sizeof(int *));
    }

    testFunction(array); 

    for(int i = 0; i < 3; i++)
    {
        free(array[i]);
    }

    return 0;
}
void testFunction(int *array[3])
{
     //do something

    return;
}

intmain（）
{
int*数组[10]={0}；
对于（int i=0；i<3；i++）
{
数组[i]=（int*）malloc（3*sizeof（int*））；
}
测试函数（数组）；
对于（int i=0；i<3；i++）
{
自由（数组[i]）；
}
返回0；
}
void testFunction（int*数组[3]）
{
//做点什么
返回；
}

---

我不明白的是以下几点。我将

array

声明为指针数组，使用

malloc

为其分配内存，然后继续调用

testFunction

。我想通过引用传递数组，我知道当我使用

testFunction（array）

调用函数时，数组会衰减为指向其第一个元素的指针（也将是指针）。但是为什么在参数列表中我必须用

*

写

（int*array[3]）

，而不仅仅是

（int-array[3]）

？

一切取决于

//在你的情况下做些什么

让我们从简单开始：也许，您只需要整数数组

如果函数只更改数组中的值，但不更改大小，则可以将其作为
int*array
或
int array[3]
传递

int*array[3]
仅允许使用大小为
3
的数组，但如果可以使用任何
int
数组，则选项
int*array
需要附加参数
int size
：

void testFunction（int*array，int arr\u size）
{
int i；
对于（i=0；i

下一步：如果需要指针数组

参数应该是
int*array[3]
或更好的
int**array
（指针指向指针）

查看初始化循环（我将
sizeof（int*）
更改为
sizeof（int）
）

最后：2D阵列的内存分配

考虑一下
main的以下变体：

intmain（）
{
整数**数组；
//为3个指针分配内存*
数组=（int*）malloc（3*sizeof（int*）；
if（数组==NULL）
返回1；//停止程序
//然后用addreses为3 int初始化这3个指针
对于（int i=0；i<3；i++）
{
数组[i]=（int*）malloc（3*sizeof（int））；
if（array[i]==NULL）返回1；
}
testFunction（数组，3，3）；
//首先，为int分配空闲内存
对于（int i=0；i<3；i++）
{
自由（数组[i]）；
}
//然后为指针分配空闲内存
自由（数组）；
返回0；
}

请注意，
malloc
返回的值应该在使用前检查（NULL表示未分配内存）

出于同样的原因，可以在函数中添加检查：

void testFunction（int**array，int wSize，int hSize）
{
int row，col；
if（array==NULL）//检查这里
返回；
for（行=0；行
类型为*
的参数可以接受类型为[]

的参数，但不能接受类型为的任何参数

如果您编写

void testFunction（int arg[3]）

就可以了，但是您将无法访问

array[1]

和

array[2]

等等，只有where

array[0]

的前3个元素指向。还需要一个comversion（使用

testFunction（（int*）数组调用）；

作为一种良好的实践，有必要使函数参数与作为参数传递的参数保持一致。因此

int*array[10]

可以传递给

f（int**arg）

或

f（int*arg[]）

，但既不能传递给

f（int*arg）

也不能传递给

f（int-arg）

无效测试函数（int**array、int int\u arr\u size、int size\u数组的int size\u指针的int size\u）
{
for（int j=0；j<数组的大小\u\u\u指针的大小；j++）
{
int*arrptr=array[j]；//这个指针只是为了理解这个想法。
对于（int i=0；i

及

intmain（）
{    
int*数组[10]；
对于（int i=0；i

array[i]=（int*）malloc（3*sizeof（int*）

应该是

array[i]=malloc（3*sizeof*array[i]）

至于你的问题，你传递了一个指向

int

（类型为

int*[10]

）的指针数组。你为什么认为

int数组[]

（表示

int

的数组）是否可用作参数？需要“指针类型”作为testFunction的参数，因为将“数组地址”分配给testFunction。数组==&数组[0]==第一个数组的地址。C不支持按引用传递。它严格按值传递。“数组衰减为指向其第一个元素的指针”正确。由于第一个元素是指向

int

的指针，数组会衰减到指向

int

的指针的地址，这是指向

int

的指针。

int[3]

如果要传入

int*[3]

，是否作为参数类型工作？@templatetypedef当然是

int[3]

和

int*[3]

是不同的情况，但我从简单的情况解释到更复杂的情况，“可以在函数中添加检查”是半个解决方案。检查

数组
和每个
数组[行]
，或者
for(int i = 0; i < 3; i++)
{
    array[i] = (int *)malloc(3*sizeof(int));
}

void testFunction(int **array, int int_arr_size, int size_of_array_of_pointers) 
{
    for(int j = 0; j < size_of_array_of_pointers; j++)
    {
         int *arrptr = array[j];   // this pointer only to understand the idea. 
         for(int i = 0; i < int_arr_size; i++)
         {
             arrptr[i] = i + 1;
         }
    }
}

int main()
{    

    int *array[10];

    for(int i = 0; i < sizeof(array) / sizeof(int *); i++)
    {
        array[i] = malloc(3*sizeof(int));
    }

    testFunction(array, 3, sizeof(array) / sizeof(int *)); 

    for(int i = 0; i < sizeof(array) / sizeof(int *); i++)
    {
        free(array[i]);
    }

    return 0;
}