对于动态数组(malloc或c++ new)，你需要像其他人提到的那样存储数组的大小，或者构建一个数组管理器结构来处理添加、删除、计数等。不幸的是，C在这方面做得不如c++好，因为你基本上必须为你存储的每一种不同的数组类型构建它，如果你需要管理多种类型的数组，这是很麻烦的。

对于静态数组(例如您示例中的数组)，有一个通用宏用于获取大小，但不建议使用它，因为它不会检查参数是否真的是静态数组。宏在实际代码中使用，例如在Linux内核头文件中，尽管它可能与下面的略有不同:

#if !defined(ARRAY_SIZE)
    #define ARRAY_SIZE(x) (sizeof((x)) / sizeof((x)[0]))
#endif

int main()
{
    int days[] = {1,2,3,4,5};
    int *ptr = days;
    printf("%u\n", ARRAY_SIZE(days));
    printf("%u\n", sizeof(ptr));
    return 0;
}

您可以使用谷歌来提防这样的宏。小心些而已。

如果可能的话，c++的标准库，如vector，更安全，更容易使用。

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

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

答案是，“不。”

C程序员所做的就是将数组的大小存储在某个地方。它可以是结构的一部分，或者程序员可以欺骗一点，malloc()比要求的更多的内存，以便在数组开始之前存储长度值。

正如所有正确答案所述，您不能仅从数组的衰减指针值获得此信息。如果衰减指针是函数接收到的参数，则必须以其他方式提供原始数组的大小，以便函数知道该大小。

这里有一个不同于目前所提供的建议，它可以工作:传递一个指向数组的指针。这个建议类似于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 */

如果假定函数能够操作任意大小的数组，则必须将大小作为附加信息提供给函数。

在字符串中，末尾有一个'\0'字符，因此可以使用strlen等函数来获取字符串的长度。例如，整数数组的问题是不能使用任何值作为结束值，因此一种可能的解决方案是寻址数组并使用NULL指针作为结束值。

#include <stdio.h>
/* the following function will produce the warning:
 * ‘sizeof’ on array function parameter ‘a’ will
 * return size of ‘int *’ [-Wsizeof-array-argument]
 */
void foo( int a[] )
{
    printf( "%lu\n", sizeof a );
}
/* so we have to implement something else one possible
 * idea is to use the NULL pointer as a control value
 * the same way '\0' is used in strings but this way
 * the pointer passed to a function should address pointers
 * so the actual implementation of an array type will
 * be a pointer to pointer
 */
typedef char * type_t; /* line 18 */
typedef type_t ** array_t;
int main( void )
{
    array_t initialize( int, ... );
    /* initialize an array with four values "foo", "bar", "baz", "foobar"
     * if one wants to use integers rather than strings than in the typedef
     * declaration at line 18 the char * type should be changed with int
     * and in the format used for printing the array values 
     * at line 45 and 51 "%s" should be changed with "%i"
     */
    array_t array = initialize( 4, "foo", "bar", "baz", "foobar" );

    int size( array_t );
    /* print array size */
    printf( "size %i:\n", size( array ));

    void aprint( char *, array_t );
    /* print array values */
    aprint( "%s\n", array ); /* line 45 */

    type_t getval( array_t, int );
    /* print an indexed value */
    int i = 2;
    type_t val = getval( array, i );
    printf( "%i: %s\n", i, val ); /* line 51 */

    void delete( array_t );
    /* free some space */
    delete( array );

    return 0;
}
/* the output of the program should be:
 * size 4:
 * foo
 * bar
 * baz
 * foobar
 * 2: baz
 */
#include <stdarg.h>
#include <stdlib.h>
array_t initialize( int n, ... )
{
    /* here we store the array values */
    type_t *v = (type_t *) malloc( sizeof( type_t ) * n );
    va_list ap;
    va_start( ap, n );
    int j;
    for ( j = 0; j < n; j++ )
        v[j] = va_arg( ap, type_t );
    va_end( ap );
    /* the actual array will hold the addresses of those
     * values plus a NULL pointer
     */
    array_t a = (array_t) malloc( sizeof( type_t *) * ( n + 1 ));
    a[n] = NULL;
    for ( j = 0; j < n; j++ )
        a[j] = v + j;
    return a;
}
int size( array_t a )
{
    int n = 0;
    while ( *a++ != NULL )
        n++;
    return n;
}
void aprint( char *fmt, array_t a )
{
    while ( *a != NULL )
        printf( fmt, **a++ );   
}
type_t getval( array_t a, int i )
{
    return *a[i];
}
void delete( array_t a )
{
    free( *a );
    free( a );
}

对于这个特定的例子，是的，如果你使用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