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

传递数组第一个成员的内存位置的值。

Therefore when you start modifying the array inside the function, you are modifying the original array.

记住 a[1]是 *(a+1)。

您没有将数组作为副本传递。它只是一个指向数组第一个元素在内存中的地址的指针。

将数组作为参数传递时，此

void arraytest(int a[])

意思完全相同

void arraytest(int *a)

所以您可以在 main 中修改 是中的值。

由于历史原因，数组不是一级公民，不能通过值传递。

您正在传递数组的第一个元素的地址

在 C 语言中，除了少数特殊情况外，数组引用总是“衰减”到指向数组第一个元素的指针。因此，不可能通过值传递数组。函数调用中的数组将作为指针传递给函数，这类似于通过引用传递数组。

编辑: 在三种特殊情况下，数组不会衰减为指向其第一个元素的指针:

1. sizeof a is not the same as sizeof (&a[0]).
2. &a与 &(&a[0])不同(与 &a[0]也不完全相同)。
3. char b[] = "foo"不同于 char b[] = &("foo")。

如果希望使用 传递一维数组作为函数中的参数，则必须使用以下三种方法之一声明形式参数，并且所有三种声明方法都会产生类似的结果，因为每个 tells the compiler that an integer pointer is going to be received。

int func(int arr[], ...){
.
.
.
}


int func(int arr[SIZE], ...){
.
.
.
}


int func(int* arr, ...){
.
.
.
}

因此，要修改原始值。

谢谢! ! ！

在大多数情况下，C 中的数组被转换为指向数组本身第一个元素的指针。更详细地说，传递给函数的数组总是被转换成指针。

以下是 K & R 第二大道的一段话:

当数组名传递给函数时，传递的是 初始元素的位置 参数是局部变量，因此数组名称参数是 指针，即包含地址的变量。

Writing:

void arraytest(int a[])

和写作有着相同的含义:

void arraytest(int *a)

因此，尽管您没有显式地编写它，但它是在传递指针的过程中进行的，因此您要修改 main 中的值。

对于更多我真的建议阅读 这个。

此外，您还可以在 SO给你上找到其他答案

将多维数组作为参数传递给函数。 将一个 dim 数组作为参数传递或多或少是琐碎的。 让我们来看一个更有趣的例子，传递一个2 dim 数组。 在 C 语言中，不能使用指针结构(int **)而不是2 dim 数组。 Let's make an example:

