如何确定 C 中数组的大小？

您可以使用 sizeof 运算符，但它不适用于函数，因为它将获取指针的引用，您可以执行以下操作来查找数组的长度：

len = sizeof(arr)/sizeof(arr[0])

最初在这里找到的代码：C program to find the number of elements in an array

如果你知道数组的数据类型，你可以使用类似的东西：

int arr[] = {23, 12, 423, 43, 21, 43, 65, 76, 22};

int noofele = sizeof(arr)/sizeof(int);

或者如果你不知道数组的数据类型，你可以使用类似的东西：

noofele = sizeof(arr)/sizeof(arr[0]);

注意：只有在运行时未定义数组（如 malloc）并且数组未在函数中传递时，此操作才有效。在这两种情况下，arr（数组名）都是一个指针。

每个人都在使用的宏 ARRAYELEMENTCOUNT(x) 的计算结果不正确。实际上，这只是一个敏感问题，因为您不能拥有导致“数组”类型的表达式。

/* Compile as: CL /P "macro.c" */
# define ARRAYELEMENTCOUNT(x) (sizeof (x) / sizeof (x[0]))

ARRAYELEMENTCOUNT(p + 1);

实际上评估为：

(sizeof (p + 1) / sizeof (p + 1[0]));

然而

/* Compile as: CL /P "macro.c" */
# define ARRAYELEMENTCOUNT(x) (sizeof (x) / sizeof (x)[0])

ARRAYELEMENTCOUNT(p + 1);

它正确评估为：

(sizeof (p + 1) / sizeof (p + 1)[0]);

这实际上与数组的大小没有太大关系。我刚刚注意到很多错误，因为没有真正观察 C 预处理器是如何工作的。您总是包装宏参数，而不是可能涉及的表达式。

这是对的;我的例子很糟糕。但这实际上正是应该发生的事情。正如我之前提到的，p + 1 最终将成为指针类型并使整个宏无效（就像您尝试在带有指针参数的函数中使用宏一样）。

归根结底，在这种特殊情况下，错误并不重要（所以我只是在浪费大家的时间；huzzah！），因为您没有具有“数组”类型的表达式。但我认为关于预处理器评估细节的这一点真的很重要。

对于多维数组，它有点复杂。通常人们定义明确的宏常量，即

#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中数组的大小：

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

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

“你介绍了一种用脚射击自己的微妙方式”

'native' 数组不存储它们的大小。因此建议将数组的长度保存在单独的变量/常量中，并在传递数组时传递它，即：

#define MY_ARRAY_LENGTH   15
int myArray[MY_ARRAY_LENGTH];

你应该总是避免使用原生数组（除非你不能，在这种情况下，请注意你的脚）。如果您正在编写 C++，请使用 STL 的“向量”容器。 “与数组相比，它们提供几乎相同的性能”，而且它们更有用！

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

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

如果你真的想这样做来传递你的数组，我建议实现一个结构来存储一个指向你想要一个数组的类型的指针和一个表示数组大小的整数。然后你可以将它传递给你的函数。只需将数组变量值（指向第一个元素的指针）分配给该指针。然后您可以使用 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: %d\n", 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;
}

最好的方法是保存这些信息，例如，在一个结构中：

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

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

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

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

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

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

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

#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

最简单的答案：

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

对于预定义的数组：

 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("%d\n", sizeof(a)/sizeof(int));
    int *first=a;
    int *last=&(a[9]);
    printf("%d\n", (last-first)+1);
}

输出：

10
10

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

#include <stdio.h>

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

注意：这个可以给你未定义的行为，正如 MM 在评论中指出的那样。

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

有关详细信息，请参阅 here 和 here。

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

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 的链接。

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