首先，这里有一些代码:
int main()
{
int days[] = {1,2,3,4,5};
int *ptr = days;
printf("%u\n", sizeof(days));
printf("%u\n", sizeof(ptr));
return 0;
}
是否有一种方法可以找出ptr指向的数组的大小(而不是仅仅给出它的大小，这在32位系统上是4个字节)?
当前回答
大多数实现都有一个函数，告诉你使用malloc()或calloc()分配的对象的保留大小，例如GNU有malloc_usable_size()
但是，这将返回反转块的大小，它可以大于malloc()/realloc()的值。
其他回答
#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;
}
对于这个特定的例子，是的，如果你使用typedefs(见下面)。当然，如果您这样做，您也可以使用SIZEOF_DAYS，因为您知道指针指向什么。
如果你有一个(void *)指针，就像malloc()之类返回的那样，那么，没有办法确定指针指向什么数据结构，因此，也没有办法确定它的大小。
#include <stdio.h>
#define NUM_DAYS 5
typedef int days_t[ NUM_DAYS ];
#define SIZEOF_DAYS ( sizeof( days_t ) )
int main() {
days_t days;
days_t *ptr = &days;
printf( "SIZEOF_DAYS: %u\n", SIZEOF_DAYS );
printf( "sizeof(days): %u\n", sizeof(days) );
printf( "sizeof(*ptr): %u\n", sizeof(*ptr) );
printf( "sizeof(ptr): %u\n", sizeof(ptr) );
return 0;
}
输出:
SIZEOF_DAYS: 20
sizeof(days): 20
sizeof(*ptr): 20
sizeof(ptr): 4
大多数实现都有一个函数，告诉你使用malloc()或calloc()分配的对象的保留大小，例如GNU有malloc_usable_size()
但是，这将返回反转块的大小，它可以大于malloc()/realloc()的值。
正如所有正确答案所述，您不能仅从数组的衰减指针值获得此信息。如果衰减指针是函数接收到的参数，则必须以其他方式提供原始数组的大小，以便函数知道该大小。
这里有一个不同于目前所提供的建议，它可以工作:传递一个指向数组的指针。这个建议类似于c++风格的建议，除了C不支持模板或引用:
#define ARRAY_SZ 10
void foo (int (*arr)[ARRAY_SZ]) {
printf("%u\n", (unsigned)sizeof(*arr)/sizeof(**arr));
}
但是，这个建议对于您的问题来说有点愚蠢，因为函数被定义为确切地知道传入的数组的大小(因此，几乎不需要对数组使用sizeof)。不过，它所做的是提供一些类型安全性。它将禁止传入一个不需要的大小的数组。
int x[20];
int y[10];
foo(&x); /* error */
foo(&y); /* ok */
如果假定函数能够操作任意大小的数组，则必须将大小作为附加信息提供给函数。
这就是我个人在代码中所做的。我喜欢让它尽可能简单，同时仍然能够得到我需要的值。
typedef struct intArr {
int size;
int* arr;
} intArr_t;
int main() {
intArr_t arr;
arr.size = 6;
arr.arr = (int*)malloc(sizeof(int) * arr.size);
for (size_t i = 0; i < arr.size; i++) {
arr.arr[i] = i * 10;
}
return 0;
}
