Variable Length Array - Versionsgeschichte

Thomas Dresler: Anpassung

2023-12-17T21:53:50Z

Anpassung

← Nächstältere Version		Version vom 17. Dezember 2023, 23:53 Uhr
Zeile 11:		Zeile 11:
	</syntaxhighlight>		</syntaxhighlight>
	Dabei ist zu beachten, dass VLAs nicht initialisiert werden können (Einschränkung in den C-Standards, vgl. §6.7.8 respektive §6.7.9)<ref name="c99">ISO/IEC9899-1999 Programming Languages -- C</ref><ref name="c11">ISO/IEC9899-2011 Programming Languages -- C</ref> und die Größe nur einmalig bei der Definition festgelegt werden kann. Darüber hinaus können VLAs nur innerhalb von Funktionen angelegt werden. Außerhalb von Funktionen müssen Feldgrößen auch in C99 zum Zeitpunkt der Übersetzung bekannt sein. Der Gültigkeitsbereich eines VLAs beginnt wie bei allen lokalen Variablen mit dessen Definition und umfasst den umschließenden Block.		Dabei ist zu beachten, dass VLAs nicht initialisiert werden können (Einschränkung in den C-Standards, vgl. §6.7.8 respektive §6.7.9)<ref name="c99">ISO/IEC9899-1999 Programming Languages -- C</ref><ref name="c11">ISO/IEC9899-2011 Programming Languages -- C</ref> und die Größe nur einmalig bei der Definition festgelegt werden kann. Darüber hinaus können VLAs nur innerhalb von Funktionen angelegt werden. Außerhalb von Funktionen müssen Feldgrößen auch in C99 zum Zeitpunkt der Übersetzung bekannt sein. Der Gültigkeitsbereich eines VLAs beginnt wie bei allen lokalen Variablen mit dessen Definition und umfasst den umschließenden Block.
	Ein großer Vorteil von VLAs ist, dass für temporäre Felder der Aufruf von <code>malloc()</code> und <code>free()</code> wegfällt; der Compiler übernimmt die Anforderung und Freigabe des erforderlichen Speichers.<ref>Randy Meyers: ''The New C: Why Variable Length Arrays?'', Dr. Dobb’s, 1. October 2001, Online: http://www.drdobbs.com/the-new-cwhy-variable-length-arrays/184401444 . Abgerufen am 12. August 2014</ref> Da in der Regel VLAs auf dem [[Stapelspeicher\|Stack]] und nicht auf dem [[Dynamischer Speicher\|Heap]] angelegt werden, ist die Speicheranforderung auch erheblich effizienter.<ref name="Jones08"> Derek M. Jones: ''The New C Standard - An Economic and Cultural Commentary'', Addison-Wesley Professional 2008, auch Online: http://www.coding-guidelines.com/cbook/cbook1_2.pdf . Abgerufen am 12. August 2014</ref> Außerdem kann auf feste Array-Größen, die häufig Ursache für Softwarefehler sind, verzichtet werden.<ref>[https://www.securecoding.cert.org/confluence/display/c/VOID+STR35-C.+Do+not+copy+data+from+an+unbounded+source+to+a+fixed-length+array Webseite des CERT Secure Coding Standard STR35-C]. Abgerufen am 14. Februar 2016</ref>		Ein großer Vorteil von VLAs ist, dass für temporäre Felder der Aufruf von <code>malloc()</code> und <code>free()</code> wegfällt; der Compiler übernimmt die Anforderung und Freigabe des erforderlichen Speichers.<ref>Randy Meyers: ''The New C: Why Variable Length Arrays?'', Dr. Dobb’s, 1. October 2001, Online: http://www.drdobbs.com/the-new-cwhy-variable-length-arrays/184401444 . Abgerufen am 12. August 2014</ref> Da in der Regel VLAs auf dem [[Stapelspeicher\|Stack]] und nicht auf dem [[Dynamischer Speicher\|Heap]] angelegt werden, ist die Speicheranforderung auch erheblich effizienter.<ref name="Jones08"> Derek M. Jones: ''The New C Standard - An Economic and Cultural Commentary'', Addison-Wesley Professional 2008, auch Online: [http://www.coding-guidelines.com/cbook/cbook1_2.pdf PDF]. Abgerufen am 12. August 2014</ref> Außerdem kann auf feste Array-Größen, die häufig Ursache für Softwarefehler sind, verzichtet werden.<ref>[https://www.securecoding.cert.org/confluence/display/c/VOID+STR35-C.+Do+not+copy+data+from+an+unbounded+source+to+a+fixed-length+array Webseite des CERT Secure Coding Standard STR35-C]. Abgerufen am 14. Februar 2016</ref>
	=== Beispiel ===		=== Beispiel ===
	Das folgende Beispiel zeigt eine typische Anwendung von VLAs.		Das folgende Beispiel zeigt eine typische Anwendung von VLAs.

Aka: Tippfehler entfernt, Kleinkram

2023-10-17T21:13:52Z

Tippfehler entfernt, Kleinkram

