为什么不与MAIN中的数组参数的大小相同？

Question

为什么数组的大小不与MAIN中的参数相同？

#include <stdio.h>

void PrintSize(int p_someArray[10]);

int main () {
    int myArray[10];
    printf("%d\n", sizeof(myArray)); /* As expected, 40 */
    PrintSize(myArray);/* Prints 4, not 40 */
}

void PrintSize(int p_someArray[10]){
    printf("%d\n", sizeof(p_someArray));
}

Answer 1

您发现的行为实际上是C语言中的大疣。每当您声明采用数组参数的函数时，编译器都会忽略您，并将参数更改为指针。因此，这些声明的行为就像第一个：

void func(int *a)
void func(int a[])
void func(int a
typedef int array_plz[5];
void func(array_plz a)

A将是在所有四种情况下的指针。如果您将数组传递到Func，它将立即腐烂到指向其第一个元素的指针。 （在64位系统上，一个64位指针的大小是32位INT的两倍，因此您的大小比率返回2。）

该规则的唯一目的是与不支持的历史编译器保持向后兼容将聚合值作为函数参数传递。

这并不意味着不可能将数组传递给函数。您可以通过将数组嵌入结构（基本上是C ++ 11的STD ::数组的目的）来绕开此疣：

struct array_rly {
int a[5];
};
void func(struct array_rly a)
{
printf("%zd\n", sizeof(a.a)/sizeof(a.a[0]));  /* prints 5 */
}

或者通过将指针传递到数组：

void func(const int (*a)[5])
{
printf("%zd\n", sizeof(*a)/sizeof((*a)[0]));  /* prints 5 */
}

如果数组大小不是编译 -时间常数，您可以使用C99可变长度数组的指针到阵列技术：

void func(int n, const int (*a)[n])
{
printf("%zd\n", sizeof(*a)/sizeof((*a)[0]));  /* prints n */
}

Answer 2

因为阵列作为参数传递时将其腐烂成指针。这就是C起作用的方式，尽管您可以通过参考将C ++中的“数组”传递并克服此问题。请注意，您可以将不同尺寸的数组传递给此功能：

 // 10 is superfluous here! You can pass an array of different size!
void PrintSize(int p_someArray[10]);

Answer 3

在C ++中，您可以为此目的通过引用传递数组：

void foo(int (&array)[10])
{
    std::cout << sizeof(array) << "\n";
}

Answer 4

在C语言中，没有方法可以确定
数组的大小，因此数量需要
通过以及指向第一个元素的指针。

Answer 5

您不能将数组传递给函数。

如果您真的想打印大小，则可以将指针传递给数组，但是它根本不通用，因为您还需要定义该功能的数组尺寸。

#include <stdio.h>

void PrintSize(int (*p_anArray)[10]);

int main(void) {
    int myArray[10];
    printf("%d\n", sizeof(myArray)); /* as expected 40 */
    PrintSize(&myArray);/* prints 40 */
}

void PrintSize(int (*p_anArray)[10]){
    printf("%d\n", (int) sizeof(*p_anArray));
}

Answer 6

行为是设计。

功能参数声明中的同一语法是指与局部变量定义中完全不同的内容。

原因在其他答案中描述。

Answer 7

在C语言中，当您将数组作为参数传递给该函数时，它会自动转换为指针，从一个函数传递另一个函数的数组通过参考将其称为呼叫。这就是所谓函数仅接收指向函数的第一个元素的指针的原因，这就是

Fun（int a []）类似于娱乐（int *a）的原因;

因此，当您打印数组的大小时，它将打印第一个元素的大小。

Answer 8

在“ c”编程langlyange'sizeof（）'是运算符，他返回字节中的对象大小。“ sizeof（）”操作员的观点必须是左值类型（整数，浮点数，float号，struct，struct，array，array ）。因此，如果您想知道字节中的数组的大小，您可以非常简单。仅使用'sizeof（）'operator'，并且为他的参数使用阵列名称。例如：

#include <stdio.h>

main(){

 int n[10];
 printf("Size of n is: %d \n", sizeof(n)); 

}

32位系统上的输出将是：n的尺寸为：40。因为32系统上的Ineteger是4bytes.on 64x，是8bytes。在这种情况下，我们在一个数组中声明了10个整数。因此，结果是'10 * sizeof（int）'。

一些提示：

如果我们有一个像这样声明的数组，那就是'int n [] = {1，2，3，... 155 ..};'。
因此，我们想知道该数组中存储了多少个元素。
使用此alghorithm：

sizeof（name_of_the_array） / sizeof（array_type）

代码：#include

main（）{

int n[] = { 1, 2, 3, 44, 6, 7 };
printf("Number of elements: %d \n", sizeof(n) / sizeof(int));
return 0;

} { }

Answer 9

阵列仅大小。在大多数情况下，数组是通往内存的指针。声明中的大小仅告诉编译器为该数组分配多少内存 - 它与类型无关，因此SizeOf（）无需进行。

Answer 10

当您将其传递给函数时，数组类型是隐式转换为指针类型。

因此，

void PrintSize(int p_someArray[10]) {
    printf("%zu\n", sizeof(p_someArray));
}

是

void PrintSize(int *p_someArray) {
    printf("%zu\n", sizeof(p_someArray));
}

等效的。因此，您得到的是 sizeof（int*） 的值

Answer 11

这是一个指针，这就是为什么将数组的大小作为第二个参数传递给函数的常见实现

Answer 12

正如其他人所说的那样，当用作函数参数时，阵列会衰减指向其第一个元素。还值得注意的是，SizeOf不会评估表达式，并且与表达式一起使用时不需要括号，因此您的参数实际上根本没有使用，因此您不妨使用类型而不是值编写大小。

#include <stdio.h>

void PrintSize1 ( int someArray[][10] );
void PrintSize2 ( int someArray[10] );

int main ()
{
    int myArray[10];
    printf ( "%d\n", sizeof myArray ); /* as expected 40 */
    printf ( "%d\n", sizeof ( int[10] ) ); /* requires parens */
    PrintSize1 ( 0 ); /* prints 40, does not evaluate 0[0] */
    PrintSize2 ( 0 ); /* prints 40, someArray unused */
}

void PrintSize1 ( int someArray[][10] )
{
    printf ( "%d\n", sizeof someArray[0] );
}

void PrintSize2 ( int someArray[10] )
{
    printf ( "%d\n", sizeof ( int[10] ) );
}

Answer 13

因此，您需要将数组的Lenght作为第二个参数传递。当您编写代码时，您俩都声明了一个恒定大小的数组，然后将该数组传递给函数时，将数组长度常数显示在您的代码中的几个位置...

k＆amp; r 是很痛苦的。为了营救：

#define N_ELEMENTS(array) (sizeof(array)/sizeof((array)[0])) 

所以现在您可以做：

int a[10];
...
myfunction(a, N_ELEMENTS(a));