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

Question

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

也就是数组能容纳多少个元素？

score 1530 · Accepted Answer

执行摘要：

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

score 964 · Accepted Answer

如果您正在处理未作为参数接收的数组，则该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

score 162 · Accepted Answer

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

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

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

score 58 · Accepted Answer

“sizeof把戏”是我所知道的最好的方法，在括号的使用上有一个小但（对我来说，这是一个主要的烦恼）重要的变化。

正如 Wikipedia 条目所表明的那样，Csizeof不是函数。它是一个运算符。因此，它不需要在其参数周围加上括号，除非参数是类型名称。这很容易记住，因为它使参数看起来像一个强制转换表达式，它也使用括号。

所以：如果您有以下情况：

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

现在你受到保护了。当然，您复制了变量的名称，但是如果您更改它，这很可能会破坏编译器可以检测到的方式。

score 42 · Accepted Answer

42

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

查看此链接以获取说明

于 2013-12-07T22:43:01.680 回答

score 34 · Accepted Answer

我建议永远不要使用sizeof（即使可以使用）来获取数组的两种不同大小中的任何一种，无论是元素数还是字节数，这是我在这里展示的最后两种情况。对于这两种尺寸中的每一种，都可以使用下面显示的宏来使其更安全。原因是为了让维护者清楚代码的意图，和乍一看的区别（这种写法并不明显），这样每个阅读代码的人都会发现错误sizeof(ptr)。sizeof(arr)

TL;博士：

#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);                               \
                        char ISO_C_forbids_a_struct_with_no_members__;  \
                }                                                       \
        )                                                               \
)
#define must_be_array(arr)  must_be(is_array(arr))

有关此主题的重要错误：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构造的安全性。

使用示例：

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

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

memset()需要这个值作为它的第三个参数。

和以前一样，如果数组作为参数（指针）被接收，它将无法编译，我们将不得不用值替换宏调用：

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

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

更新（2020 年 4 月 23 日）：`-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]))并且希望让它安全。我们将需要 C2Xstatic_assert()和一些 GCC 扩展：表达式中的语句和声明， __ builtin_types_compatible_p：

#include <assert.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))

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

NowARRAY_SIZE()是完全安全的，因此它的所有衍生产品都是安全的。

更新：libbsd 提供`__arraycount()`：

libbsd__arraycount()提供了in的宏<sys/cdefs.h>，它是不安全的，因为它缺少一对括号，但是我们可以自己添加这些括号，因此我们甚至不需要在头文件中编写除法（为什么要复制已经存在的代码？）。该宏是在系统头文件中定义的，所以如果我们使用它，我们将被迫使用上面的宏。

#inlcude <assert.h>
#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))

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

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

更新：允许在文件范围内使用宏：

不幸的是，({})gcc 扩展不能在文件范围内使用。为了能够在文件范围内使用宏，静态断言必须在sizeof(struct {}). 然后，将其乘以0不影响结果。强制转换(int)可能很好地模拟返回的函数(int)0（在这种情况下，它不是必需的，但它可以重用于其他事情）。

此外，的定义ARRAY_BYTES()可以简化一点。

#include <assert.h>
#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 must_be(e)             (                                        \
        0 * (int)sizeof(                                                \
                struct {                                                \
                        static_assert(e);                               \
                        char ISO_C_forbids_a_struct_with_no_members__;  \
                }                                                       \
        )                                                               \
)
#define must_be_array(arr)      must_be(is_array(arr))

#define ARRAY_SIZE(arr)         (__arraycount((arr)) + 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))

笔记：

此代码使用以下扩展，这些扩展是完全必要的，并且它们的存在对于实现安全是绝对必要的。如果你的编译器没有它们，或者一些类似的，那么你就无法达到这种安全级别。

我还使用了以下 C2X 功能。但是，可以使用一些肮脏的技巧来克服使用较旧标准的缺失（例如，参见：C 代码中的“:-!!”是什么？）（在 C11 中您也有static_assert()，但它需要一条消息）。

static_assert()

score 27 · Accepted Answer

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

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

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

score 23 · Accepted Answer

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

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(array name) 都是一个指针。

score 22 · Accepted Answer

每个人都在使用的宏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！），因为您没有具有“数组”类型的表达式。但我认为关于预处理器评估细节的这一点真的很重要。

score 18 · Accepted Answer

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

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

等等，无穷无尽。

score 17 · Accepted Answer

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

score 16 · Accepted Answer

16

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

于 2008-09-01T06:50:31.253 回答

score 13 · Accepted Answer

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

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/

score 12 · Accepted Answer

12

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

于 2016-09-12T14:54:31.023 回答

score 6 · Accepted Answer

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

score 5 · Accepted Answer

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

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

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

score 5 · Accepted Answer

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

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

score 3 · Accepted Answer

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

#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

score 2 · Accepted Answer

最简单的答案：

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

score 2 · Accepted Answer

2

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

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

于 2020-01-28T10:42:39.893 回答

score 1 · Accepted Answer

对于预定义的数组：

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

计算数组中的元素数：

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

score -1 · Accepted Answer

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

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

Ifa是的数组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 / 1if是一个类型为或a的数组。除以 1 是多余的。charunsigned charsigned char

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

sizeof(a)

例如：

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

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

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

score -2 · Accepted Answer

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

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

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

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

23 回答 23

数组元素的大小

数组中的元素个数

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

更新（2020 年 4 月 23 日）：-Wsizeof-pointer-div有问题：

更新：libbsd 提供__arraycount()：

更新：允许在文件范围内使用宏：

笔记：

Related

Reference

更新（2020 年 4 月 23 日）：`-Wsizeof-pointer-div`有问题：

更新：libbsd 提供`__arraycount()`：