Question

通常，当我们按名称传递数组时，按地址调用。这意味着如果我们更改main()之外的任何数组值，它将反映在main()中。

那么，如果我想将数组作为函数的参数传递并在main()内调用它，那么该函数的任何更改都不会反映在{{1 }}？

例如：

main()

现在我想通过值将void Foo(int arr[]) //takes an integer array `arr` as argument { // do something with `arr } int main() { int abc[]={5,1,2,9}; //do something to pass `abc` inside `Foo` so that changes inside `Foo` doesn't change the value of `abc` array. }数组传递给abc。

Answer 1

可以通过将数组包装在struct中来实现。您可以包含一个字段大小的字段，这样您就不需要显式传递此参数。这种方法的优点是避免了以后必须释放的额外内存分配。

C已经通过值将参数传递给函数，但是数组标识符在大多数表达式中衰减为指针，特别是在函数调用中。然而struct不会衰减到指针，而是通过值传递给函数，这意味着原始结构的副本及其所有内容在函数范围内是可见的。如果struct包含数组，则也会复制该数组。请注意，如果struct包含一个指向动态数组的int的指针，那么当struct传递给函数时会复制指针，但同样的内存是由副本和原始指针引用。这种方法依赖于包含实际数组的struct。

另请注意，struct不能包含类型不完整的成员，因此不能包含VLA。在这里，我将全局常量MAX_ARR定义为100，以便为处理具有相同struct类型的不同大小的数组提供一些空间。

您还可以从函数返回struct。我添加了一个示例，该示例修改了传递给函数的Array struct，并返回修改后的struct以分配给不同的Array struct在调用函数中。这导致调用者可以访问原始数组和转换后的数组。

#include <stdio.h>

#define MAX_ARR  100

struct Array {
    size_t size;
    int array[MAX_ARR];
};

void print_array(struct Array local_arr);
void func(struct Array local_arr);
struct Array triple(struct Array local_arr);

int main(void)
{
    struct Array data = {
        .size = 10,
        .array = { 1, 2, 3, 4, 5, 6, 7, 8, 9, 10 }
    };
    struct Array transformed_data;

    func(data);
    transformed_data = triple(data);

    printf("Original\n");
    print_array(data);

    printf("Transformed\n");
    print_array(transformed_data);

    return 0;
}

void print_array(struct Array local_arr)
{
    for (size_t i = 0; i < local_arr.size; i++) {
        printf("%5d", local_arr.array[i]);
    }
    putchar('\n');
}

void func(struct Array local_arr)
{
    for (size_t i = 0; i < local_arr.size; i++) {
        local_arr.array[i] *= 2;
    }
    printf("Modified\n");
    print_array(local_arr);
}

struct Array triple(struct Array local_arr)
{
    for (size_t i = 0; i < local_arr.size; i++) {
        local_arr.array[i] *= 3;
    }
    return local_arr;
}

节目输出：

Modified
    2    4    6    8   10   12   14   16   18   20
Original
    1    2    3    4    5    6    7    8    9   10
Transformed
    3    6    9   12   15   18   21   24   27   30

Answer 2

一般来说，你不能。

来电者可以这样做;

int main()
{
    int abc[]={5,1,2,9};

    {
         int temp[sizeof (abc)/sizeof (*abc)];
         memcpy(temp, abc, sizeof(abc));
         Foo(temp);
    }
}

请记住Foo()没有收到有关传递的数组中元素数量的任何信息。

如果你希望Foo()做类似的事情，那么调用者并不需要，有必要将元素的数量作为一个单独的参数传递。

void Foo(int arr[], size_t size)    /*  C99 or later */
{
       int temp[size];   //   VLA
       memcpy(temp, arr, size*sizeof(int));
         /* whatever */
}

或（在C99之前）。

void Foo(int arr[], size_t size)    /*  Before C99 */
{
       int *temp = malloc(size * sizeof (int));
       memcpy(temp, arr, size*sizeof(int));
         /* whatever */
       free(temp);
}

为了避免内存泄漏，在第二种情况下，有必要确保在调用free(temp)之前函数没有返回。

在上述Foo()的两个版本中，可能需要进行额外的错误检查（例如，检测空指针或传递的零大小，malloc()成功等等。）

Answer 3

（我不确定Ryan为什么不自愿提供自己的答案，但我同意以下内容应该有效：）

#include <stdlib.h> // In header
#include <string.h>

int Foo(size_t size, int arr[])
{
   // guard against bad arguments
   if (arr == NULL || size <= 0)
   {
       return -1;
   }

   // create local array, since size is variable, allocate dynamically
   int* arr_2 = NULL;
   if ((arr_2 = malloc(n * sizeof(*arr_2)) == NULL)
   {
       return -1; // malloc allocation error
   }
   // otherwise if the size is constant:
   // int arr_2[SOME_CONSTANT_SIZE];

   // copy from arr to arr_2
   memcpy(arr_2, arr, n * sizeof(*arr_2));

   // some computation

   free(arr_2);

   return 0;
}

请注意，一旦我们离开arr_2的范围，Foo将不再存在。此外，对于非原始数组元素，您需要进行更多的复制工作。

按值传递数组

3 个答案: