为什么数组参数的大小不同于 main？

当您将数组类型传递给函数时，数组类型被 毫无疑问转换为指针类型。

那么,

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*)的值

Arrays are only loosely sized. For the most part, an array is a pointer to memory. The size in your declaration only tells the compiler how much memory to allocate for the array - it's not associated with the type, so sizeof() has nothing to go on.

因为数组作为参数传递时会衰减为指针。这就是 C 的工作方式，尽管您可以通过引用在 C + + 中传递“数组”并克服这个问题。注意，您可以将不同大小的数组传递给这个函数:

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

In the C language, there is no method to determine the 未知数组的大小，因此数量需要 以及指向第一个元素的指针。

这种行为是有计划的。

函数参数声明中的语法与局部变量定义中的语法完全不同。

原因在其他答案中有描述。

You can't pass arrays to functions.

如果您真的想要打印大小，您可以传递一个指向数组的指针，但它不会是泛型的，因为您还需要为函数定义数组大小。

#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));
}

正如其他人所说，当数组用作函数参数时，它们会衰减为指向第一个元素的指针。另外值得注意的是，sizeof 不计算表达式，在与表达式一起使用时不需要括号，因此实际上根本没有使用参数，所以您可以使用类型而不是值来编写 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] ) );
}

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

因此，您需要将数组的长度作为第二个参数传递。在编写代码时，您需要声明一个常量大小的数组，然后将该数组传递给一个函数，因此，让数组长度常量在代码中显示多个位置是一件痛苦的事情... ..。

K & R 拯救了我们:

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

所以现在你可以做例如:

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

在 c + + 中，你可以通过引用来传递数组:

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

您发现的行为实际上是 C 语言中的一个大缺陷。每当您声明一个带有数组参数的函数时，编译器都会忽略您，并将该参数更改为指针。因此，这些声明都表现得像第一个声明:

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

A 在所有四种情况下都是指向 int 的指针。如果将数组传递给 func，它将立即衰减为指向其第一个元素的指针。(在64位系统中，64位指针的大小是32位 int 的两倍，因此大小比值返回2。)

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

This does not mean that it’s impossible to pass an array to a function. You can get around this wart by embedding the array into a struct (this is basically the purpose of C++11’s std::array):

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

or by passing a pointer to the array:

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 */
}

在 C 语言中，当你将数组作为参数传递给函数时，它会自动转换为指针，数组从一个函数传递，另一个函数被称为引用调用。这就是被调用函数只接收指向函数第一个元素的指针的原因

Fun (int a [])类似于 fun (int * a) ;

所以当你打印数组的大小时，它会打印第一个元素的大小。

在‘ C’编程语言中，‘ sizeof ()’是操作符，它返回对象的大小(以字节为单位)。‘ sizeof ()’运算符的参数必须是左值类型(整数、浮点数、结构、数组)。所以如果你想知道一个数组的字节大小，你可以做得很简单。只需使用‘ sizeof ()’操作符，对于他的参数使用数组名称。例如:

#include <stdio.h>


main(){


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


}

在32位系统上的输出将是: n 的大小是: 40。因为32系统上的 neteger 是4字节。在64x 上是8字节。在这个例子中，我们在一个数组中声明了10个整数，所以结果是’10 * sizeof (int)’。

一些小贴士:

如果我们有一个像这样声明的数组‘ int n [] = {1,2,3，... 155. . } ;’。 所以我们想知道这个数组中存储了多少元素。 使用这个算法:

Sizeof (name _ of _ the _ array)/sizeof (array _ type)

代码: # include

主(){

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

}