kann die Größe des Arrays zur Laufzeit in c bestimmt werden?

Wie ich weiß, muss ein Array eine bestimmte Größe haben, bevor es in c kompiliert wird.

Ich frage mich, warum dieser Code noch funktioniert?

int s;
printf("enter the array size: ");
scanf("%d",&s);

int a[s]; // Isn't s value determined at run time?

Array-Größen müssen mit ANSI 89 C bekannt sein. Die Version 99 der Spezifikation hat diese Einschränkung aufgehoben und Arrays mit variabler Größe zugelassen.

Hier ist die Dokumentation zur GNU-Version dieser Funktion

• http://www.cs.utah.edu/dept/old/texinfo/glibc-manual-0.02/library_toc.html#SEC49

Arrays mit variabler Länge sind seitdem Teil der C-Sprache C99. Aber sie wurden als optionales Feature in gemacht C11 – was bedeutet, dass eine C11-konforme Implementierung dies nicht bereitstellen muss (obwohl praktisch alle Implementierungen, die C99 unterstützen, sicherlich VLAs in C11 bereitstellen).

Sie können mithilfe des Makros prüfen, ob Ihre Implementierung keine VLAs bereitstellt __STDC_NO_VLA__ (Wenn es im C99- oder C11-Kompilierungsmodus definiert ist, unterstützt Ihre Implementierung keine VLAs).

Die Entscheidung über eine Array-Größe zur Laufzeit ist also in modernem C (>= C99) möglich, und Code wie der folgende ist in Ordnung:

int s;
printf("Enter the array size: ");
scanf("%d", &s);
int a[s];

Ein offensichtlicher Nachteil von VLAs ist, dass if s ist ziemlich groß und die Zuteilung von a könnte scheitern. Schlimmer noch, es gibt keine Möglichkeit zu überprüfen, ob die Zuweisung fehlgeschlagen ist, und Sie werden auf Laufzeitfehler (z. B. segfault) stoßen. Es ist im Wesentlichen undefiniertes Verhalten. So Sie möchten VLAs vermeiden, wenn die Arraygröße zu groß ist. Grundsätzlich sollten Sie im Zweifelsfall auf dynamische Speicherallokation setzen (siehe unten).

Ein weiteres Problem, viel weniger schwerwiegend im Vergleich zu anderen, mit VLAs ist, dass sie haben automatische Speicherdauer (auch bekannt als “Stack zugewiesen”). Wenn Sie also etwas wollen, das länger hält, dann das Bereich blockieren Wo die VLA deklariert ist, helfen VLAs nicht weiter.

Ebenfalls relevant ist, dass kein VLA drin ist C89,. Daher ist die Verwendung der dynamischen Speicherzuweisung der einzige Weg. Obwohl es einige nicht standardmäßige Erweiterungen gab, wie z alloca() das VLA ähnlich ist und die gleichen Nachteile wie VLAs hat).

int s;
printf("enter the array size: ");
scanf("%d",&s);
int *a = malloc(s * sizeof *a);
...
free(a);

Wenn Sie ein Array mit dynamischer Größe zuweisen müssen, müssen Sie es mit malloc() aus dem Heap holen.

int *a = malloc(sizeof(int) * s)

Du verwechselst hier zwei Dinge.

1) Bestimmen der Größe eines bereits zugewiesenen Arrays (was Ihr Titel impliziert): divide sizeof() für die Summe um die Größe eines (z. B. ersten) Elements:

 sizeof(a)/sizeof(a[0])

2) Speicher dynamisch zuweisen, wenn Ihre Frage fragt:

 int *a = (int*)malloc( s * sizeof(int) );

Dieser Code wird von der C99-Sprachspezifikation unterstützt. Dieser Code wird auch vom GCC-Compiler im C89/90-Modus als Erweiterung unterstützt.

Die Antwort auf Ihre Frage (warum es “funktioniert”) hängt also davon ab, wie Sie es kompilieren. Im Allgemeinen wird dies nicht einmal von einem C89/90-Compiler kompiliert.

Es ist wichtig zu verstehen, wie Speicher von einem Compiler einer Variablen zugewiesen wird, um Ihre Frage richtig zu beantworten. Es gibt zwei Modi, in denen der Speicher einer Variablen zugewiesen wird, er kann sich auf einem Heap oder auf einem Stack befinden. Speicher auf einem Heap wird dynamisch zugewiesen. So kann einer Variablen, der Speicher auf einem Heap zugewiesen wird, während der Laufzeit ihre Größe gegeben werden.

Die Arrays im Fall von C erhalten Speicher auf einem Stack. Um Speicher auf einem Stapel bereitzustellen, sollte die Größe des Speichers dem Compiler während der Kompilierzeit bekannt sein. Damit zur Laufzeit so viel Speicher für die Variable auf dem Stack reserviert werden kann. Aus diesem Grund können Sie die Größe des Arrays zur Laufzeit nicht bestimmen, soweit es die C-Sprache betrifft.