将数组通过值传递到函数

Question

以下是本书 c编程的片段。这不是错误的，因为数组永远无法按价值传递？

viii.6：如何通过值将数组传递给函数？

答案：一个数组可以通过在 称为函数数组名称 使用方括号（<代码> [和]） 附在末端。打电话时 功能，只需通过 阵列（即阵列的名称） 到所谓的函数。例如， 以下程序通过数组 x []到名称的功能 byval_func（）按值：

int []参数告诉 编译器byval_func（） 功能将有一个论点 - 一个 整数阵列。什么时候 byval_func（）函数，您 将阵列的地址传递到 byval_func（）：

  byval_func（x）;
 

因为数组正在传递 值，数组的确切副本为 制作并放在堆栈上。这 称为功能然后接收到此 阵列的副本可以打印。 因为阵列传递给 byval_func（）是 原始数组，修改数组 在byval_func（）函数中 对原始数组没有影响。

Answer 1

因为数组是按值传递的，所以将数组的精确副本放在堆栈上。

这是不正确的：数组本身没有被复制，只有指向其地址的指针的副本传递给Callee（放在堆栈上）。 （无论您是将参数声明为int []还是int*，它 衰减到指针 。）这使您可以从呼叫函数内部修改数组的内容。因此，这个

因为数组传递到byval_func（）是原始数组的副本，因此修改byval_func（）函数中的数组对原始数组没有影响。

是错误的（对@Jonathan Leffler的评论很荣幸）。但是，重新分配函数内部的指针不会将指针更改为函数之外的原始数组。

Answer 2

燃烧那本书。如果您想要一个没有初学者程序员编写的真实C FAQ，请使用此： http：http：http： //c-faq.com/aryptr/index.html 。

语法方面，严格地说您 在C中通过值传递数组，

void func (int* x); /* this is a pointer */

void func (int x[]); /* this is a pointer */

void func (int x[10]); /* this is a pointer */

但是 ，对于记录，C中有一个肮脏的技巧，它确实允许您通过数组根据C的价值。不要在家尝试！因为尽管有这个技巧，但仍然永远没有理由按值传递数组。

typedef struct
{
  int my_array[10];
} Array_by_val;

void func (Array_by_val x);

Answer 3

这不是错误的，因为数组永远无法按值传递？

确切地。您不能在C中按值来通过一个数组。

我看了书的引用部分，这种混乱或错误的来源很快找到。

作者不知道*i等于i []作为函数的参数时。后一种形式是为了明确说明代码的读者的发明，表明i指向一个数组，这是一个很好的混乱来源，也是这个问题的骗子。

我觉得很有趣的是，本书的特定部分或其他部分的作者（因为本书有 5 的作者）或 7 < /strong>校对者至少没有提及句子：

“ byval_func（）函数被调用，您将数组的地址传递到byval_func（）：< /em>“

至少这样，他们应该注意到存在冲突。
由于您通过地址，它只是一个地址。没有任何神奇的事情会将地址变成一个全新的数组。

---

但是回到问题本身：

您似乎无法通过C中的数组来通过C中的值，因为您似乎已经知道自己。但是您可以做三个（可能还有更多，但这是我的无罪状态），这可能是根据独特的情况的替代方法，所以让我们开始。

1. 将数组封装在结构中（如其他答案所述）：

#include <stdio.h>

struct a_s {
   int a[20];
};

void foo (struct a_s a)
{
   size_t length = sizeof a.a / sizeof *a.a;

   for(size_t i = 0; i < length; i++)
   {
       printf("%d\n",a.a[i]);
   }
}

int main()
{
   struct a_s array;

   size_t length = sizeof array.a / sizeof *array.a;

   for(size_t i = 0; i < length; i++)
   {
       array.a[i] = 15;
   } 

   foo(array);
}

2. 通过指针传递，但还添加了一个参数以确定数组的大小。在调用函数中，有一个带有该大小信息的新数组，并在呼叫者中的数组中分配了值：

#include <stdio.h>

void foo (int *array, size_t length)
{
   int b[length];

   for(size_t i = 0; i < length; i++)
   {
       b[i] = array[i];
       printf("%d\n",b[i]);
   }
}

int main()
{
   int a[10] = {0,1,2,3,4,5,6,7,8,9};

   foo(a,(sizeof a / sizeof *a));
}

3. 避免定义本地数组，只使用一个带有全局范围的数组：

#include <stdio.h>

int a[10];
size_t length = sizeof a / sizeof *a;

void foo (void)
{
   for(size_t i = 0; i < length; i++)
   {
       printf("%d\n",a[i]);
   }
}

int main()
{   
   for(size_t i = 0; i < length; i++)
   {
       a[i] = 25;
   } 

   foo();
}

Answer 4

在C和C ++中，不可能通过一个值将完整的内存块作为参数传递到一个函数，但是我们可以传递其地址。实际上，这几乎具有相同的效果，并且更快，更有效地操作。

为了安全起见，您可以将数组尺寸传递或在指针之前放置const预选赛，以确保Callee不会更改它。

Answer 5

Yo可以通过将阵列包裹到结构中来解决它

#include <stdint.h>
#include <stdio.h>

struct wrap
{
    int x[1000];
};

struct wrap foo(struct wrap x)
{
    struct wrap y;

    for(int index = 0; index < 1000; index ++)
        y.x[index] = x.x[index] * x.x[index];
    return y;
}

int main ()
{
    struct wrap y;

    for(int index = 0; index < 1000; index ++)
        y.x[index] = rand();
    y = foo(y);
    for(int index = 0; index < 1000; index ++)
    {
        printf("%d %s", y.x[index], !(index % 30) ? "\n" : "");
    }


}

Answer 6

#include<stdio.h>
void  fun(int a[],int n);
int main()
{
    int a[5]={1,2,3,4,5};
    fun(a,5);
}
void  fun(int a[],int n)
{
    int i;
    for(i=0;i<=n-1;i++)
        printf("value=%d\n",a[i]);
}

通过这种方法，我们可以按值将数组传递，但实际上该数组正在通过其实际复制在堆栈中的基本地址访问。