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

#1 楼

执行摘要：

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

#2 楼

如果您要处理未作为参数接收的数组，则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 OS中）：

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

#3 楼

值得注意的是，sizeof在处理已衰减为指针的数组值时无济于事：即使它指向数组的开头，但对于编译器，它与指向该数组单个元素的指针相同数组。指针不会“记住”用于初始化数组的其他任何信息。

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

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

#4 楼

sizeof技巧是我所知的最好方法，在括号的使用上有一个很小但是（对我来说，这是一个主要的麻烦）。

维基百科条目清楚地表明， 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);

现在您已受到保护。当然，您可以重复变量的名称，但是如果您更改它，则很有可能以编译器可以检测的方式破坏该变量。

#5 楼

int size = (&arr)[1] - arr;

查看此链接以获取解释

#6 楼

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

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

最初在此处找到的代码：
C程序查找数组中元素的数量

#7 楼

如果您知道数组的数据类型，则可以使用类似以下内容的方法：

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（数组名称）都是一个指针。

#8 楼

每个人都在使用的宏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最终将成为指针类型，并使整个宏无效（就像您试图在带有指针参数的函数中使用该宏一样）。

最后，在这种情况下，错误实际上并不重要（因此，我只是在浪费每个人的时间；烦死了！），因为您没有带有“数组”类型的表达式。但实际上，我认为关于预处理程序评估的要点很微妙。

#9 楼

对于多维数组，这有点复杂。人们通常会定义显式宏常量，即

#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])

等，无限制。

#10 楼

我建议不要使用sizeof（即使可以使用它）来获取数组的两个不同大小中的任何一个，无论是元素数量还是字节数，这是我在这里显示的最后两种情况。对于这两种大小，可以使用下面显示的宏使其更安全。原因是使代码的意图明显地体现给维护者，乍一看，sizeof(ptr)与sizeof(arr)的区别（这种写法并不明显），因此对于每个阅读代码的人来说，错误都是显而易见的。

; DR：

#define ARRAY_SIZE(arr)     (sizeof(arr) / sizeof((arr)[0]) + must_be_array(arr))

#define ARRAY_SSIZE(arr)    ((ptrdiff_t)ARRAY_SIZE(arr))

#define ARRAY_BYTES(arr)    (sizeof(arr) + must_be_array(arr))

#define ARRAY_SBYTES(arr)   ((ssize_t)ARRAY_BYTES(arr))

must_be_array(arr)（定义如下）是必需的，因为-Wsizeof-pointer-div越野车（截至2020年4月）：

#define is_same_type(a, b)  __builtin_types_compatible_p(typeof(a), typeof(b))
#define is_array(arr)       (!is_same_type((arr), &(arr)[0]))
#define must_be(e, ...)     (                               \
        0 * (int)sizeof(                                                \
                struct {                                                \
                        _Static_assert((e)  __VA_OPT__(,)  __VA_ARGS__);\
                        char ISO_C_forbids_a_struct_with_no_members__;  \
                }                                                       \
        )                                                               \
)
#define must_be_array(arr)  must_be(is_array(arr), "Not a `[]` !")

有是与此主题相关的重要错误：https://lkml.org/lkml/2015/9/3/428
我不同意Linus提供的解决方案，即永远不要对函数参数使用数组表示法。
我喜欢将数组表示法用作文档，该文档将指针用作数组。但这意味着需要应用一个简单的解决方案，以便不可能编写错误的代码。
从一个数组中，我们可能需要知道三种大小：

数组元素的大小
数组中元素的数目
数组在内存中使用的字节大小


数组
第一个非常简单，我们处理数组还是指针都没关系，因为它的处理方式相同。
用法示例：

void foo(ptrdiff_t nmemb, int arr[static nmemb])
{
        qsort(arr, nmemb, sizeof(arr[0]), cmp);
}

qsort()需要将此值作为其第三个参数。

