Ja, ich hatte zu Beginn meiner Vorlesung ja schon angekündigt, dass das Thema Felder an einer

etwas ungewöhnlichen Stelle kommt. Normalerweise sind Felder ja einfach Verbunddatentypen sowie

Strukturen auch und man würde sie natürlich im Zusammenhang mit den Datentypen und Variablen

einführen. Aber Felder haben auch einen sehr engen Bezug zu den Zeigern und deswegen dachte

ich eigentlich, dass es vernünftig ist, erstmal die Zeiger einzuführen und dann die Felder zu

bringen und dann vor allem den Zusammenhang zwischen Zeigern und Feldern darzustellen. Und

das möchte ich jetzt machen. Als erstes will ich die Felder erstmal normal kurz einführen. Zunächst

am Beispiel der eindimensionalen Felder. Es gibt in sie natürlich auch mehrdimensionale Felder,

sie haben aber eine relativ geringe Bedeutung. Also eine Reihe von Daten des selben Typs kann

zu einem Feld zusammengefasst werden. Bei der Definition eines Feldes wird die Größe des

Feldes mit angegeben. Diese Größe muss eine Konstante sein und ab dem C Standard 99 kann

bei lokalen Feldern und zwar bei lokalen Feldern des Datentyps oder des Speichertyps Automatic auch

ein zur Laufzeit berechneter Wert als Felddimension eingesetzt werden. Das geht natürlich nur bei der

Speicherklasse Automatic, denn Daten der Speicherklasse Static werden ja bereits zu

Programm Start angelegt, also der Speicherplatz von Static Daten wird bereits beim Programm Start

angelegt. Und dann kann ich dafür natürlich keinen Wert hernehmen als Feldgröße, der erst zur

Laufzeit bekannt wird. Das muss damit ja ein bereits zur Besetzungszeit bekannter und damit

konstanter Wert sein. Der Zugriff auf die Feldelemente erfolgt ganz normal durch Indizierung,

beginnend bei Null. Das ist eigentlich in allen Programmiersprachen mit Feldern so. Die

Definition eines Feldes sieht dann so aus, wie das hier beschrieben ist. Ich gebe den Feld Typ an,

dann den Namen des Feldes und dann in eckigen Klammern die Größe und da können also mehrere

Größen Werte stehen, dann wäre es ein mehrdimensionales Feld und danach kann auch noch eine Initialisierung

kommen. Beispiele dafür wären sowas wie x integer x von 5 oder double f von 20, also letztendlich

fünf Integers hintereinander stehend oder 20 Doubles hintereinander stehend. Die Initialisierung

des Feldes erfolgt dann ganz normal wie bei variable Initialisierungen auch. Es kommt ein Ist-Gleichzeichen

und dann kommt der Initialisierungswert. Im Fall von einem Feld sind es natürlich mehrere Werte,

die dann durch geschweifte Klammern, gekapselt hintereinander angegeben werden. Also ein Beispiel

hier wäre dieses Feld integer prim von 4 mit vier Initialisierungswerten 2, 3, 5 und 7, also

vier Primzahlen oder Charaktername von 5, fünf Charakters, die dann eben durch Charakterliterale,

wie nämlich der Buchstabe großes O, der Buchstabe T, noch ein T, ein kleines O,

Initialisiert werden. Und hier ist eine sehr wichtige Sache, dieses Charakterfeld wird durch

einen sogenannten Nullcharakter abgeschlossen. Das ist eine Konvention in C, das Zeichenketten

generell durch ein spezielles Zeichen, das in der internen Kodierung den numerischen Wert Null hat,

das ist dieser Nullcharakter Backslash Null, dass Zeichenketten so abgeschlossen werden. Und dieser

Nullcharakter unterscheidet sich vom Zeichen Null, also von der Zahl Null, die würde man dann in

Apostroph Null Apostroph darstellen, also ohne den Backslash. Und die Zahl Null in der internen

Kodierung hat einen ganz anderen Wert, wie eben dieser Nullcharakter, der eben den Wert, auch

numerisch den Wert Null hat. Wenn man die explizite Feltdimension weglässt, dann schaut sich der

Compiler einfach an, wie viele Initialisierungskonstanten sind angegeben und macht das

Feld entsprechend groß. Also hier an dieser Stelle integer, Priem, Klammer auf Klammer zu, würde das

Feld auch vier Elemente groß werden oder eben hier Name würde das Feld auch fünf Elemente groß

werden. Wenn man zu wenige Initialisierungskonstanten angibt, dann wird das Feld einfach mit weiteren

Null Elementen aufgefüllt. Charakterfelder können auch durch sogenannte String-Literale

initialisiert werden. Ein String-Literal ist letztlich eine Zeichenkette, die durch Doppelapostroph

geklammert ist, also sowas wie hier Doppelapostroph, Otto Doppelapostroph. Und wenn sie jetzt vorne

anschauen, das Feld hat die Größe 5, die Dimension 5, obwohl hier nur vier Zeichen stehen. Man muss

einfach sehen, bei so einem String-Literal wird dieses terminierende Nullzeichen immer noch

automatisch mit rangehängt. Das heißt also Doppelapostroph, Otto Doppelapostroph ist fünf

Bytes lang, auch wenn man jetzt da nur vier Buchstaben sieht. Und das Name von zwei ist

natürlich exakt das gleiche, bloß eben ohne Felddimension bei der Definition.