c中的sizeof（a）/sizeof（a[0]）如何以及为什么用于计算数组中的元素数

我是编程新手，我不知道sizeof（a）和sizeof（a[0]）计算数组中元素数量的确切含义。 为什么以及在何处使用此功能？

---

划分它们的目的是什么。

sizeof

返回变量的大小（以字节为单位）。因此，

sizeof（a）

其中a是数组，将返回数组的大小，即数组中的元素数乘以一个元素的大小

sizeof（a[0]）

将给出数组中一个元素的大小（我们只选择了第一个）

---

so-

sizeof（a）/sizeof（a[0]）

=数组长度*数组中一个元素的大小/数组中一个元素的大小=数组长度。

根据C标准（6.5.3.4运算符的大小和对齐）

2sizeof运算符产生其操作数的大小（字节），它 可以是表达式或类型的括号名称。尺寸是 根据操作数的类型确定。结果是一个整数。如果 操作数的类型是可变长度数组类型，即操作数 进行评估；否则，将不计算操作数并返回结果 是一个整数常量

例如，如果你有一个数组

int a[N];

int a[] = { 0, 1, 2, 3, 4, 5, 6, 7, 8, 9 };
const size_t N = sizeof( a ) / sizeof( *a );

void f( int a[10] );

void f( int *a, size_t n );

其中N是某个整数值，然后是表达式

sizeof( a )

void f( int a[10] )
{
    size_t n = sizeof( a ) / sizeof( a[0] );
    //...
}

    size_t n = sizeof( a ) / sizeof( a[0] );

生成数组占用的字节数。由于数组有

N个

元素，并且每个元素依次占用

sizeof（int）

字节

sizeof( a ) == N * sizeof( int )

或者什么是相同的

sizeof( a ) == N * sizeof( a[0] )

因此，您可以用以下方法计算N

N = sizeof( a ) / sizeof( a[0] )

例如，如果您不知道数组的确切大小，它会很有用，因为它的大小取决于初始值设定项的数量

比如说

int a[N];

int a[] = { 0, 1, 2, 3, 4, 5, 6, 7, 8, 9 };
const size_t N = sizeof( a ) / sizeof( *a );

void f( int a[10] );

void f( int *a, size_t n );

考虑到初学者有时会犯错误

假设有一个函数将数组声明为参数

比如说

int a[N];

int a[] = { 0, 1, 2, 3, 4, 5, 6, 7, 8, 9 };
const size_t N = sizeof( a ) / sizeof( *a );

void f( int a[10] );

void f( int *a, size_t n );

这个函数可以像这样调用

int a[10];

f( a );

初学者通常在函数体中写以下表达式

sizeof( a )

void f( int a[10] )
{
    size_t n = sizeof( a ) / sizeof( a[0] );
    //...
}

    size_t n = sizeof( a ) / sizeof( a[0] );

然而，这是一个错误的代码。问题是像数组一样声明的参数被调整为指向数组元素类型的指针。所以函数声明实际上看起来像

void f( int *a );

在表达式中的函数中

sizeof( a )

void f( int a[10] )
{
    size_t n = sizeof( a ) / sizeof( a[0] );
    //...
}

    size_t n = sizeof( a ) / sizeof( a[0] );

参数

a

是指针。就是相当于

    size_t n = sizeof( int * ) / sizeof( int );

根据使用的系统指针占用4或8字节。因此，如果

sizeof（int）

等于4，则得到2或1

您将无法获取用作参数的数组中的元素数

指针不保留关于它们是指向单个对象还是指向某个数组的第一个对象的信息

在这种情况下，应该使用第二个参数声明函数，该参数指定数组中的元素数。比如说

int a[N];

int a[] = { 0, 1, 2, 3, 4, 5, 6, 7, 8, 9 };
const size_t N = sizeof( a ) / sizeof( *a );

void f( int a[10] );

void f( int *a, size_t n );

sizeof（a）和sizeof（a[0]的含义）

sizeof（a）

是其操作数的大小（以字节为单位），在本例中是一个名为

a

的数组

sizeof（a[0]）

是其操作数的大小（以字节为单位），在本例中为数组的单个元素

。。。计算数组中的元素数

将数组的大小除以元素的大小

sizeof（a）/sizeof（a[0]）

为什么?

以便于代码维护。考虑使用

some_type a[N];
... code that visually separates the declaration and the below loop
for (i=0; i<N; i++) 
  foo(a[i])

某些类型的a[N]；
... 从视觉上分离声明和以下循环的代码
对于（i=0；i除了所说的，
sizeof（myarray）工作并返回类型乘以元素数这一事实，我认为这可能非常依赖于编译器。一些编译器允许您这样做，而其他编译器则不允许。
如果你不小心的话，这是C编程中的一个怪癖。
请尝试编译并运行此程序，以便自己查看

# include <stdio.h>
# include <stdlib.h>


void Z1 ( int *z )
{
   printf(" size of z1 = %d\n", sizeof( z ) );
}

void Z2 ( int z[] )
{
   printf(" size of z2 = %d\n", sizeof( z ) );
}

void Z3 ( int z[10] )
{
   printf(" size of z3    = %d\n", sizeof( z ) );
   printf(" size of z3[5] = %d\n", sizeof ( z[5] ) );
}

int main ( int argc, char *argv[] )
{
   char a1;
   short int a2;
   int a3;
   long int a4;
   float a5;
   double a6;

   int myarray[10];


   for ( a3 = 0; a3 < 10; a3++ )
   {
      myarray[a3] = a3;
   }

   printf("\n");
   printf(" size of char      = %d\n", sizeof( a1 ) );
   printf(" size of short int = %d\n", sizeof( a2 ) );
   printf(" size of int       = %d\n", sizeof( a3 ) );
   printf(" size of long int  = %d\n", sizeof( a4 ) );
   printf(" size of float     = %d\n", sizeof( a5 ) );
   printf(" size of double    = %d\n", sizeof( a6 ) );

   printf(" size of myarray      = %d\n", sizeof( myarray ) );
   printf(" size of myarray[5]   = %d\n", sizeof( myarray[5] ) );

   printf("\n");

   Z1( myarray );
   Z2( myarray );
   Z3( myarray );
}

需要明确的是，如果数组被定义为
inta[N]
，那么您已经知道元素的数量
N
。例如，这就是。使用它的原因是当您有
inta[]={1,2,3,4}；
并且元素的数量没有直接定义时。也不要在原始指针上使用它，即
int*a…sizeof（a）/sizeof（a[0]）
，它将为您提供与元素数量不同且无关的内容。