← Nächstältere Version		Version vom 17. Oktober 2023, 23:13 Uhr
Zeile 1:		Zeile 1:
	Ein ''' Variable Length Array (VLA)''' ist ein [[Datentyp]] der [[C (Programmiersprache)\|Programmiersprache C]]. Es handelt sich um ein [[Feld (Datentyp)\|Feld]] ({{EnS\|''Array''}}), dessen Größe erst zur Laufzeit, d. h. variabel, festgelegt wird.		Ein ''' Variable Length Array (VLA)''' ist ein [[Datentyp]] der [[C (Programmiersprache)\|Programmiersprache C]]. Es handelt sich um ein [[Feld (Datentyp)\|Feld]] ({{EnS\|''Array''}}), dessen Größe erst zur Laufzeit, d. h. variabel, festgelegt wird.
	== Funktionsweise und Anwendung ==		== Funktionsweise und Anwendung ==
	Im Gegensatz zum klassischen [[Feld (Datentyp)#Standard-Feld\|Vektor]], dessen Größe zum Zeitpunkt der Übersetzung festgelegt wird,<ref>Kernighan/Ritchie: ''Programmieren in C - Mit dem C-Referenz Manual in deutscher Sprache'', Hanser 1990, 2. Auflage</ref> führt der [[Varianten der Programmiersprache C#C99\|C99]]-Standard das Konzept variabler Array-Größen ein. Bei der Definition eines Feldes kann dessen Größe durch einen beliebigen ganzzahligen Ausdruck bestimmt werden.		Im Gegensatz zum klassischen [[Feld (Datentyp)#Standard-Feld\|Vektor]], dessen Größe zum Zeitpunkt der Übersetzung festgelegt wird,<ref>Kernighan/Ritchie: ''Programmieren in C - Mit dem C-Referenz Manual in deutscher Sprache'', Hanser 1990, 2. Auflage</ref> führt der [[Varianten der Programmiersprache C#C99\|C99]]-Standard das Konzept variabler Array-Größen ein. Bei der Definition eines Feldes kann dessen Größe durch einen beliebigen ganzzahligen Ausdruck bestimmt werden.
	; Beispiel Vektor und VLA		; Beispiel Vektor und VLA
	<syntaxhighlight lang="c">		<syntaxhighlight lang="c">
	void foo(unsigned int len) {		void foo(unsigned int len) {
	int vector[3] = { 14, 4, 7 }; /* initialisiertes Feld fixer Größe */		int vector[3] = { 14, 4, 7 }; /* initialisiertes Feld fixer Größe */
	int vla[len]; /* VLA entsprechend dem Parameter len */		int vla[len]; /* VLA entsprechend dem Parameter len */
Zeile 10:		Zeile 10:
	}		}
	</syntaxhighlight>		</syntaxhighlight>
	Dabei ist zu beachten, dass VLAs nicht initialisiert werden können (Einschränkung in den C-Standards, vgl. §6.7.8 respektive §6.7.9)<ref name="c99">ISO/IEC9899-1999 Programming Languages -- C</ref><ref name="c11">ISO/IEC9899-2011 Programming Languages -- C</ref> und die Größe nur einmalig bei der Definition festgelegt werden kann. Darüber hinaus können VLAs nur innerhalb von Funktionen angelegt werden. Außerhalb von Funktionen müssen Feldgrößen auch in C99 zum Zeitpunkt der Übersetzung bekannt sein. Der Gültigkeitsbereich eines VLAs beginnt wie bei allen lokalen Variablen mit dessen Definition und umfasst den umschließenden Block.		Dabei ist zu beachten, dass VLAs nicht initialisiert werden können (Einschränkung in den C-Standards, vgl. §6.7.8 respektive §6.7.9)<ref name="c99">ISO/IEC9899-1999 Programming Languages -- C</ref><ref name="c11">ISO/IEC9899-2011 Programming Languages -- C</ref> und die Größe nur einmalig bei der Definition festgelegt werden kann. Darüber hinaus können VLAs nur innerhalb von Funktionen angelegt werden. Außerhalb von Funktionen müssen Feldgrößen auch in C99 zum Zeitpunkt der Übersetzung bekannt sein. Der Gültigkeitsbereich eines VLAs beginnt wie bei allen lokalen Variablen mit dessen Definition und umfasst den umschließenden Block.
	Ein großer Vorteil von VLAs ist, dass für temporäre Felder der Aufruf von <code>malloc()</code> und <code>free()</code> wegfällt; der Compiler übernimmt die Anforderung und Freigabe des erforderlichen Speichers.<ref>Randy Meyers: ''The New C: Why Variable Length Arrays?'', Dr. ~~Dobb's~~, 1. October 2001, Online: http://www.drdobbs.com/the-new-cwhy-variable-length-arrays/184401444 . Abgerufen am 12. August 2014</ref> Da in der Regel VLAs auf dem [[Stapelspeicher\|Stack]] und nicht auf dem [[Dynamischer Speicher\|Heap]] angelegt werden, ist die Speicheranforderung auch erheblich effizienter.<ref name="Jones08"> Derek M. Jones: ''The New C Standard - An Economic and Cultural Commentary'', Addison-Wesley Professional 2008, auch Online: http://www.coding-guidelines.com/cbook/cbook1_2.pdf . Abgerufen am 12. August 2014</ref> Außerdem kann auf feste Array-Größen, die häufig Ursache für Softwarefehler sind, verzichtet werden.<ref>[https://www.securecoding.cert.org/confluence/display/c/VOID+STR35-C.+Do+not+copy+data+from+an+unbounded+source+to+a+fixed-length+array Webseite des CERT Secure Coding Standard STR35-C]. Abgerufen am 14. Februar 2016</ref>		Ein großer Vorteil von VLAs ist, dass für temporäre Felder der Aufruf von <code>malloc()</code> und <code>free()</code> wegfällt; der Compiler übernimmt die Anforderung und Freigabe des erforderlichen Speichers.<ref>Randy Meyers: ''The New C: Why Variable Length Arrays?'', Dr. Dobb’s, 1. October 2001, Online: http://www.drdobbs.com/the-new-cwhy-variable-length-arrays/184401444 . Abgerufen am 12. August 2014</ref> Da in der Regel VLAs auf dem [[Stapelspeicher\|Stack]] und nicht auf dem [[Dynamischer Speicher\|Heap]] angelegt werden, ist die Speicheranforderung auch erheblich effizienter.<ref name="Jones08"> Derek M. Jones: ''The New C Standard - An Economic and Cultural Commentary'', Addison-Wesley Professional 2008, auch Online: http://www.coding-guidelines.com/cbook/cbook1_2.pdf . Abgerufen am 12. August 2014</ref> Außerdem kann auf feste Array-Größen, die häufig Ursache für Softwarefehler sind, verzichtet werden.<ref>[https://www.securecoding.cert.org/confluence/display/c/VOID+STR35-C.+Do+not+copy+data+from+an+unbounded+source+to+a+fixed-length+array Webseite des CERT Secure Coding Standard STR35-C]. Abgerufen am 14. Februar 2016</ref>
	=== Beispiel ===		=== Beispiel ===
	Das folgende Beispiel zeigt eine typische Anwendung von VLAs.		Das folgende Beispiel zeigt eine typische Anwendung von VLAs.
Zeile 20:		Zeile 20:

	char* reverse_string(char* in_out){		char* reverse_string(char* in_out){
	unsigned int len = strlen(in_out);		unsigned int len = strlen(in_out);
	char tmp[len + 1]; // VLA für String und Nullterminierung		char tmp[len + 1]; // VLA für String und Nullterminierung
	strcpy(tmp, in_out);		strcpy(tmp, in_out);
Zeile 36:		Zeile 36:
	</syntaxhighlight>		</syntaxhighlight>
	Die Funktion <code>reverse_string()</code> verwendet die lokale Variable <code>tmp</code> als VLA; dieses nimmt den übergebenen String auf. Im Anschluss wird der String in umgekehrter Reihenfolge wieder in den Ein-/Ausgabeparameter <code>in_out</code> zurückgeschrieben.		Die Funktion <code>reverse_string()</code> verwendet die lokale Variable <code>tmp</code> als VLA; dieses nimmt den übergebenen String auf. Im Anschluss wird der String in umgekehrter Reihenfolge wieder in den Ein-/Ausgabeparameter <code>in_out</code> zurückgeschrieben.
	Selbstverständlich lassen sich auch mehrdimensionale VLAs generieren, wie das Beispiel aus dem C11-Standard zeigt <code>int a[n][6][m];</code><ref name="c11" />		Selbstverständlich lassen sich auch mehrdimensionale VLAs generieren, wie das Beispiel aus dem C11-Standard zeigt <code>int a[n][6][m];</code><ref name="c11" />
	=== Auswirkungen ===		=== Auswirkungen ===
	Der Operator <code>sizeof</code> muss bei VLAs zur Laufzeit ausgewertet werden, d. h. für jedes VLA muss Meta-Information zur Laufzeit generiert werden.<ref name="Jones08" /> Die Definition von VLAs darf nicht übersprungen werden, hier schränken die C-Standards die Benutzung von <code>goto</code> ein.<ref name="c99" /><ref name="c11" />		Der Operator <code>sizeof</code> muss bei VLAs zur Laufzeit ausgewertet werden, d. h. für jedes VLA muss Meta-Information zur Laufzeit generiert werden.<ref name="Jones08" /> Die Definition von VLAs darf nicht übersprungen werden, hier schränken die C-Standards die Benutzung von <code>goto</code> ein.<ref name="c99" /><ref name="c11" />
	Im Gegensatz zu C99 ist die Implementierung von VLAs bei C11-konformen Compilern freigestellt. Die Verfügbarkeit kann über das Define <code>__STDC_NO_VLA__</code> abgefragt werden, das den Integerwert 1 aufweist, sofern VLAs nicht unterstützt werden.<ref name="c11" />		Im Gegensatz zu C99 ist die Implementierung von VLAs bei C11-konformen Compilern freigestellt. Die Verfügbarkeit kann über das Define <code>__STDC_NO_VLA__</code> abgefragt werden, das den Integerwert 1 aufweist, sofern VLAs nicht unterstützt werden.<ref name="c11" />

Aka: /* Auswirkungen */ Abkürzung korrigiert

2018-04-15T08:49:15Z

Auswirkungen: Abkürzung korrigiert

← Nächstältere Version		Version vom 15. April 2018, 10:49 Uhr
Zeile 38:		Zeile 38:
	Selbstverständlich lassen sich auch mehrdimensionale VLAs generieren, wie das Beispiel aus dem C11-Standard zeigt <code>int a[n][6][m];</code><ref name="c11" />		Selbstverständlich lassen sich auch mehrdimensionale VLAs generieren, wie das Beispiel aus dem C11-Standard zeigt <code>int a[n][6][m];</code><ref name="c11" />
	=== Auswirkungen ===		=== Auswirkungen ===
	Der Operator <code>sizeof</code> muss bei VLAs zur Laufzeit ausgewertet werden, d.h. für jedes VLA muss Meta-Information zur Laufzeit generiert werden.<ref name="Jones08" /> Die Definition von VLAs darf nicht übersprungen werden, hier schränken die C-Standards die Benutzung von <code>goto</code> ein.<ref name="c99" /><ref name="c11" />		Der Operator <code>sizeof</code> muss bei VLAs zur Laufzeit ausgewertet werden, d. h. für jedes VLA muss Meta-Information zur Laufzeit generiert werden.<ref name="Jones08" /> Die Definition von VLAs darf nicht übersprungen werden, hier schränken die C-Standards die Benutzung von <code>goto</code> ein.<ref name="c99" /><ref name="c11" />
	Im Gegensatz zu C99 ist die Implementierung von VLAs bei C11-konformen Compilern freigestellt. Die Verfügbarkeit kann über das Define <code>__STDC_NO_VLA__</code> abgefragt werden, das den Integerwert 1 aufweist, sofern VLAs nicht unterstützt werden.<ref name="c11" />		Im Gegensatz zu C99 ist die Implementierung von VLAs bei C11-konformen Compilern freigestellt. Die Verfügbarkeit kann über das Define <code>__STDC_NO_VLA__</code> abgefragt werden, das den Integerwert 1 aufweist, sofern VLAs nicht unterstützt werden.<ref name="c11" />

2003:DF:4BE8:500:8DE4:43A2:A26E:3257: Die Übersetzung von „Heap“ mit „Halde“ ist unsinnig → entfernt.

2017-11-30T19:07:19Z

Die Übersetzung von „Heap“ mit „Halde“ ist unsinnig → entfernt.

← Nächstältere Version		Version vom 30. November 2017, 21:07 Uhr
Zeile 11:		Zeile 11:
	</syntaxhighlight>		</syntaxhighlight>
	Dabei ist zu beachten, dass VLAs nicht initialisiert werden können (Einschränkung in den C-Standards, vgl. §6.7.8 respektive §6.7.9)<ref name="c99">ISO/IEC9899-1999 Programming Languages -- C</ref><ref name="c11">ISO/IEC9899-2011 Programming Languages -- C</ref> und die Größe nur einmalig bei der Definition festgelegt werden kann. Darüber hinaus können VLAs nur innerhalb von Funktionen angelegt werden. Außerhalb von Funktionen müssen Feldgrößen auch in C99 zum Zeitpunkt der Übersetzung bekannt sein. Der Gültigkeitsbereich eines VLAs beginnt wie bei allen lokalen Variablen mit dessen Definition und umfasst den umschließenden Block.		Dabei ist zu beachten, dass VLAs nicht initialisiert werden können (Einschränkung in den C-Standards, vgl. §6.7.8 respektive §6.7.9)<ref name="c99">ISO/IEC9899-1999 Programming Languages -- C</ref><ref name="c11">ISO/IEC9899-2011 Programming Languages -- C</ref> und die Größe nur einmalig bei der Definition festgelegt werden kann. Darüber hinaus können VLAs nur innerhalb von Funktionen angelegt werden. Außerhalb von Funktionen müssen Feldgrößen auch in C99 zum Zeitpunkt der Übersetzung bekannt sein. Der Gültigkeitsbereich eines VLAs beginnt wie bei allen lokalen Variablen mit dessen Definition und umfasst den umschließenden Block.
	Ein großer Vorteil von VLAs ist, dass für temporäre Felder der Aufruf von <code>malloc()</code> und <code>free()</code> wegfällt; der Compiler übernimmt die Anforderung und Freigabe des erforderlichen Speichers.<ref>Randy Meyers: ''The New C: Why Variable Length Arrays?'', Dr. Dobb's, 1. October 2001, Online: http://www.drdobbs.com/the-new-cwhy-variable-length-arrays/184401444 . Abgerufen am 12. August 2014</ref> Da in der Regel VLAs auf dem [[Stapelspeicher\|Stack]] und nicht auf ~~der~~ [[Dynamischer Speicher\|~~Halde (~~Heap)]] angelegt werden, ist die Speicheranforderung auch erheblich effizienter.<ref name="Jones08"> Derek M. Jones: ''The New C Standard - An Economic and Cultural Commentary'', Addison-Wesley Professional 2008, auch Online: http://www.coding-guidelines.com/cbook/cbook1_2.pdf . Abgerufen am 12. August 2014</ref> Außerdem kann auf feste Array-Größen, die häufig Ursache für Softwarefehler sind, verzichtet werden.<ref>[https://www.securecoding.cert.org/confluence/display/c/VOID+STR35-C.+Do+not+copy+data+from+an+unbounded+source+to+a+fixed-length+array Webseite des CERT Secure Coding Standard STR35-C]. Abgerufen am 14. Februar 2016</ref>		Ein großer Vorteil von VLAs ist, dass für temporäre Felder der Aufruf von <code>malloc()</code> und <code>free()</code> wegfällt; der Compiler übernimmt die Anforderung und Freigabe des erforderlichen Speichers.<ref>Randy Meyers: ''The New C: Why Variable Length Arrays?'', Dr. Dobb's, 1. October 2001, Online: http://www.drdobbs.com/the-new-cwhy-variable-length-arrays/184401444 . Abgerufen am 12. August 2014</ref> Da in der Regel VLAs auf dem [[Stapelspeicher\|Stack]] und nicht auf dem [[Dynamischer Speicher\|Heap]] angelegt werden, ist die Speicheranforderung auch erheblich effizienter.<ref name="Jones08"> Derek M. Jones: ''The New C Standard - An Economic and Cultural Commentary'', Addison-Wesley Professional 2008, auch Online: http://www.coding-guidelines.com/cbook/cbook1_2.pdf . Abgerufen am 12. August 2014</ref> Außerdem kann auf feste Array-Größen, die häufig Ursache für Softwarefehler sind, verzichtet werden.<ref>[https://www.securecoding.cert.org/confluence/display/c/VOID+STR35-C.+Do+not+copy+data+from+an+unbounded+source+to+a+fixed-length+array Webseite des CERT Secure Coding Standard STR35-C]. Abgerufen am 14. Februar 2016</ref>
	=== Beispiel ===		=== Beispiel ===
	Das folgende Beispiel zeigt eine typische Anwendung von VLAs.		Das folgende Beispiel zeigt eine typische Anwendung von VLAs.

2003:75:4F60:3BB5:2C89:18DF:71B7:73CD: /* Funktionsweise und Anwendung */Tippfehler korrigiert

2017-09-06T16:00:40Z

Funktionsweise und Anwendung: Tippfehler korrigiert

← Nächstältere Version		Version vom 6. September 2017, 18:00 Uhr
Zeile 36:		Zeile 36:
	</syntaxhighlight>		</syntaxhighlight>
	Die Funktion <code>reverse_string()</code> verwendet die lokale Variable <code>tmp</code> als VLA; dieses nimmt den übergebenen String auf. Im Anschluss wird der String in umgekehrter Reihenfolge wieder in den Ein-/Ausgabeparameter <code>in_out</code> zurückgeschrieben.		Die Funktion <code>reverse_string()</code> verwendet die lokale Variable <code>tmp</code> als VLA; dieses nimmt den übergebenen String auf. Im Anschluss wird der String in umgekehrter Reihenfolge wieder in den Ein-/Ausgabeparameter <code>in_out</code> zurückgeschrieben.
	Selbstverständlich lassen sich auch mehrdimensionale VLAs ~~generierten~~, wie das Beispiel aus dem C11-Standard zeigt <code>int a[n][6][m];</code><ref name="c11" />		Selbstverständlich lassen sich auch mehrdimensionale VLAs generieren, wie das Beispiel aus dem C11-Standard zeigt <code>int a[n][6][m];</code><ref name="c11" />
	=== Auswirkungen ===		=== Auswirkungen ===
	Der Operator <code>sizeof</code> muss bei VLAs zur Laufzeit ausgewertet werden, d.h. für jedes VLA muss Meta-Information zur Laufzeit generiert werden.<ref name="Jones08" /> Die Definition von VLAs darf nicht übersprungen werden, hier schränken die C-Standards die Benutzung von <code>goto</code> ein.<ref name="c99" /><ref name="c11" />		Der Operator <code>sizeof</code> muss bei VLAs zur Laufzeit ausgewertet werden, d.h. für jedes VLA muss Meta-Information zur Laufzeit generiert werden.<ref name="Jones08" /> Die Definition von VLAs darf nicht übersprungen werden, hier schränken die C-Standards die Benutzung von <code>goto</code> ein.<ref name="c99" /><ref name="c11" />

78.54.133.207: /* Abgrenzung zu anderen Programmiersprachen */

2016-09-04T14:37:28Z

Abgrenzung zu anderen Programmiersprachen

← Nächstältere Version		Version vom 4. September 2016, 16:37 Uhr
Zeile 42:		Zeile 42:

	== Abgrenzung zu anderen Programmiersprachen ==		== Abgrenzung zu anderen Programmiersprachen ==
	VLAs sind C-spezifisch und werden nicht vom C++-Standard übernommen. [[C++]] bietet Container-Klassen, die variable Felder ermöglichen. Die Programmiersprachen [[APL (Programmiersprache)\|APL]] und [[Perl (Programmiersprache)\|Perl]] unterstützen beispielsweise Felder, ~~dessen~~ Größe zur Laufzeit verändert werden ~~können~~.<ref name="Jones08" /> Arrays in [[Java (Programmiersprache)\|Java]] haben eine feste Größe. Da sie dynamisch angelegt werden, können wie bei VLAs die Größen zur Laufzeit festgelegt werden.		VLAs sind C-spezifisch und werden nicht vom C++-Standard übernommen. [[C++]] bietet Container-Klassen, die variable Felder ermöglichen. Die Programmiersprachen [[APL (Programmiersprache)\|APL]] und [[Perl (Programmiersprache)\|Perl]] unterstützen beispielsweise Felder, deren Größe zur Laufzeit verändert werden kann.<ref name="Jones08" /> Arrays in [[Java (Programmiersprache)\|Java]] haben eine feste Größe. Da sie dynamisch angelegt werden, können wie bei VLAs die Größen zur Laufzeit festgelegt werden.

	== Einzelnachweise ==		== Einzelnachweise ==

Ajv39: Weblink aktualisiert

2016-02-14T21:18:45Z

Weblink aktualisiert

← Nächstältere Version		Version vom 14. Februar 2016, 23:18 Uhr
Zeile 11:		Zeile 11:
	</syntaxhighlight>		</syntaxhighlight>
	Dabei ist zu beachten, dass VLAs nicht initialisiert werden können (Einschränkung in den C-Standards, vgl. §6.7.8 respektive §6.7.9)<ref name="c99">ISO/IEC9899-1999 Programming Languages -- C</ref><ref name="c11">ISO/IEC9899-2011 Programming Languages -- C</ref> und die Größe nur einmalig bei der Definition festgelegt werden kann. Darüber hinaus können VLAs nur innerhalb von Funktionen angelegt werden. Außerhalb von Funktionen müssen Feldgrößen auch in C99 zum Zeitpunkt der Übersetzung bekannt sein. Der Gültigkeitsbereich eines VLAs beginnt wie bei allen lokalen Variablen mit dessen Definition und umfasst den umschließenden Block.		Dabei ist zu beachten, dass VLAs nicht initialisiert werden können (Einschränkung in den C-Standards, vgl. §6.7.8 respektive §6.7.9)<ref name="c99">ISO/IEC9899-1999 Programming Languages -- C</ref><ref name="c11">ISO/IEC9899-2011 Programming Languages -- C</ref> und die Größe nur einmalig bei der Definition festgelegt werden kann. Darüber hinaus können VLAs nur innerhalb von Funktionen angelegt werden. Außerhalb von Funktionen müssen Feldgrößen auch in C99 zum Zeitpunkt der Übersetzung bekannt sein. Der Gültigkeitsbereich eines VLAs beginnt wie bei allen lokalen Variablen mit dessen Definition und umfasst den umschließenden Block.
	Ein großer Vorteil von VLAs ist, dass für temporäre Felder der Aufruf von <code>malloc()</code> und <code>free()</code> wegfällt; der Compiler übernimmt die Anforderung und Freigabe des erforderlichen Speichers.<ref>Randy Meyers: ''The New C: Why Variable Length Arrays?'', Dr. Dobb's, 1. October 2001, Online: http://www.drdobbs.com/the-new-cwhy-variable-length-arrays/184401444 . Abgerufen am 12. August 2014</ref> Da in der Regel VLAs auf dem [[Stapelspeicher\|Stack]] und nicht auf der [[Dynamischer Speicher\|Halde (Heap)]] angelegt werden, ist die Speicheranforderung auch erheblich effizienter.<ref name="Jones08"> Derek M. Jones: ''The New C Standard - An Economic and Cultural Commentary'', Addison-Wesley Professional 2008, auch Online: http://www.coding-guidelines.com/cbook/cbook1_2.pdf . Abgerufen am 12. August 2014</ref> Außerdem kann auf feste Array-Größen, die häufig Ursache für Softwarefehler sind, verzichtet werden.<ref>[https://www.securecoding.cert.org/confluence/display/~~seccode~~/VOID+STR35-C.+Do+not+copy+data+from+an+unbounded+source+to+a+fixed-length+array Webseite des CERT Secure Coding Standard STR35-C]. Abgerufen am 12. ~~August~~ ~~2014~~</ref>		Ein großer Vorteil von VLAs ist, dass für temporäre Felder der Aufruf von <code>malloc()</code> und <code>free()</code> wegfällt; der Compiler übernimmt die Anforderung und Freigabe des erforderlichen Speichers.<ref>Randy Meyers: ''The New C: Why Variable Length Arrays?'', Dr. Dobb's, 1. October 2001, Online: http://www.drdobbs.com/the-new-cwhy-variable-length-arrays/184401444 . Abgerufen am 12. August 2014</ref> Da in der Regel VLAs auf dem [[Stapelspeicher\|Stack]] und nicht auf der [[Dynamischer Speicher\|Halde (Heap)]] angelegt werden, ist die Speicheranforderung auch erheblich effizienter.<ref name="Jones08"> Derek M. Jones: ''The New C Standard - An Economic and Cultural Commentary'', Addison-Wesley Professional 2008, auch Online: http://www.coding-guidelines.com/cbook/cbook1_2.pdf . Abgerufen am 12. August 2014</ref> Außerdem kann auf feste Array-Größen, die häufig Ursache für Softwarefehler sind, verzichtet werden.<ref>[https://www.securecoding.cert.org/confluence/display/c/VOID+STR35-C.+Do+not+copy+data+from+an+unbounded+source+to+a+fixed-length+array Webseite des CERT Secure Coding Standard STR35-C]. Abgerufen am 14. Februar 2016</ref>
	=== Beispiel ===		=== Beispiel ===
	Das folgende Beispiel zeigt eine typische Anwendung von VLAs.		Das folgende Beispiel zeigt eine typische Anwendung von VLAs.

Ajv39: kl

2014-09-20T17:42:21Z

← Nächstältere Version		Version vom 20. September 2014, 19:42 Uhr
Zeile 1:		Zeile 1:
	Ein ''' Variable Length Array (VLA)''' ist ein [[Datentyp]] der [[C (Programmiersprache)\|Programmiersprache C]]. Es handelt sich um ein [[Feld (Datentyp)\|Feld]] ({{EnS\|''Array''}}), dessen Größe erst zur Laufzeit, d.h. variabel, festgelegt wird.		Ein ''' Variable Length Array (VLA)''' ist ein [[Datentyp]] der [[C (Programmiersprache)\|Programmiersprache C]]. Es handelt sich um ein [[Feld (Datentyp)\|Feld]] ({{EnS\|''Array''}}), dessen Größe erst zur Laufzeit, d. h. variabel, festgelegt wird.
	== Funktionsweise und Anwendung ==		== Funktionsweise und Anwendung ==
	Im Gegensatz zum klassischen [[Feld (Datentyp)#Standard-Feld\|Vektor]], dessen Größe zum Zeitpunkt der Übersetzung festgelegt wird<ref>Kernighan/Ritchie: ''Programmieren in C - Mit dem C-Referenz Manual in deutscher Sprache'', Hanser 1990, 2. Auflage</ref>, führt der [[Varianten der Programmiersprache C#C99\|C99]]-Standard das Konzept variabler Array-Größen ein. Bei der Definition eines Feldes kann dessen Größe durch einen beliebigen ganzzahligen Ausdruck bestimmt werden.		Im Gegensatz zum klassischen [[Feld (Datentyp)#Standard-Feld\|Vektor]], dessen Größe zum Zeitpunkt der Übersetzung festgelegt wird,<ref>Kernighan/Ritchie: ''Programmieren in C - Mit dem C-Referenz Manual in deutscher Sprache'', Hanser 1990, 2. Auflage</ref> führt der [[Varianten der Programmiersprache C#C99\|C99]]-Standard das Konzept variabler Array-Größen ein. Bei der Definition eines Feldes kann dessen Größe durch einen beliebigen ganzzahligen Ausdruck bestimmt werden.
	; Beispiel Vektor und VLA		; Beispiel Vektor und VLA
	<syntaxhighlight lang="c">		<syntaxhighlight lang="c">
Zeile 38:		Zeile 38:
	Selbstverständlich lassen sich auch mehrdimensionale VLAs generierten, wie das Beispiel aus dem C11-Standard zeigt <code>int a[n][6][m];</code><ref name="c11" />		Selbstverständlich lassen sich auch mehrdimensionale VLAs generierten, wie das Beispiel aus dem C11-Standard zeigt <code>int a[n][6][m];</code><ref name="c11" />
	=== Auswirkungen ===		=== Auswirkungen ===
	Der Operator <code>sizeof</code> muss bei VLAs zur Laufzeit ausgewertet werden, d.h. für jedes VLA muss Meta-Information zur Laufzeit generiert werden <ref name="Jones08" />. Die Definition von VLAs darf nicht übersprungen werden, hier schränken die C-Standards die Benutzung von <code>goto</code> ein.<ref name="c99" /><ref name="c11" />		Der Operator <code>sizeof</code> muss bei VLAs zur Laufzeit ausgewertet werden, d.h. für jedes VLA muss Meta-Information zur Laufzeit generiert werden.<ref name="Jones08" /> Die Definition von VLAs darf nicht übersprungen werden, hier schränken die C-Standards die Benutzung von <code>goto</code> ein.<ref name="c99" /><ref name="c11" />
	Im Gegensatz zu C99 ist die Implementierung von VLAs bei C11-konformen Compilern freigestellt. Die Verfügbarkeit kann über das Define <code>__STDC_NO_VLA__</code> abgefragt werden, das den Integerwert 1 aufweist, sofern VLAs nicht unterstützt werden.<ref name="c11" />		Im Gegensatz zu C99 ist die Implementierung von VLAs bei C11-konformen Compilern freigestellt. Die Verfügbarkeit kann über das Define <code>__STDC_NO_VLA__</code> abgefragt werden, das den Integerwert 1 aufweist, sofern VLAs nicht unterstützt werden.<ref name="c11" />

Ajv39: Tippfehler entfernt

2014-09-20T17:38:36Z

Tippfehler entfernt

← Nächstältere Version		Version vom 20. September 2014, 19:38 Uhr
Zeile 6:		Zeile 6:
	void foo(unsigned int len) {		void foo(unsigned int len) {
	int vector[3] = { 14, 4, 7 }; /* initialisiertes Feld fixer Größe */		int vector[3] = { 14, 4, 7 }; /* initialisiertes Feld fixer Größe */
	int vla[len]; /* VLA ~~entprechend~~ dem Parameter len */		int vla[len]; /* VLA entsprechend dem Parameter len */
	...		...
	}		}
	</syntaxhighlight>		</syntaxhighlight>
	Dabei ist zu beachten, dass VLAs nicht initialisiert werden können (Einschränkung in den C-Standards, vgl. §6.7.8 respektive §6.7.9)<ref name="c99">ISO/IEC9899-1999 Programming Languages -- C</ref><ref name="c11">ISO/IEC9899-2011 Programming Languages -- C</ref> und die Größe nur einmalig bei der Definition festgelegt werden kann. Darüber hinaus können VLAs nur innerhalb von Funktionen angelegt werden. Außerhalb von Funktionen müssen Feldgrößen auch in C99 zum Zeitpunkt der Übersetzung bekannt sein. Der Gültigkeitsbereich eines VLAs beginnt wie bei allen lokalen Variablen mit dessen Definition und umfasst den umschließenden Block.		Dabei ist zu beachten, dass VLAs nicht initialisiert werden können (Einschränkung in den C-Standards, vgl. §6.7.8 respektive §6.7.9)<ref name="c99">ISO/IEC9899-1999 Programming Languages -- C</ref><ref name="c11">ISO/IEC9899-2011 Programming Languages -- C</ref> und die Größe nur einmalig bei der Definition festgelegt werden kann. Darüber hinaus können VLAs nur innerhalb von Funktionen angelegt werden. Außerhalb von Funktionen müssen Feldgrößen auch in C99 zum Zeitpunkt der Übersetzung bekannt sein. Der Gültigkeitsbereich eines VLAs beginnt wie bei allen lokalen Variablen mit dessen Definition und umfasst den umschließenden Block.
	Ein großer Vorteil von VLAs ist, dass für temporäre Felder der Aufruf von <code>malloc()</code> und <code>free()</code> wegfällt; der Compiler übernimmt die Anforderung und Freigabe des erforderlichen Speichers.<ref>Randy Meyers: ''The New C: Why Variable Length Arrays?'', Dr. Dobb's, 1. ~~Ocotber~~ 2001, Online: http://www.drdobbs.com/the-new-cwhy-variable-length-arrays/184401444 . Abgerufen am 12. August 2014</ref> Da in der Regel VLAs auf dem [[Stapelspeicher\|Stack]] und nicht auf der [[Dynamischer Speicher\|Halde (Heap)]] angelegt werden, ist die Speicheranforderung auch erheblich effizienter.<ref name="Jones08"> Derek M. Jones: ''The New C Standard - An Economic and Cultural Commentary'', Addison-Wesley Professional 2008, auch Online: http://www.coding-guidelines.com/cbook/cbook1_2.pdf . Abgerufen am 12. August 2014</ref> Außerdem kann auf feste Array-Größen, die häufig Ursache für Softwarefehler sind, verzichtet werden.<ref>[https://www.securecoding.cert.org/confluence/display/seccode/VOID+STR35-C.+Do+not+copy+data+from+an+unbounded+source+to+a+fixed-length+array Webseite des CERT Secure Coding Standard STR35-C]. Abgerufen am 12. August 2014</ref>		Ein großer Vorteil von VLAs ist, dass für temporäre Felder der Aufruf von <code>malloc()</code> und <code>free()</code> wegfällt; der Compiler übernimmt die Anforderung und Freigabe des erforderlichen Speichers.<ref>Randy Meyers: ''The New C: Why Variable Length Arrays?'', Dr. Dobb's, 1. October 2001, Online: http://www.drdobbs.com/the-new-cwhy-variable-length-arrays/184401444 . Abgerufen am 12. August 2014</ref> Da in der Regel VLAs auf dem [[Stapelspeicher\|Stack]] und nicht auf der [[Dynamischer Speicher\|Halde (Heap)]] angelegt werden, ist die Speicheranforderung auch erheblich effizienter.<ref name="Jones08"> Derek M. Jones: ''The New C Standard - An Economic and Cultural Commentary'', Addison-Wesley Professional 2008, auch Online: http://www.coding-guidelines.com/cbook/cbook1_2.pdf . Abgerufen am 12. August 2014</ref> Außerdem kann auf feste Array-Größen, die häufig Ursache für Softwarefehler sind, verzichtet werden.<ref>[https://www.securecoding.cert.org/confluence/display/seccode/VOID+STR35-C.+Do+not+copy+data+from+an+unbounded+source+to+a+fixed-length+array Webseite des CERT Secure Coding Standard STR35-C]. Abgerufen am 12. August 2014</ref>
	=== Beispiel ===		=== Beispiel ===
	Das folgende Beispiel zeigt eine typische Anwendung von VLAs.		Das folgende Beispiel zeigt eine typische Anwendung von VLAs.

S.Didam: /* Funktionsweise und Anwendung */ tippo

2014-08-13T07:42:35Z

Funktionsweise und Anwendung: tippo

← Nächstältere Version		Version vom 13. August 2014, 09:42 Uhr
Zeile 10:		Zeile 10:
	}		}
	</syntaxhighlight>		</syntaxhighlight>
	Dabei ist zu beachten, dass VLAs nicht initialisiert werden können (Einschränkung in den C-Standards, vgl. §6.7.8 respektive §6.7.9)<ref name="c99">ISO/IEC9899-1999 Programming Languages -- C</ref><ref name="c11">ISO/IEC9899-2011 Programming Languages -- C</ref> und die Größe nur einmalig bei der Definition festgelegt werden kann. ~~Darüberhinaus~~ können VLAs nur innerhalb von Funktionen angelegt werden. Außerhalb von Funktionen müssen Feldgrößen auch in C99 zum Zeitpunkt der Übersetzung bekannt sein. Der Gültigkeitsbereich eines VLAs beginnt wie bei allen lokalen Variablen mit dessen Definition und umfasst den umschließenden Block.		Dabei ist zu beachten, dass VLAs nicht initialisiert werden können (Einschränkung in den C-Standards, vgl. §6.7.8 respektive §6.7.9)<ref name="c99">ISO/IEC9899-1999 Programming Languages -- C</ref><ref name="c11">ISO/IEC9899-2011 Programming Languages -- C</ref> und die Größe nur einmalig bei der Definition festgelegt werden kann. Darüber hinaus können VLAs nur innerhalb von Funktionen angelegt werden. Außerhalb von Funktionen müssen Feldgrößen auch in C99 zum Zeitpunkt der Übersetzung bekannt sein. Der Gültigkeitsbereich eines VLAs beginnt wie bei allen lokalen Variablen mit dessen Definition und umfasst den umschließenden Block.
	Ein großer Vorteil von VLAs ist, dass für temporäre Felder der Aufruf von <code>malloc()</code> und <code>free()</code> wegfällt; der Compiler übernimmt die Anforderung und Freigabe des erforderlichen Speichers.<ref>Randy Meyers: ''The New C: Why Variable Length Arrays?'', Dr. Dobb's, 1. Ocotber 2001, Online: http://www.drdobbs.com/the-new-cwhy-variable-length-arrays/184401444 . Abgerufen am 12. August 2014</ref> Da in der Regel VLAs auf dem [[Stapelspeicher\|Stack]] und nicht auf der [[Dynamischer Speicher\|Halde (Heap)]] angelegt werden, ist die Speicheranforderung auch erheblich effizienter.<ref name="Jones08"> Derek M. Jones: ''The New C Standard - An Economic and Cultural Commentary'', Addison-Wesley Professional 2008, auch Online: http://www.coding-guidelines.com/cbook/cbook1_2.pdf . Abgerufen am 12. August 2014</ref> Außerdem kann auf feste Array-Größen, die häufig Ursache für Softwarefehler sind, verzichtet werden.<ref>[https://www.securecoding.cert.org/confluence/display/seccode/VOID+STR35-C.+Do+not+copy+data+from+an+unbounded+source+to+a+fixed-length+array Webseite des CERT Secure Coding Standard STR35-C]. Abgerufen am 12. August 2014</ref>		Ein großer Vorteil von VLAs ist, dass für temporäre Felder der Aufruf von <code>malloc()</code> und <code>free()</code> wegfällt; der Compiler übernimmt die Anforderung und Freigabe des erforderlichen Speichers.<ref>Randy Meyers: ''The New C: Why Variable Length Arrays?'', Dr. Dobb's, 1. Ocotber 2001, Online: http://www.drdobbs.com/the-new-cwhy-variable-length-arrays/184401444 . Abgerufen am 12. August 2014</ref> Da in der Regel VLAs auf dem [[Stapelspeicher\|Stack]] und nicht auf der [[Dynamischer Speicher\|Halde (Heap)]] angelegt werden, ist die Speicheranforderung auch erheblich effizienter.<ref name="Jones08"> Derek M. Jones: ''The New C Standard - An Economic and Cultural Commentary'', Addison-Wesley Professional 2008, auch Online: http://www.coding-guidelines.com/cbook/cbook1_2.pdf . Abgerufen am 12. August 2014</ref> Außerdem kann auf feste Array-Größen, die häufig Ursache für Softwarefehler sind, verzichtet werden.<ref>[https://www.securecoding.cert.org/confluence/display/seccode/VOID+STR35-C.+Do+not+copy+data+from+an+unbounded+source+to+a+fixed-length+array Webseite des CERT Secure Coding Standard STR35-C]. Abgerufen am 12. August 2014</ref>
	=== Beispiel ===		=== Beispiel ===
Zeile 40:		Zeile 40:
	Der Operator <code>sizeof</code> muss bei VLAs zur Laufzeit ausgewertet werden, d.h. für jedes VLA muss Meta-Information zur Laufzeit generiert werden <ref name="Jones08" />. Die Definition von VLAs darf nicht übersprungen werden, hier schränken die C-Standards die Benutzung von <code>goto</code> ein.<ref name="c99" /><ref name="c11" />		Der Operator <code>sizeof</code> muss bei VLAs zur Laufzeit ausgewertet werden, d.h. für jedes VLA muss Meta-Information zur Laufzeit generiert werden <ref name="Jones08" />. Die Definition von VLAs darf nicht übersprungen werden, hier schränken die C-Standards die Benutzung von <code>goto</code> ein.<ref name="c99" /><ref name="c11" />
	Im Gegensatz zu C99 ist die Implementierung von VLAs bei C11-konformen Compilern freigestellt. Die Verfügbarkeit kann über das Define <code>__STDC_NO_VLA__</code> abgefragt werden, das den Integerwert 1 aufweist, sofern VLAs nicht unterstützt werden.<ref name="c11" />		Im Gegensatz zu C99 ist die Implementierung von VLAs bei C11-konformen Compilern freigestellt. Die Verfügbarkeit kann über das Define <code>__STDC_NO_VLA__</code> abgefragt werden, das den Integerwert 1 aufweist, sofern VLAs nicht unterstützt werden.<ref name="c11" />

	== Abgrenzung zu anderen Programmiersprachen ==		== Abgrenzung zu anderen Programmiersprachen ==
	VLAs sind C-spezifisch und werden nicht vom C++-Standard übernommen. [[C++]] bietet Container-Klassen, die variable Felder ermöglichen. Die Programmiersprachen [[APL (Programmiersprache)\|APL]] und [[Perl (Programmiersprache)\|Perl]] unterstützen beispielsweise Felder, dessen Größe zur Laufzeit verändert werden können.<ref name="Jones08" /> Arrays in [[Java (Programmiersprache)\|Java]] haben eine feste Größe. Da sie dynamisch angelegt werden, können wie bei VLAs die Größen zur Laufzeit festgelegt werden.		VLAs sind C-spezifisch und werden nicht vom C++-Standard übernommen. [[C++]] bietet Container-Klassen, die variable Felder ermöglichen. Die Programmiersprachen [[APL (Programmiersprache)\|APL]] und [[Perl (Programmiersprache)\|Perl]] unterstützen beispielsweise Felder, dessen Größe zur Laufzeit verändert werden können.<ref name="Jones08" /> Arrays in [[Java (Programmiersprache)\|Java]] haben eine feste Größe. Da sie dynamisch angelegt werden, können wie bei VLAs die Größen zur Laufzeit festgelegt werden.