如果你正在处理没有作为参数接收的数组，sizeof方式是正确的方式。作为参数发送给函数的数组被视为指针，因此sizeof将返回指针的大小，而不是数组的大小。

因此，在函数内部，此方法不起作用。相反，始终传递一个额外的参数size_t size，指示数组中元素的数量。

测试:

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

void printSizeOf(int intArray[]);
void printLength(int intArray[]);

int main(int argc, char* argv[])
{
    int array[] = { 0, 1, 2, 3, 4, 5, 6 };

    printf("sizeof of array: %d\n", (int) sizeof(array));
    printSizeOf(array);

    printf("Length of array: %d\n", (int)( sizeof(array) / sizeof(array[0]) ));
    printLength(array);
}

void printSizeOf(int intArray[])
{
    printf("sizeof of parameter: %d\n", (int) sizeof(intArray));
}

void printLength(int intArray[])
{
    printf("Length of parameter: %d\n", (int)( sizeof(intArray) / sizeof(intArray[0]) ));
}

输出(64位Linux操作系统):

sizeof of array: 28
sizeof of parameter: 8
Length of array: 7
Length of parameter: 2

输出(32位windows操作系统):

sizeof of array: 28
sizeof of parameter: 4
Length of array: 7
Length of parameter: 1

对于多维数组，它稍微复杂一些。通常人们定义显式宏常量，即。

#define g_rgDialogRows   2
#define g_rgDialogCols   7

static char const* g_rgDialog[g_rgDialogRows][g_rgDialogCols] =
{
    { " ",  " ",    " ",    " 494", " 210", " Generic Sample Dialog", " " },
    { " 1", " 330", " 174", " 88",  " ",    " OK",        " " },
};

但是这些常量也可以在编译时用sizeof求值:

#define rows_of_array(name)       \
    (sizeof(name   ) / sizeof(name[0][0]) / columns_of_array(name))
#define columns_of_array(name)    \
    (sizeof(name[0]) / sizeof(name[0][0]))

static char* g_rgDialog[][7] = { /* ... */ };

assert(   rows_of_array(g_rgDialog) == 2);
assert(columns_of_array(g_rgDialog) == 7);

注意，这段代码可以在C和c++中运行。对于二维以上的数组，请使用

sizeof(name[0][0][0])
sizeof(name[0][0][0][0])

等等，无限。

大小的“技巧”是我所知道的最好的方法，在括号的使用上有一个小而重要的变化(对我来说，这是一个主要的烦恼)。

正如维基百科的条目所表明的那样，C语言的sizeof不是一个函数;它是一个算子。因此，除非实参是类型名，否则不需要在实参周围加上圆括号。这很容易记住，因为它使实参看起来像一个强制转换表达式，它也使用括号。

所以:如果你有以下情况:

int myArray[10];

你可以用这样的代码找到元素的数量:

size_t n = sizeof myArray / sizeof *myArray;

对我来说，这比用括号代替要容易得多。我还赞成在除法的右边部分使用星号，因为它比索引更简洁。

当然，这也都是编译时的，所以没有必要担心除法会影响程序的性能。所以尽可能使用这个形式。

当你有一个实际对象时，使用sizeof总是最好的，而不是在一个类型上，因为这样你就不需要担心犯错误并声明错误的类型。

例如，假设您有一个函数，它将一些数据输出为字节流，例如跨网络输出。让我们调用send()函数，并将一个指向要发送的对象的指针和该对象中的字节数作为参数。所以，原型变成:

void send(const void *object, size_t size);

然后你需要发送一个整数，所以你像这样编码:

int foo = 4711;
send(&foo, sizeof (int));

现在，通过在两个地方指定foo类型，您引入了一种搬起石头砸自己的脚的微妙方法。如果一个改变了，而另一个没有改变，代码就会崩溃。因此，总是这样做:

send(&foo, sizeof foo);

现在你被保护了。当然，你复制了变量的名称，但如果你改变了它，编译器很可能会检测到这种破坏。

你可以使用&操作符。以下是源代码:

#include<stdio.h>
#include<stdlib.h>
int main(){

    int a[10];

    int *p; 

    printf("%p\n", (void *)a); 
    printf("%p\n", (void *)(&a+1));
    printf("---- diff----\n");
    printf("%zu\n", sizeof(a[0]));
    printf("The size of array a is %zu\n", ((char *)(&a+1)-(char *)a)/(sizeof(a[0])));


    return 0;
};

下面是示例输出

1549216672
1549216712
---- diff----
4
The size of array a is 10

sizeof函数返回数组在内存中使用的字节数。如果你想计算数组中的元素数量，你应该用数组的sizeof变量类型除以这个数字。让我们说int array[10];，如果变量类型integer在你的计算机是32位(或4字节)，为了得到你的数组的大小，你应该做以下工作:

int array[10];
size_t sizeOfArray = sizeof(array)/sizeof(int);

值得注意的是，sizeof在处理已经衰减为指针的数组值时没有帮助:即使它指向数组的开始，对编译器来说，它与指向该数组中单个元素的指针相同。指针不会“记住”用于初始化它的数组的任何其他内容。

int a[10];
int* p = a;

assert(sizeof(a) / sizeof(a[0]) == 10);
assert(sizeof(p) == sizeof(int*));
assert(sizeof(*p) == sizeof(int));