Comment trouver le 'sizeof' (un pointeur pointant vers un tableau)?

Tout d'abord, voici un code:

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

    return 0;
}

Existe-t-il un moyen de connaître la taille du tableau qui ptrpointe vers (au lieu de simplement donner sa taille, qui est de quatre octets sur un système 32 bits)?

Non, tu ne peux pas. Le compilateur ne sait pas vers quoi pointe le pointeur. Il existe des astuces, comme terminer le tableau avec une valeur hors bande connue, puis compter la taille jusqu'à cette valeur, mais ce n'est pas utilisé sizeof().

Une autre astuce est celle mentionnée par Zan , qui consiste à cacher la taille quelque part. Par exemple, si vous allouez dynamiquement le tableau, allouez un bloc un entier plus grand que celui dont vous avez besoin, cachez la taille dans le premier entier et retournez ptr+1comme pointeur vers le tableau. Lorsque vous avez besoin de la taille, décrémentez le pointeur et regardez la valeur cachée. N'oubliez pas de libérer tout le bloc à partir du début, et pas seulement le tableau.

La réponse est non."

Les programmeurs C stockent la taille du tableau quelque part. Il peut faire partie d'une structure, ou le programmeur peut tricher un peu et malloc()plus de mémoire que demandé afin de stocker une valeur de longueur avant le début du tableau.

Pour les tableaux dynamiques ( malloc ou C ++ nouveau ), vous devez stocker la taille du tableau comme mentionné par d'autres ou peut-être créer une structure de gestionnaire de tableau qui gère l'ajout, la suppression, le comptage, etc. Malheureusement, C ne le fait pas aussi bien que C ++ puisque vous devez essentiellement le construire pour chaque type de tableau différent que vous stockez, ce qui est lourd si vous avez plusieurs types de tableaux que vous devez gérer.

Pour les tableaux statiques, tels que celui de votre exemple, une macro courante est utilisée pour obtenir la taille, mais elle n'est pas recommandée car elle ne vérifie pas si le paramètre est vraiment un tableau statique. Cependant, la macro est utilisée dans du code réel, par exemple dans les en-têtes du noyau Linux, bien qu'elle puisse être légèrement différente de celle 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 des raisons de se méfier de macros comme celle-ci. Faites attention.

Si possible, le stdlib C ++ tel que vector qui est beaucoup plus sûr et plus facile à utiliser.

Il existe une solution propre avec des modèles C ++, sans utiliser sizeof () . La fonction getSize () suivante renvoie la taille de tout tableau statique:

#include <cstddef>

template<typename T, size_t SIZE>
size_t getSize(T (&)[SIZE]) {
    return SIZE;
}

Voici un exemple avec une structure foo_t :

#include <cstddef>

template<typename T, size_t SIZE>
size_t getSize(T (&)[SIZE]) {
    return SIZE;
}

struct foo_t {
    int ball;
};

int main()
{
    foo_t foos3[] = {{1},{2},{3}};
    foo_t foos5[] = {{1},{2},{3},{4},{5}};
    printf("%u\n", getSize(foos3));
    printf("%u\n", getSize(foos5));

    return 0;
}

Production:

3
5

Pour cet exemple spécifique, oui, il y en a, SI vous utilisez des typedefs (voir ci-dessous). Bien sûr, si vous le faites de cette façon, vous pouvez tout aussi bien utiliser SIZEOF_DAYS, car vous savez vers quoi pointe le pointeur.

Si vous avez un pointeur (void *), comme renvoyé par malloc () ou similaire, alors, non, il n'y a aucun moyen de déterminer la structure de données vers laquelle le pointeur pointe et donc, 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;
} 

Production:

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

Comme toutes les bonnes réponses l'ont indiqué, vous ne pouvez pas obtenir ces informations uniquement à partir de la valeur du pointeur pourri du tableau. Si le pointeur pourri est l'argument reçu par la fonction, alors la taille du tableau d'origine doit être fournie d'une autre manière pour que la fonction connaisse cette taille.

Voici une suggestion différente de ce qui a été fourni jusqu'à présent, qui fonctionnera: passez plutôt un pointeur vers le tableau. Cette suggestion est similaire aux suggestions de style C ++, 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 idiote pour votre problème, car la fonction est définie pour connaître exactement la taille du tableau qui est passé (par conséquent, il n'est pas nécessaire d'utiliser sizeof du tout sur le tableau). Cependant, il offre une certaine sécurité de type. Il vous interdira de passer dans un tableau d'une taille indésirable.

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

