大多数实现都有一个函数，告诉你使用malloc()或calloc()分配的对象的保留大小，例如GNU有malloc_usable_size()

但是，这将返回反转块的大小，它可以大于malloc()/realloc()的值。

有一个流行的宏，你可以定义它来查找数组中的元素数量(Microsoft CRT甚至为它提供了名为_countof的OOB):

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

然后你可以这样写:

int my_array[] = { ... some elements ... };
printf("%zu", countof(my_array)); // 'z' is correct type specifier for size_t

没有神奇的解决办法。C不是一种反射语言。对象不会自动知道它们是什么。

但你有很多选择:

显然，要添加一个参数 将调用包装在宏中并自动添加参数 使用更复杂的对象。定义一个包含动态数组和数组大小的结构。然后，传递结构的地址。

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

#define array(type) struct { size_t size; type elem[0]; }

void *array_new(int esize, int ecnt)
{
    size_t *a = (size_t *)malloc(esize*ecnt+sizeof(size_t));
    if (a) *a = ecnt;
    return a;
}
#define array_new(type, count) array_new(sizeof(type),count)
#define array_delete free
#define array_foreach(type, e, arr) \
    for (type *e = (arr)->elem; e < (arr)->size + (arr)->elem; ++e)

int main(int argc, char const *argv[])
{
    array(int) *iarr = array_new(int, 10);
    array(float) *farr = array_new(float, 10);
    array(double) *darr = array_new(double, 10);
    array(char) *carr = array_new(char, 11);
    for (int i = 0; i < iarr->size; ++i) {
        iarr->elem[i] = i;
        farr->elem[i] = i*1.0f;
        darr->elem[i] = i*1.0;
        carr->elem[i] = i+'0';
    }
    array_foreach(int, e, iarr) {
        printf("%d ", *e);
    }
    array_foreach(float, e, farr) {
        printf("%.0f ", *e);
    }
    array_foreach(double, e, darr) {
        printf("%.0lf ", *e);
    }
    carr->elem[carr->size-1] = '\0';
    printf("%s\n", carr->elem);

    return 0;
}

不，你不能。编译器不知道指针指向什么。有一些技巧，比如用一个已知的带外值结束数组，然后计算数组的大小直到该值为止，但这不是使用sizeof()。

另一个技巧是Zan提到的，那就是把大小藏在某个地方。例如，如果你在动态分配数组，分配一个比你需要的大一个整型的块，在第一个整型中保存大小，并返回ptr+1作为指向数组的指针。当您需要指针的大小时，可以递减指针并查看存储的值。记住要从头开始释放整个块，而不仅仅是数组。

大多数实现都有一个函数，告诉你使用malloc()或calloc()分配的对象的保留大小，例如GNU有malloc_usable_size()

但是，这将返回反转块的大小，它可以大于malloc()/realloc()的值。