Wie findet man die 'sizeof' (einen Zeiger, der auf ein Array zeigt)?

Question

Zunächst einmal ist hier etwas 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;
}

Gibt es eine Möglichkeit, die Größe des Arrays herauszufinden, das ptr verweist (anstatt nur die Größe anzugeben, die auf einem 32-Bit-System vier Byte beträgt)?

Answer 1

Für dieses spezielle Beispiel, ja, es gibt, WENN Sie typedefs verwenden (siehe unten). Natürlich, wenn Sie es auf diese Weise tun, sind Sie genauso gut aus, um SIZEOF_DAYS verwenden, da Sie wissen, was der Zeiger zeigt auf.

Wenn Sie einen (void *)-Zeiger haben, wie er von malloc() oder ähnlichem zurückgegeben wird, dann gibt es keine Möglichkeit, festzustellen, auf welche Datenstruktur der Zeiger zeigt, und somit auch keine Möglichkeit, seine Größe zu bestimmen.

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

Ausgabe:

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

Answer 2

Sie können so vorgehen:

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

Answer 3

Es gibt keine Patentlösung. C ist keine reflektierende Sprache. Objekte wissen nicht automatisch, was sie sind.

Aber Sie haben die Qual der Wahl:

1. Fügen Sie natürlich einen Parameter hinzu
2. Den Aufruf in ein Makro verpacken und automatisch einen Parameter hinzufügen
3. Verwenden Sie ein komplexeres Objekt. Definieren Sie eine Struktur, die das dynamische Array und auch die Größe des Arrays enthält. Übergeben Sie dann die Adresse der Struktur.

Answer 4

Meine Lösung für dieses Problem ist es, die Länge des Arrays in einer Struktur Array als Meta-Information über das Array zu speichern.

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

Allerdings muss man darauf achten, die richtige Länge des zu speichernden Arrays einzustellen, da es keine Möglichkeit gibt, diese Länge zu überprüfen, wie unsere Freunde von Massive erklärt haben.

Answer 5

So mache ich es persönlich in meinem Code. Ich möchte es so einfach wie möglich halten und trotzdem die Werte erhalten, die ich brauche.

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