Wie finden Sie die 'sizeof' (ein Zeiger auf ein array)?

Nein, das können Sie nicht. Der compiler weiß nicht, was der Zeiger zeigt. Gibt es tricks, wie Ende das array mit einer bekannten out-of-band-Wert und dann zählen die Größe, die bis zu diesem Wert, aber das ist nicht mit sizeof.

Ein weiterer trick ist das man erwähnt Zan, die zum verstauen der Größe irgendwo. Zum Beispiel, wenn Sie die dynamische Zuweisung von array, reserviert einen block ein int größer als die, die Sie brauchen, verstauen Sie die Größe in der ersten int und return ptr+1 als Zeiger auf das array. Wenn Sie benötigen, die Größe, dekrementiert den Zeiger und Blick auf den verteilt-Wert. Denken Sie daran, kostenlos den ganzen block beginnend, und nicht nur das array.

InformationsquelleAutor Paul Tomblin

Für dynamische arrays (malloc oder C++ neue) müssen Sie die Größe des array, wie von anderen erwähnt oder vielleicht bauen Sie einen array-manager-Struktur, die Griffe add, remove, count, etc. Leider ist C nicht dies tun fast so gut wie C++, da Sie im Grunde haben, es zu bauen, für jede andere array-Typ, den Sie speichern das ist umständlich, wenn Sie mehrere Arten von arrays, die Sie brauchen, um zu verwalten.

Für statische arrays, wie in deinem Beispiel, es gibt eine gemeinsame makro verwendet, um die Größe, aber es ist nicht empfohlen, als es sich nicht überprüfen, ob der parameter wirklich ein statisches array. Das makro verwendet wird, in echten code aber z.B. in den Linux-kernel-Header, obwohl es möglicherweise etwas anders aus als unten:

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

Können Sie google für Gründe, vorsichtig zu sein von Makros wie dieses. Seien Sie vorsichtig.

Wenn möglich, die C++ stdlib wie vector, die ist viel sicherer und einfacher zu verwenden.

InformationsquelleAutor Ryan

Diesem Beispiel, ja, es ist, WENN Sie Typdefinitionen (siehe unten). Natürlich, wenn Sie es so machen, du bist einfach so gut zu verwenden SIZEOF_DAYS, da Sie wissen, was der Zeiger verweist.

Wenn Sie ein (void *) - Zeiger zurückgegeben wird, die durch malloc() oder ähnliches ist, dann Nein, es gibt keine Möglichkeit zu bestimmen, welche Daten die Struktur der Zeiger verweist, und somit keine Möglichkeit, Ihre 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

InformationsquelleAutor David

Als alle richtigen Antworten angegeben haben, können Sie diese Informationen aus dem verfallenen Zeiger Wert des Arrays allein. Wenn das verfallene Zeiger ist das argument eingegangen, die von der Funktion, dann die Größe des ursprünglichen Arrays bereitgestellt werden muss, in anderer Form für die Funktion zu kommen, zu wissen, dass Größe.

Hier ist ein Vorschlag anders aus, was wurde zur Verfügung gestellt, so weit,dass es funktionieren wird: Übergeben wird ein Zeiger auf das array statt. Dieser Vorschlag ist ähnlich wie die C++ - Stil Vorschläge, außer dass C nicht unterstützt, Vorlagen oder Verweisungen:

#define ARRAY_SZ 10

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

Aber dieser Vorschlag ist eine Art von albern für dein problem, da die Funktion definiert ist, genau zu wissen, die Größe des Arrays, die übergeben wird (daher gibt es wenig Notwendigkeit zu verwenden, sizeof bei alle auf dem array). Was tut es tun, obwohl, ist bieten einige geben Sicherheit. Es untersagt Ihnen, von übergeben ein array von einer unerwünschten Größe.

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

Wenn die Funktion soll in der Lage sein zu arbeiten auf eine beliebige Größe des Arrays, dann müssen Sie die Größe, die der Funktion zusätzliche Informationen.

InformationsquelleAutor jxh

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

    return 0;
}

Größe der Tage[] ist 20 und ist keine der Elemente * Größe des Datentyps.
Während die Größe der Zeiger ist 4, egal was es verweist.
Da ein Zeiger verweist auf ein anderes element durch die Speicherung Ihrer Adresse.

InformationsquelleAutor Shivangi Chaurasia

Nein, können Sie nicht verwenden sizeof(ptr) ermitteln Sie die Größe des array ptr verweist.

Obwohl die Zuweisung zusätzlicher Speicher(mehr als die Größe des Arrays) wird hilfreich sein, wenn Sie wollen speichern Sie die Länge in extra Raum.

InformationsquelleAutor SKD

hi in strings gibt es eine '\0' Charakter am Ende, so kann man die Größe
eines Strings mit Funktionen wie strlen das problem mit einem integer-array zum Beispiel ist, dass u können nicht alle Wert als end-Wert, so dass eine mögliche Lösung ist die Adresse des Arrays und Verwendung als end-Wert der NULL Zeiger

/* 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 );
}
/* край */

InformationsquelleAutor baz