Wie weist der Compiler Speicher zu, ohne die Größe zur Kompilierzeit zu kennen?

Ich habe ein C-Programm geschrieben, das ganzzahlige Eingaben vom Benutzer akzeptiert, die als Größe eines ganzzahligen Arrays verwendet werden, und mit diesem Wert deklariert es ein Array mit einer bestimmten Größe, und ich bestätige dies, indem ich die Größe des Arrays überprüfe.

Code:

#include <stdio.h>
int main(int argc, char const *argv[])
{
    int n;
    scanf("%d",&n);
    int k[n];
    printf("%ld",sizeof(k));
    return 0;
}

und überraschenderweise ist es richtig! Das Programm ist in der Lage, das Array der erforderlichen Größe zu erstellen.
Aber die gesamte statische Speicherzuweisung erfolgt zur Kompilierzeit, und während der Kompilierzeit wird der Wert von n ist nicht bekannt, wie kommt es also, dass der Compiler Speicher der erforderlichen Größe zuweisen kann?

Wenn wir den erforderlichen Speicher einfach so zuweisen können, wozu dient dann die dynamische Zuweisung? malloc() und calloc()?

Dies ist keine “statische Speicherzuweisung”. Ihr Array k ist ein Array mit variabler Länge (VLA), was bedeutet, dass Speicher für dieses Array zur Laufzeit zugewiesen wird. Die Größe wird durch den Laufzeitwert von bestimmt n.

Die Sprachspezifikation schreibt keinen bestimmten Zuordnungsmechanismus vor, aber in einer typischen Implementierung Ihren k wird in der Regel ein einfaches sein int * Zeiger mit dem tatsächlichen Speicherblock, der zur Laufzeit auf dem Stapel zugewiesen wird.

Für ein VLA sizeof -Operator wird auch zur Laufzeit ausgewertet, weshalb Sie in Ihrem Experiment den richtigen Wert daraus erhalten. Benutz einfach %zu (nicht %ld), um Werte vom Typ zu drucken size_t.

Der Hauptzweck von malloc (und andere dynamische Speicherzuweisungsfunktionen) besteht darin, die bereichsbasierten Lebensdauerregeln zu überschreiben, die für lokale Objekte gelten. Dh Speicher mit zugewiesen malloc bleibt “für immer” zugewiesen oder bis Sie die Zuweisung explizit aufheben free. Speicher allokiert mit malloc wird am Ende des Blocks nicht automatisch freigegeben.

VLA bietet wie in Ihrem Beispiel diese “Scope-Defeating” -Funktionalität nicht. Ihr Array k befolgt weiterhin reguläre bereichsbasierte Lebensdauerregeln: Seine Lebensdauer endet am Ende des Blocks. Aus diesem Grund kann VLA im Allgemeinen unmöglich ersetzen malloc und andere dynamische Speicherzuordnungsfunktionen.

Aber in bestimmten Fällen, wenn Sie den Bereich nicht “besiegen” und einfach verwenden müssen malloc Um ein Array in Laufzeitgröße zuzuweisen, könnte VLA tatsächlich als Ersatz für angesehen werden malloc. Denken Sie nur noch einmal daran, dass VLAs normalerweise auf dem Stapel zugewiesen werden und die Zuweisung großer Speicherblöcke auf dem Stapel bis heute eine ziemlich fragwürdige Programmierpraxis bleibt.

In C ist es Sache des Compilers, wie ein Compiler VLAs (Arrays mit variabler Länge) unterstützt – er muss es nicht verwenden malloc()und kann (und tut es oft) verwenden, was manchmal als “Stack” -Speicher bezeichnet wird – zB mit systemspezifischen Funktionen wie alloca() die nicht Teil von Standard-C sind. Wenn Stack verwendet wird, ist die maximale Größe eines Arrays normalerweise viel kleiner als dies mit möglich ist malloc()weil moderne Betriebssysteme Programmen ein viel kleineres Kontingent an Stack-Speicher zugestehen.