Si la fonction est censée pouvoir fonctionner sur n'importe quelle taille de tableau, vous devrez fournir la taille de la fonction comme information supplémentaire.

Il n'y a pas de solution magique. C n'est pas un langage réflexif. Les objets ne savent pas automatiquement ce qu'ils sont.

Mais vous avez plusieurs choix:

1. De toute évidence, ajoutez un paramètre
2. Envelopper l'appel dans une macro et ajouter automatiquement un paramètre
3. Utilisez un objet plus complexe. Définissez une structure qui contient le tableau dynamique ainsi que la taille du tableau. Ensuite, passez l'adresse de la structure.

Ma solution à ce problème consiste à enregistrer la longueur du tableau dans un tableau struct en tant que méta-informations sur le tableau.

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

struct Array
{
    int length;

    double *array;
};

typedef struct Array Array;

Array* NewArray(int length)
{
    /* Allocate the memory for the struct Array */
    Array *newArray = (Array*) malloc(sizeof(Array));

    /* Insert only non-negative length's*/
    newArray->length = (length > 0) ? length : 0;

    newArray->array = (double*) malloc(length*sizeof(double));

    return newArray;
}

void SetArray(Array *structure,int length,double* array)
{
    structure->length = length;
    structure->array = array;
}

void PrintArray(Array *structure)
{       
    if(structure->length > 0)
    {
        int i;
        printf("length: %d\n", structure->length);
        for (i = 0; i < structure->length; i++)
            printf("%g\n", structure->array[i]);
    }
    else
        printf("Empty Array. Length 0\n");
}

int main()
{
    int i;
    Array *negativeTest, *days = NewArray(5);

    double moreDays[] = {1,2,3,4,5,6,7,8,9,10};

    for (i = 0; i < days->length; i++)
        days->array[i] = i+1;

    PrintArray(days);

    SetArray(days,10,moreDays);

    PrintArray(days);

    negativeTest = NewArray(-5);

    PrintArray(negativeTest);

    return 0;
}

Mais vous devez vous soucier de définir la bonne longueur du tableau que vous souhaitez stocker, car il n'y a aucun moyen de vérifier cette longueur, comme nos amis l'ont expliqué massivement.

Vous pouvez faire quelque chose comme ça:

int days[] = { /*length:*/5, /*values:*/ 1,2,3,4,5 };
int *ptr = days + 1;
printf("array length: %u\n", ptr[-1]);
return 0;

Non, vous ne pouvez pas utiliser sizeof(ptr)pour trouver la taille du tableau ptrvers laquelle pointe.

Bien que l'allocation de mémoire supplémentaire (plus que la taille du tableau) sera utile si vous souhaitez stocker la longueur dans un espace supplémentaire.

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

    return 0;
}

La taille des jours [] est de 20, ce qui n'est pas un élément * la taille de son type de données. Alors que la taille du pointeur est de 4, peu importe ce qu'il pointe. Parce qu'un pointeur pointe vers un autre élément en stockant son adresse.

 #define array_size 10

 struct {
     int16 size;
     int16 array[array_size];
     int16 property1[(array_size/16)+1]
     int16 property2[(array_size/16)+1]
 } array1 = {array_size, 0, 1, 2, 3, 4, 5, 6, 7, 8, 9};

 #undef array_size

array_size passe à la variable de taille :

#define array_size 30

struct {
    int16 size;
    int16 array[array_size];
    int16 property1[(array_size/16)+1]
    int16 property2[(array_size/16)+1]
} array2 = {array_size};

#undef array_size

L'utilisation est:

void main() {

    int16 size = array1.size;
    for (int i=0; i!=size; i++) {

        array1.array[i] *= 2;
    }
}

Dans les chaînes, il y a un '\0'caractère à la fin de sorte que la longueur de la chaîne peut être obtenue en utilisant des fonctions comme strlen. Le problème avec un tableau entier, par exemple, est que vous ne pouvez pas utiliser de valeur comme valeur finale, donc une solution possible consiste à adresser le tableau et à utiliser comme valeur finale le NULLpointeur.

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