void assignZeros(int(*arr)[5], const int rows) {
for (int i = 0; i < rows; i++) {
for (int j = 0; j < 5; j++) {
*(*(arr + i) + j) = 0;
// or equivalent assignment
arr[i][j] = 0;
}
}

这里我指定了一个函数，它的第一个参数是一个指向5个整数数组的指针。 我可以把任何有5列的2 dim 数组作为参数传递:

int arr1[1][5]
int arr1[2][5]
...
int arr1[20][5]
...

您可能会想到定义一个更通用的函数，它可以接受任意2 dim 数组，并按如下方式更改函数签名:

void assignZeros(int ** arr, const int rows, const int cols) {
for (int i = 0; i < rows; i++) {
for (int j = 0; j < cols; j++) {
*(*(arr + i) + j) = 0;
}
}
}

这段代码可以编译，但是当您尝试以与第一个函数相同的方式分配值时，会得到一个运行时错误。 所以在 C 中，多维数组不同于指向指针的指针... 指向指针的指针。int(*arr)[5]是一个指向包含5个元素的数组的指针, int(*arr)[6]是指向6个元素的数组的指针，它们是指向不同类型的指针！

那么，如何定义高维函数参数呢? 很简单，我们只是按照模式！ 下面是同一个函数，它被调整为采用3维数组:

void assignZeros2(int(*arr)[4][5], const int dim1, const int dim2, const int dim3) {
for (int i = 0; i < dim1; i++) {
for (int j = 0; j < dim2; j++) {
for (int k = 0; k < dim3; k++) {
*(*(*(arr + i) + j) + k) = 0;
// or equivalent assignment
arr[i][j][k] = 0;
}
}
}
}

如您所料，它可以将第二维度中的4个元素和第三维度中的5个元素中的任意3个 dim 数组作为参数。任何类似的事情都是可以的:

arr[1][4][5]
arr[2][4][5]
...
arr[10][4][5]
...

但是我们必须指定所有尺寸大小直到第一个。

要传递2D (或更高的多维)数组，请参阅我的其他答案:

1. How to pass a multidimensional [C-style] array to a function in C and C++, and here:
2. 如何传递一个多维数组到一个函数在 C + + 只，通过 std::vector<std::vector<int>>&

在 C (和 C + +)中将1D 数组作为函数参数传递

1. C 语言中的标准数组使用，自然类型衰减(调整)从数组到 ptr

@ Bo Persson 在他的伟大回答中正确地指出:

将数组作为参数传递时，此

void arraytest(int a[])

means exactly the same as

void arraytest(int *a)

让我添加一些注释来增加这两个代码片段的清晰度:

// param is array of ints; the arg passed automatically "adjusts" (frequently said
// informally as "decays") from `int []` (array of ints) to `int *`
// (ptr to int)
void arraytest(int a[])


// ptr to int
void arraytest(int *a)

不过，我还要补充一点，上述两种形式也是:

1. 完全相同的意思

    // array of 0 ints; automatically adjusts (decays) from `int [0]`
   // (array of zero ints) to `int *` (ptr to int)
   void arraytest(int a[0])
   

2. 也就是说

    // array of 1 int; automatically adjusts (decays) from `int [1]`
   // (array of 1 int) to `int *` (ptr to int)
   void arraytest(int a[1])
   

3. which means exactly the same as

    // array of 2 ints; automatically adjusts (decays) from `int [2]`
   // (array of 2 ints) to `int *` (ptr to int)
   void arraytest(int a[2])
   

4. 也就是说

    // array of 1000 ints; automatically adjusts (decays) from `int [1000]`
   // (array of 1000 ints) to `int *` (ptr to int)
   void arraytest(int a[1000])
   

5. 等等。

在上面的每一个数组例子中，如下面代码中的例子调用所示，输入参数类型调整(衰减)为 int * ，可以在没有警告和错误的情况下调用，即使启用构建选项 -Wall -Wextra -Werror(参见 这是我的回购了解这3个构建选项的详细信息) ，如下所示:

int array1[2];
int * array2 = array1;


// works fine because `array1` automatically decays from an array type
// to a pointer type: `int *`
arraytest(array1);
// works fine because `array2` is already an `int *`
arraytest(array2);

事实上，这里的数组参数中的“ size”值([0]、 [1]、 [2]、 [1000]等等)显然只是为了美观/自我文档化的目的，并且可以是任何你想要的正整数(我认为是 size_t类型) ！

然而，在实践中，您应该使用它来指定您希望函数接收的数组的最小大小，以便在编写代码时可以轻松地跟踪和验证。MISRA-C-2012标准(点击此处购买/下载236-pg 2012-15.00版本的标准 PDF)甚至声明(重点补充) :

// `a` is of type `int (*)[2]`, which means "pointer to array of 2 ints";
// since it is already a ptr, it can NOT automatically decay further
// to any other type of ptr
void arraytest(int (*a)[2])
{
// my function here
}

int array1[2];


// ok, since the type of `array1` is `int (*)[2]` (ptr to array of
// 2 ints)
arraytest(&array1); // you must use the & operator here to prevent
// `array1` from otherwise automatically decaying
// into `int *`, which is the WRONG input type here!

int array1[2];


// WARNING! Wrong type since the type of `array1` decays to `int *`:
//      main.c:32:15: warning: passing argument 1 of ‘arraytest’ from
//      incompatible pointer type [-Wincompatible-pointer-types]
//      main.c:22:6: note: expected ‘int (*)[2]’ but argument is of type ‘int *’
arraytest(array1); // (missing & operator)

int array[2]; // variable `array` is of type `int [2]`, or "array of 2 ints"


// `array_p` is a "type safe" ptr to array of size 2 of int; ie: its type
// is `int (*)[2]`, which can also be stated: "ptr to array of 2 ints"
int (*array_p)[2] = &array;