Speicher für Arrays mit variabler Länge kann eindeutig nicht statisch zugewiesen werden. Es kann jedoch auf dem Stack allokiert werden. Im Allgemeinen beinhaltet dies die Verwendung eines “Rahmenzeigers”, um den Ort des Funktionsstapelrahmens angesichts dynamisch bestimmter Änderungen des Stapelzeigers zu verfolgen.

Wenn ich versuche, Ihr Programm zu kompilieren, scheint es tatsächlich so zu sein, dass das Array mit variabler Länge optimiert wurde. Also habe ich Ihren Code geändert, um den Compiler zu zwingen, das Array tatsächlich zuzuweisen.

#include <stdio.h>
int main(int argc, char const *argv[])
{
    int n;
    scanf("%d",&n);
    int k[n];
    printf("%s %ld",k,sizeof(k));
    return 0;
}

Godbolt-Kompilierung für Arm mit gcc 6.3 (mit Arm, weil ich Arm-ASM lesen kann) kompiliert dies https://godbolt.org/g/5ZnHfa. (Kommentare von mir)

main:
        push    {fp, lr}      ; Save fp and lr on the stack
        add     fp, sp, #4    ; Create a "frame pointer" so we know where
                              ; our stack frame is even after applying a 
                              ; dynamic offset to the stack pointer.
        sub     sp, sp, #8    ; allocate 8 bytes on the stack (8 rather
                              ; than 4 due to ABI alignment
                              ; requirements)
        sub     r1, fp, #8    ; load r1 with a pointer to n
        ldr     r0, .L3       ; load pointer to format string for scanf
                              ; into r0
        bl      scanf         ; call scanf (arguments in r0 and r1)
        ldr     r2, [fp, #-8] ; load r2 with value of n
        ldr     r0, .L3+4     ; load pointer to format string for printf
                              ; into r0
        lsl     r2, r2, #2    ; multiply n by 4
        add     r3, r2, #10   ; add 10 to n*4 (not sure why it used 10,
                              ; 7 would seem sufficient)
        bic     r3, r3, #7    ; and clear the low bits so it is a
                              ; multiple of 8 (stack alignment again) 
        sub     sp, sp, r3    ; actually allocate the dynamic array on
                              ; the stack
        mov     r1, sp        ; store a pointer to the dynamic size array
                              ; in r1
        bl      printf        ; call printf (arguments in r0, r1 and r2)
        mov     r0, #0        ; set r0 to 0
        sub     sp, fp, #4    ; use the frame pointer to restore the
                              ; stack pointer
        pop     {fp, lr}      ; restore fp and lr
        bx      lr            ; return to the caller (return value in r0)
.L3:
        .word   .LC0
        .word   .LC1
.LC0:
        .ascii  "%d\000"
.LC1:
        .ascii  "%s %ld\000"

Der Speicher für dieses Konstrukt, das als “Variable-Length-Array”, VLA, bezeichnet wird, wird ähnlich wie auf dem Stapel zugewiesen alloca. Wie genau dies geschieht, hängt davon ab, welchen Compiler Sie verwenden, aber im Wesentlichen geht es darum, die Größe zu berechnen, wenn sie bekannt ist, und dann zu subtrahieren [1] die Gesamtgröße aus dem Stapelzeiger.

Du brauchst malloc und Freunde, weil diese Zuordnung “stirbt”, wenn Sie die Funktion verlassen. [And it’s not valid in standard C++]

[1] Für typische Prozessoren, die einen Stapel verwenden, der “gegen Null wächst”.

Wenn gesagt wird, dass der Compiler Speicher für Variablen bei zuweist Kompilierzeit, bedeutet dies, dass die Platzierung dieser Variablen festgelegt und in den ausführbaren Code eingebettet wird, den der Compiler generiert, und nicht, dass der Compiler Platz für sie bereitstellt, während er arbeitet. Die eigentliche dynamische Speicherallokation wird vom generierten Programm durchgeführt, wenn es läuft.