# define SIZE_OF_ARRAY(_array) (sizeof(_array) / sizeof(_array[0]))

**注意：**正如M.M在评论中指出的那样，这一点可能会给你带来未定义的行为。

int a[10];
int size = (*(&a+1)-a);

有关更多详细信息，请参见here和here。

对于预定义的数组：

int a[] = {1, 2, 3, 4, 5, 6};

计算数组中的元素数：

element _count = sizeof(a) / sizeof(a[0]);

要知道在代码中显式声明并由其变量引用的固定数组的大小，可以使用sizeof，例如：

int a[10];
int len = sizeof(a)/sizeof(int);

但这通常是没用的，因为你已经知道答案了。

但是，如果你有一个指针，你不能使用sizeof，这是一个原则问题。

但是……由于数组是以线性内存的形式提供给用户的，如果您知道最后一个元素的地址，并且知道类型的大小，那么您可以计算它的大小，然后您可以计算它有多少元素。例如：

# include <stdio.h>

int main(){
    int a[10];
    printf("%dn", sizeof(a)/sizeof(int));
    int *first = a;
    int *last = &(a[9]);
    printf("%dn", (last-first) + 1);
}

产出：

10
10

另外，如果您不能利用编译时间，您可以：

# include <stdio.h>

int main(){
    int a[10];
    printf("%dn", sizeof(a)/sizeof(int));
    void *first = a;
    void *last = &(a[9]);
    printf("%dn", (last-first)/sizeof(int) + 1);
}

除了已经提供的答案之外，我还想指出一个特殊情况，即使用

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

如果a是char、unsigned char或signed char的数组，则不需要使用两次sizeof，因为具有这些类型的一个操作数的sizeof表达式总是得到1。

引用C18，6.5.3.4/4：
“将sizeof应用于类型为char、unsigned char或signed char的操作数(或其限定版本)时，结果为1。”

因此，如果a是char、unsigned char或signed char类型的数组，则sizeof(a) / sizeof (a[0])等同于NUMBER OF ARRAY ELEMENTS / 1。1的除法是多余的。

在这种情况下，您可以简单地缩写并执行以下操作：

sizeof(a)

例如：

char a[10];
size_t length = sizeof(a);

如果你想要证据，这里有一个到Godbolt的链接。

尽管如此，如果类型发生重大变化(尽管这种情况很少发生)，该部门仍会保持安全。

“你引入了一种微妙的方式来打自己的脚。”

C‘原生’数组不存储它们的大小。因此，建议将数组的长度保存在单独的变量/const中，并在传递数组时传递它，即：

# define MY_ARRAY_LENGTH   15

int myArray[MY_ARRAY_LENGTH];

如果您正在编写C++，无论如何都应该始终避免本机数组(除非您做不到，在这种情况下，请注意脚下)。如果您正在编写C++，请使用STL的“VECTOR”容器。“与数组相比，它们提供了几乎相同的性能”，而且它们要有用得多！

// vector is a template, the <int> means it is a vector of ints
vector<int> numbers;  

// push_back() puts a new value at the end (or back) of the vector
for (int i = 0; i < 10; i++)
    numbers.push_back(i);

// Determine the size of the array
cout << numbers.size();

请参阅：http://www.cplusplus.com/reference/stl/vector/

最简单的答案是：

# include <stdio.h>

int main(void) {

    int a[] = {2,3,4,5,4,5,6,78,9,91,435,4,5,76,7,34}; // For example only
    int size;

    size = sizeof(a)/sizeof(a[0]); // Method

    printf("size = %d", size);
    return 0;
}

您可以使用&运算符。以下是源代码：

# include<stdio.h>

# include<stdlib.h>

int main(){

    int a[10];

    int *p; 

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

    return 0;
};

以下是样例输出

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

一个更优雅的解决方案将是

size_t size = sizeof(a) / sizeof(*a);

函数sizeof返回数组在内存中使用的字节数。如果要计算数组中的元素数，则应将该数除以数组的sizeof变量类型。假设int array[10];，如果您的计算机中的变量类型整数是32位(或4字节)，为了获得数组的大小，您应该执行以下操作：

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