对于其他两个大小（这是问题的主题），我们想确保正在处理数组，如果没有处理则中断编译，因为如果处理指针，则会得到错误的值。当编译中断时，我们可以很容易地看到我们不是在处理数组，而是在使用指针，并且我们只需要编写带有变量或存储宏大小的宏的代码即可。指针后面的数组。

数组中的元素数
这是最常见的，许多答案为您提供了典型的宏ARRAY_SIZE：

#define ARRAY_SIZE(arr)     (sizeof(arr) / sizeof((arr)[0]))

鉴于ARRAY_SIZE的结果通常与ptrdiff_t类型的带符号变量一起使用，最好定义此宏的带符号变体：

#define ARRAY_SSIZE(arr)    ((ptrdiff_t)ARRAY_SIZE(arr))

成员超过PTRDIFF_MAX的数组将给出无效的数组宏的此已签名版本的值，但从读取C17 :: 6.5.6.9来看，类似的数组已经开始运行。在这种情况下，仅应使用ARRAY_SIZE和size_t。
当您将此宏应用于指针时，最新版本的编译器（例如GCC 8）会警告您，因此是安全的（还有其他方法可以使其变得安全）使用较旧的编译器。）
通过将整个数组的字节大小除以每个元素的大小来工作。
使用示例：

void foo(ptrdiff_t nmemb)
{
        char buf[nmemb];

        fgets(buf, ARRAY_SIZE(buf), stdin);
}

void bar(ptrdiff_t nmemb)
{
        int arr[nmemb];

        for (ptrdiff_t i = 0; i < ARRAY_SSIZE(arr); i++)
                arr[i] = i;
}

如果这些函数没有如果使用数组，但改为使用数组作为参数，则先前的代码将无法编译，因此不可能出现错误（假设使用了最新的编译器版本，或者使用了其他技巧），并且我们需要用以下值替换宏调用：

void foo(ptrdiff_t nmemb, char buf[nmemb])
{

        fgets(buf, nmemb, stdin);
}

void bar(ptrdiff_t nmemb, int arr[nmemb])
{

        for (ptrdiff_t i = 0; i < nmemb; i++)
                arr[i] = i;
}

数组在内存中使用的字节大小
ARRAY_SIZE通常用作前一种情况的解决方案，但这种情况很少安全地写，也许是因为它不太常见。
获取此值的常用方法是使用sizeof(arr)。问题：与上一个相同；
解决问题的方法是使用与以前相同的宏，我们知道这是安全的（如果将其应用于指针，则会破坏编译过程） ）：

#define ARRAY_BYTES(arr)        (sizeof((arr)[0]) * ARRAY_SIZE(arr))

鉴于有时会将ARRAY_BYTES的结果与返回ssize_t的函数的输出进行比较，最好定义此宏的带符号变体：

#define ARRAY_SBYTES(arr)   ((ssize_t)ARRAY_BYTES(arr))

它的工作原理非常简单：它消除了ARRAY_SIZE的除法运算，因此在数学上的取消之后，您最终只得到一个sizeof(arr)，但又增加了ARRAY_SIZE结构的安全性。
memset()需要将此值作为第三个参数。
和以前一样，如果将数组作为参数（指针）接收，则它将无法编译，因此我们必须将宏调用替换为值：

void foo(ptrdiff_t nmemb)
{
        int arr[nmemb];

        memset(arr, 0, ARRAY_BYTES(arr));
}

更新（23 / apr / 2020）：-Wsizeof-pointer-div有错误：
今天我发现新的警告出现在只有在宏不是在系统头中定义的宏中，GCC才起作用。如果您在系统中安装的标头（通常是/usr/local/include/或/usr/include/）（#include <foo.h>）中定义宏，则编译器将不会发出警告（我尝试了GCC 9.3.0）。
所以我们有#define ARRAY_SIZE(arr) (sizeof(arr) / sizeof((arr)[0]))并想要使其安全。我们将需要C11 _Static_assert()和一些GCC扩展：表达式中的语句和声明，__ builtin_types_compatible_p：

void foo(ptrdiff_t nmemb, int arr[nmemb])
{

        memset(arr, 0, sizeof(arr[0]) * nmemb);
}

