cat-like tool with fread() and write() in C

[Yamagi]

Wobei sich sizeof() nicht so verhält, wie man intuitiv erwarten würde. Es macht genau das was der Name sagt, es gibt die Größe eines Objekts in Byte zurück:

#include <stdio.h>

int buffer1[64];

void sizes(int *buffer2)
{
    int buffer3[256];

    printf("buffer1: %lu\n", sizeof(buffer1));
    printf("buffer2: %lu\n", sizeof(buffer2));
    printf("buffer3: %lu\n", sizeof(buffer3));
}

int main(void)
{
    int buffer2[128];

    sizes(buffer2);

    return 0;
}

# ./sizeof
buffer1: 256
buffer2: 8
buffer3: 1024

Nachtrag: Es ist ein 64 Bit System.

 

[mogbo]

[1][2] ist ein C/C++ Operator der die die Größe des Objektes zurück liefert.

Die Ablageart von sizeof() wurde mir beim Googeln leider nicht klar, ich würde gerne wissen wo diese Information abgelegt wird, da ich eigentlich immer dachte das sizeof zur Kompilierzeit schon durch Werte ersetzt wird (die Links helfen mir leider nicht weiter)

printf("buffer1: %lu\n", sizeof(buffer1)); printf("buffer2: %lu\n", sizeof(buffer2)); printf("buffer3: %lu\n", sizeof(buffer3));

buffer1 = sizeof(int) * 64
buffer2 = sizeof(int *)
buffer3 = sizeof(int) * 256

Die Art der Ausgabe ist mir bewusst, ich verstehe blos nicht wo die Info abgelegt wird bzw. ob ich diese Info irgendwo ohne sizeof nachlesen kann

int
*zahl(void)
{
    void *calc = malloc(sizeof(int));
    *((int *) calc) = arc4random() % 100 + 1;

    return calc;
}


int
main(void)
{
    void *ptr;

    char buffer[*((int *) (ptr = zahl()))];
    freezero(ptr, sizeof(int));

    printf("sizeof(buffer): %lu\n", sizeof(buffer));

    return EXIT_SUCCESS;
}

Gerade in diesem Beispiel, ich lege einen dynamischen Randomwert auf einem dynamischen Punkt im Speicher ab und Nulle die Info vor der Abfrage und trotzdem klappts

 

[Yamagi]

Das sind zwei Fälle:

• Für alles, was kein Variable Size Array (VLA) ist, kann der Compiler zur Compilezeit entscheiden, was sizeof() ergibt und den Wert entsprechend einfügen. In dem Fall geschieht zur Laufzeit also überhaupt nichts.
• VLA sind in C eine Art Fremdkörper und auch wenn sie manchmal ganz praktisch sein können, waren sie nicht unbedingt eine gute Idee. Im Fall von VLA muss der Compiler Code in das Programm einbauen, der einige zugehörige Metadatenverwaltet. Das ist unter anderem die Größe bzw. Länge des Felds. Diese Größeninformation kann dann genutzt werden um sizeof() zur Laufzeit zu implementieren. Wo und wie die Information abgelegt ist, ist dabei Implementierungsabhängig meine ich.

 

[mogbo]

Gut, dann verwende ich sizeof weiterhin nicht für Arrays und dynamisches Zeug

 

[schorsch_76]

Du kannst auch sizeof(buffer)/sizeof(buffer[0]) machen

 

[Yamagi]

Ja, das geht schon. Ich wollte auch nicht sagen "nutze es nicht", sondern eher "behalte im Hinterkopf, was es macht".

 

[Tron]

• VLA sind in C eine Art Fremdkörper und [...] Diese Größeninformation kann dann genutzt werden um sizeof() zur Laufzeit zu implementieren. Wo und wie die Information abgelegt ist, ist dabei Implementierungsabhängig meine ich.

Das klingt viel schlimmer als es alles ist.
Effektiv kann man sich

int arr[a * b + c];
... sizeof(arr) ...

so vorstellen:

size_t const N = a * b + c;
int arr[N];
... (sizeof(*arr) * N) ... /* Elementgröße * Anzahl */

Das muss auch so funktionieren, denn z.B. ein Ändern von 'a' darf keinen Einfluss auf das Ergebnis von 'sizeof(arr)' haben.