最好的方法是将此信息保存在结构中，例如：

typedef struct {
     int *array;
     int elements;
} list_s;

执行所有必要的功能，如创建、销毁、检查相等性以及您需要的所有其他功能。它更容易作为参数传递。

如果您真的想这样做以传递数组，我建议实现一个结构来存储指向您想要的类型的指针、数组和表示数组大小的整数。然后，您可以将其传递给您的函数。只需将数组变量值(指向第一个元素的指针)赋给该指针。然后，您可以转到Array.arr[i]获取第i个元素，并使用Array.size获取数组中的元素数。

我为您添加了一些代码。它不是很有用，但你可以用更多的功能来扩展它。不过，老实说，如果这些都是您想要的，那么您应该停止使用C语言，而使用另一种内置了这些功能的语言。

/* Absolutely no one should use this...
   By the time you're done implementing it you'll wish you just passed around
   an array and size to your functions */
/* This is a static implementation. You can get a dynamic implementation and 
   cut out the array in main by using the stdlib memory allocation methods,
   but it will work much slower since it will store your array on the heap */

# include <stdio.h>

# include <string.h>

/*

# include "MyTypeArray.h"

* /

/* MyTypeArray.h 

# ifndef MYTYPE_ARRAY

# define MYTYPE_ARRAY

* /

typedef struct MyType
{
   int age;
   char name[20];
} MyType;
typedef struct MyTypeArray
{
   int size;
   MyType *arr;
} MyTypeArray;

MyType new_MyType(int age, char *name);
MyTypeArray newMyTypeArray(int size, MyType *first);
/*

# endif

End MyTypeArray.h */

/* MyTypeArray.c */
MyType new_MyType(int age, char *name)
{
   MyType d;
   d.age = age;
   strcpy(d.name, name);
   return d;
}

MyTypeArray new_MyTypeArray(int size, MyType *first)
{
   MyTypeArray d;
   d.size = size;
   d.arr = first;
   return d;
}
/* End MyTypeArray.c */

void print_MyType_names(MyTypeArray d)
{
   int i;
   for (i = 0; i < d.size; i++)
   {
      printf("Name: %s, Age: %dn", d.arr[i].name, d.arr[i].age);
   }
}

int main()
{
   /* First create an array on the stack to store our elements in.
      Note we could create an empty array with a size instead and
      set the elements later. */
   MyType arr[] = {new_MyType(10, "Sam"), new_MyType(3, "Baxter")};
   /* Now create a "MyTypeArray" which will use the array we just
      created internally. Really it will just store the value of the pointer
      "arr". Here we are manually setting the size. You can use the sizeof
      trick here instead if you're sure it will work with your compiler. */
   MyTypeArray array = new_MyTypeArray(2, arr);
   /* MyTypeArray array = new_MyTypeArray(sizeof(arr)/sizeof(arr[0]), arr); */
   print_MyType_names(array);
   return 0;
}

执行摘要：

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

完整答案：

要确定数组的字节大小，可以使用sizeof运算符：

int a[17];
size_t n = sizeof(a);

在我的计算机上，整数是4字节长，所以n是68。

要确定数组中的元素数，可以将数组的总大小除以数组元素的大小。您可以对类型执行此操作，如下所示：

int a[17];
size_t n = sizeof(a) / sizeof(int);

并得到正确的答案(68/4=17)，但是如果a的类型改变了，如果你也忘记了改变sizeof(int)，你就会有一个严重的错误。

因此，首选除数是sizeof(a[0])或等效的sizeof(*a)，即数组第一个元素的大小。

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

另一个优点是，您现在可以在宏中轻松地将数组名称参数化，并获得：

# define NELEMS(x)  (sizeof(x) / sizeof((x)[0]))

int a[17];
size_t n = NELEMS(a);

sizeof(array) / sizeof(array[0])

数组的大小，以C：

int a[10];
size_t size_of_array = sizeof(a);      // Size of array a
int n = sizeof (a) / sizeof (a[0]);    // Number of elements in array a
size_t size_of_element = sizeof(a[0]); // Size of each element in array a                                          
                                       // Size of each element = size of type