'Sizeof' (diziyi gösteren bir işaretçi) nasıl bulunur?

İlk önce, bazı kodlar:

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

    return 0;
}

ptrİşaret eden dizinin boyutunu bulmanın bir yolu var mı (sadece 32 bit sistemde dört bayt olan boyutunu vermek yerine)?

Hayır, yapamazsınız. Derleyici işaretçinin neye işaret ettiğini bilmiyor. Diziyi bilinen bir bant dışı değeriyle bitirmek ve ardından boyutu bu değere kadar saymak gibi hileler vardır, ancak bu kullanılmaz sizeof().

Başka bir hile, Zan'ın bahsettiği, bir yerlerde boyutu saklamaktır. Örneğin, diziyi dinamik olarak ayırıyorsanız, ihtiyacınız olandan bir int daha büyük bir blok atayın, ilk int'deki boyutu saklayın ptr+1ve diziye işaretçi olarak dönün . Boyuta ihtiyacınız olduğunda, işaretçiyi azaltın ve saklanan değere bakın. Sadece diziyi değil, baştan başlayarak tüm bloğu boşaltmayı unutmayın.

Cevap hayır."

C programcılarının yaptığı şey dizinin boyutunu bir yerde saklamaktır. Bir yapının parçası olabilir veya programcı malloc(), dizinin başlangıcından önce bir uzunluk değerini saklamak için istenenden biraz daha fazla bellek kopyalayabilir.

Dinamik diziler için ( malloc veya C ++ yeni ) dizinin boyutunu başkaları tarafından belirtildiği gibi depolamanız veya belki de ekleme, kaldırma, sayma, vb. İşlemlerini gerçekleştiren bir dizi yöneticisi yapısı oluşturmanız gerekir. Temel olarak yönetmeniz gereken çok sayıda diziniz varsa sakıncalı olan her farklı dizi türü için oluşturmak zorunda olduğunuz için C ++.

Örneğinizde olduğu gibi statik diziler için, boyutu elde etmek için kullanılan ortak bir makro vardır, ancak parametrenin gerçekten statik bir dizi olup olmadığını kontrol etmediğinden önerilmez . Makro, gerçek kodda, örneğin Linux çekirdek başlıklarında kullanılır, ancak aşağıdaki koddan biraz farklı olabilir:

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

Bunun gibi makrolara karşı dikkatli olmanız için Google'ı kullanabilirsiniz. Dikkatli ol.

Mümkünse, vektör gibi C ++ stdlib çok daha güvenli ve kullanımı daha kolaydır.

C ++ şablonları ile sizeof () kullanmadan temiz bir çözüm var . Aşağıdaki getSize () işlevi, herhangi bir statik dizinin boyutunu döndürür:

#include <cstddef>

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

İşte foo_t yapısına sahip bir örnek :

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

Çıktı:

3
5

Bu özel örnek için, evet, typedefs kullanırsanız (aşağıya bakın). Tabii ki, bu şekilde yaparsanız, işaretçinin neye işaret ettiğini bildiğiniz için SIZEOF_DAYS'i kullanmak kadar iyi değilsiniz.

Eğer malloc () ya da benzerleri tarafından döndürülen bir (void *) işaretçiniz varsa, o zaman hayır, işaretçinin hangi veri yapısını gösterdiğini ve dolayısıyla boyutunu belirlemenin bir yolu yoktur.

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

Çıktı:

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

Tüm doğru cevapların belirttiği gibi, bu bilgiyi sadece dizinin çürümüş işaretçi değerinden alamazsınız. Çürümüş işaretçi işlev tarafından alınan argüman ise, işlevin bu boyutu tanıması için kaynak dizinin boyutu başka bir şekilde sağlanmalıdır.

İşte şimdiye kadar sağlananlardan farklı bir öneri, işe yarayacak: Bunun yerine diziye bir işaretçi geçirin. Bu öneri, C'nin şablonları veya başvuruları desteklememesi dışında C ++ stil önerilerine benzer:

#define ARRAY_SZ 10

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

Ancak, bu öneri probleminiz için bir tür saçmadır, çünkü işlev geçirilen dizinin boyutunu tam olarak bilmek için tanımlanmıştır (bu nedenle, dizide sizeof'i kullanmaya çok az ihtiyaç vardır). Bununla birlikte yaptığı şey, bir tür güvenlik sunmaktır. İstenmeyen boyutta bir dizi geçirmenizi yasaklar.

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

İşlevin herhangi bir dizi boyutunda çalışabilmesi gerekiyorsa, işleve boyutu ek bilgi olarak sağlamanız gerekir.

Sihirli bir çözüm yok. C yansıtıcı bir dil değildir. Nesneler ne olduklarını otomatik olarak bilmezler.

Ancak birçok seçeneğiniz var:

1. Açıkçası, bir parametre ekleyin
2. Aramayı bir makroya sarın ve otomatik olarak bir parametre ekleyin
3. Daha karmaşık bir nesne kullanın. Dinamik diziyi ve dizinin boyutunu içeren bir yapı tanımlayın. Ardından, yapının adresini iletin.

Bu soruna benim çözüm dizinin uzunluğunu dizi hakkında bir meta-bilgi olarak bir yapı dizisine kaydetmek.

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

Ancak saklamak istediğiniz dizinin doğru uzunluğunu ayarlamanız gerekir, çünkü bu uzunluğu kontrol etmenin bir yolu yoktur, tıpkı arkadaşlarımızın kitlesel olarak açıkladığı gibi.

Bunun gibi bir şey yapabilirsiniz:

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

Hayır, sizeof(ptr)dizinin ptrişaret ettiği boyutu bulmak için kullanamazsınız .

Ekstra bellek ayırmak (dizinin boyutundan daha fazla) uzunluğunu fazladan alanda saklamak istiyorsanız yardımcı olacaktır.

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

    return 0;
}

Günlerin boyutu [], öğe türünden * olmayan 20'dir ve veri türünün boyutu. İşaretçi ne olursa olsun işaretçi boyutu 4'tür. Çünkü bir işaretçi diğer öğeyi adresini saklayarak işaret eder.

 #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 boyut değişkenine geçiyor :

#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

Kullanımı:

void main() {

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

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

Dizelerde '\0', sonunda işlevler kullanılarak dizenin uzunluğu elde edilebilen bir karakter vardır strlen. Örneğin, bir tamsayı dizisiyle ilgili sorun, bitiş değeri olarak herhangi bir değeri kullanamayacağınızdır, bu nedenle olası bir çözüm, diziyi adreslemek ve NULLişaretçiyi bir bitiş değeri olarak kullanmaktır .

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