现在ARRAY_SIZE()是完全安全的，因此其所有派生形式都将是安全的。

更新：libbsd提供__arraycount()：
Libbsd在__arraycount()中提供了宏<sys/cdefs.h>，这是不安全的，因为它缺少一对圆括号，但是我们可以自己添加这些圆括号，因此我们甚至不需要在标头中写入除法（为什么我们要复制已经存在的代码存在吗？）。该宏是在系统头文件中定义的，因此如果使用它，则必须使用上面的宏。

#define is_same_type(a, b)      __builtin_types_compatible_p(typeof(a), typeof(b))
#define is_array(arr)           (!is_same_type((arr), &(arr)[0]))
#define Static_assert_array(arr) _Static_assert(is_array(arr), "Not a `[]` !")

#define ARRAY_SIZE(arr)         (                                       \
{                                                                       \
        Static_assert_array(arr);                                       \
        sizeof(arr) / sizeof((arr)[0]);                                \
}                                                                       \
)

有些系统在nitems()中提供<sys/param.h>，有些系统同时提供了两者。您应该检查系统，并使用现有的系统，并可能使用一些预处理器条件来实现可移植性，并同时支持两者。

更新：允许宏在文件范围内使用：
不幸的是，则不能在文件范围内使用({}) gcc扩展名。
要能够在文件范围内使用宏，静态声明必须在sizeof(struct {})内部。然后，将其乘以0不会影响结果。强制转换为(int)可能是不错的，它可以模拟返回(int)0的函数（在这种情况下没有必要，但随后它可重用于其他用途）。
另外，

#include <stddef.h>
#include <sys/cdefs.h>
#include <sys/types.h>


#define is_same_type(a, b)      __builtin_types_compatible_p(typeof(a), typeof(b))
#define is_array(arr)           (!is_same_type((arr), &(arr)[0]))
#define Static_assert_array(arr) _Static_assert(is_array(arr), "Not a `[]` !")

#define ARRAY_SIZE(arr)         (                                       \
{                                                                       \
        Static_assert_array(arr);                                       \
        __arraycount((arr));                                            \
}                                                                       \
)

#define ARRAY_SSIZE(arr)        ((ptrdiff_t)ARRAY_SIZE(arr))
#define ARRAY_BYTES(arr)        (sizeof((arr)[0]) * ARRAY_SIZE(arr))
#define ARRAY_SBYTES(arr)       ((ssize_t)ARRAY_BYTES(arr))

注意：
此代码利用以下扩展，这些扩展是完全必要的，并且它们的存在对于确保安全是绝对必要的。如果您的编译器没有它们，或类似的东西，那么您就无法达到此安全级别。

ARRAY_BYTES()
__builtin_types_compatible_p()

我也做了使用以下C11功能。但是，可以使用一些肮脏的技巧来克服由于使用较旧的标准而导致的缺失（例如，参见：C代码中的“：-!!”是什么？）。

typeof()

我也使用以下扩展名，但是有一种标准的C方法可以执行相同的操作。

_Static_assert()

#11 楼

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

#12 楼

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

#13 楼

“您已经介绍了一种用脚射击自己的微妙方法”

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

#14 楼

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

#15 楼

如果您真的想通过数组来传递数据，那么我建议您实现一个结构，以存储指向您想要的数组类型的指针和一个表示数组大小的整数。然后，您可以将其传递给函数。只需将数组变量值（指向第一个元素的指针）分配给该指针。然后可以使用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;
}

#16 楼

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

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

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

#17 楼

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

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

#18 楼

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

#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

#19 楼

最简单的答案：

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

#20 楼

更优雅的解决方案是

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

#21 楼

除了已经提供的答案外，我想通过使用

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。”


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

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

sizeof(a)

例如：

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

如果您想证明，这里是GodBolt的链接。


但是，如果类型发生明显变化，该部门仍将保持安全。 （尽管这些情况很少见。）

#22 楼

注意：这可以给您MM在注释中指出的未定义行为。

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

有关更多详细信息，请参见
此处
以及此处。