Comment trouver le "sizeof" (un pointeur pointant sur un tableau)?

Non, vous ne pouvez pas. Le compilateur ne sait pas ce que le pointeur pointe. Il y a des trucs, comme la fin du tableau avec un out-of-band de la valeur et puis en comptant la taille jusqu'à ce que la valeur, mais ce n'est pas à l'aide de sizeof.

Une autre astuce est celle mentionnée par Zan, qui est à ranger la taille quelque part. Par exemple, si vous êtes alloue dynamiquement le tableau, allouer un bloc un int plus grand que celui dont vous avez besoin, la planque de la taille à la première de type int, et le retour ptr+1 comme le pointeur vers le tableau. Lorsque vous avez besoin de la taille, décrémenter le pointeur et coup d'oeil à l'planqué valeur. N'oubliez pas de libérer l'ensemble du bloc de départ depuis le début, et pas seulement le tableau.

Pour les tableaux dynamiques (malloc ou C++ nouveau) vous avez besoin de stocker la taille de la matrice comme mentionné par d'autres, ou peut-être construire un tableau gestionnaire de la structure qui s'occupe d'ajouter, de supprimer, compter, etc. Malheureusement, C de ne pas le faire presque aussi bien que le C++ depuis en gros, vous avez à construire pour chaque différent type de tableau que vous stockez, ce qui est contraignant si vous disposez de plusieurs types de tableaux que vous avez besoin pour gérer.

Pour les tableaux statiques, comme dans votre exemple, il existe une macro permet d'obtenir la taille, mais il est pas recommandé qu'il ne vérifie pas si le paramètre est vraiment un tableau statique. La macro est utilisée dans le code réel, bien que, par exemple, dans le noyau de Linux les en-têtes bien qu'il peut être légèrement différent de celui ci-dessous:

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

Vous pouvez google pour raisons de se méfier des macros comme cela. Être prudent.

Si possible, le C++ stdlib comme vecteur qui est beaucoup plus sûr et plus facile à utiliser.

Pour cet exemple précis, oui, il est, SI vous utilisez des typedefs (voir ci-dessous). Bien sûr, si vous faites de cette façon, vous êtes aussi bien pour l'utilisation SIZEOF_DAYS, puisque vous savez ce que le pointeur pointe.

Si vous avez un (void * pointeur, comme retourné par malloc() ou autres, alors, non, il n'y a aucun moyen de déterminer quelle structure de données que le pointeur pointe et, par conséquent, aucun moyen de déterminer sa taille.

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

De sortie:

SIZEOF_DAYS:  20
sizeof(days): 20
sizeof(*ptr): 20
sizeof(ptr):  4

Comme toutes les bonnes réponses vous l'avez dit, vous ne pouvez pas obtenir cette information à partir de la vétuste la valeur du pointeur de la matrice seule. Si le pourri pointeur est l'argument reçu par la fonction, la taille de la provenance tableau doit être fourni pour la fonction venir à savoir que la taille de l'.

Voici une suggestion différente de ce qui a été fourni jusqu'à maintenant,qui va travailler: Passer un pointeur vers le tableau à la place. Cette suggestion est similaire pour le style C++ suggestions, sauf que C ne prend pas en charge les modèles ou les références:

#define ARRAY_SZ 10

void foo (int (*arr)[ARRAY_SZ]) {
    printf("%u\n", (unsigned)sizeof(*arr)/sizeof(**arr));
}

Mais, cette suggestion est un peu idiot de votre problème, puisque la fonction est définie pour connaître exactement la taille de la matrice qui est passé dans (et par conséquent, il n'est pas nécessaire d'utiliser sizeof à tous sur le tableau). Ce qu'il fait faire, cependant, est d'offrir un certain type de sécurité. Il va vous interdire de passer dans un tableau d'un format restreint.

int x[20];
int y[10];
foo(&x); /* error */
foo(&y); /* ok */

Si la fonction est censée être capable de fonctionner sur n'importe quelle taille de tableau, alors vous aurez à fournir la taille de la fonction en tant qu'informations supplémentaires.

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

    return 0;
}

Taille de jours[] est 20 qui n'est pas d'éléments * taille de ce type de données.
Alors que la taille du pointeur est de 4, peu importe ce qu'il désigne.
Parce qu'un pointeur de points de d'autres de l'élément de stockage d'adresse.

Non, vous ne pouvez pas utiliser sizeof(ptr) pour trouver la taille de la matrice de ptr pointe.

Si l'allocation de la mémoire supplémentaire(plus que la taille de la matrice), vous sera utile si vous souhaitez stocker la longueur de l'espace supplémentaire.

salut dans les cordes il y a un '\0' de caractère à la fin on peut donc obtenir la taille
d'une chaîne avec des fonctions comme strlen le problème avec un tableau d'entiers par exemple, c'est que u ne peut pas utiliser n'importe quelle valeur une valeur de fin donc une solution possible est de répondre à l'éventail et l'utiliser comme une valeur à la fin de la NULL pointeur

/* http://stackoverflow.com/questions/492384/how-to-find-the-sizeof-a-pointer-pointing-to-an-array */
#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;
/*
*    -- --
*   -**-**-
*   -$$$$$-
*    -999-
*     -^-
*      -
*/
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 );
}
/* край */