FAQ Vorschlag: Dynamische Speicherverwaltung mit C

[Guybrush Threepwood]

Da sich ja im FAQ Bereich nichts tut *tadelndumsichschau*,

hab ich mal folgendes verfasst und bin für Vorschläge offen:

Dynamische Speicherverwaltung mit C

Um, mit C, während der Programmlaufzeit Speicherplatz zu reservieren, brauchen wir zunächst einmal einen Zeiger vom entsprechenden Datentyp. Dabei kann es sich um jeden beliebigen Datentyp handeln, in unserem Beispiel soll es ein Zeiger vom Typ char sein.

char *lpZeiger;

[/PHP]

Dieser Zeiger soll nun die Adresse des Speicherplatzes aufnehmen, den wir reservieren wollen.

Dies könnte z.B. so aussehen:

[PHP]
lpZeiger = (char*) malloc(sizeof(char));

Dabei reserviert die Funktion malloc den Platz für die Größe eines chars und gibt die Adresse zurück, welche wir nur noch in einen char Zeiger casten müssen.

Um nun mit dem reserviertem Speicher, auf den lpZeiger zeigt, arbeiten zu können benötigen wir den Dereferenzierungsoperator *. Dieser sagt dem Compiler das wir nicht auf den Inahlt von lpZeiger, sondern auf den Bereich auf den er zeigt, zugreifen wollen.

*lpZeiger = 'h';


printf ("%c\n",*lpZeiger);

[/PHP]

Wenn wir den selbst reservierten Speicher nicht mehr benötigen, sollten wir auf keinen Fall vergessen diesen wieder Freizugeben.

[PHP]
free(lpZeiger);

Wenn wir dies nicht machen entstehen Speicherlecks, da der Speicher ja immer noch reserviert ist.

Wir können aber nicht nur Platz für einen einzigen character reservieren, sondern auch für mehrere. Die einzige Grenze die wir haben ist der virtuelle Speicher des PCs.

Um Speicher für mehrere character zu reservieren gehen wir einfach folgendermaßen vor:

char *lpZeiger;


lpZeiger = (char*) malloc(12*sizeof(char));

[/PHP]

Somit haben wir Speicherplatz für 12 Character reserviert, in die wir jetzt z.B. einen String kopieren können:

[PHP]
strcpy(lpZeiger,"Hallo Welt!");

Alle die sich fragen warum wir 12 Character für einen String mit 11 Zeichen reserviert haben sollten das 0 Zeichen nicht vergessen, mit dem jeder String abgeschlossen wird.

Diesen String können wir jetzt ganz einfach anzeigen (oder sonst was damit machen) und sollten wieder nicht vergessen den Speicher freizugeben sobald er nicht mehr benötigt wird:

printf ("%s\n",lpZeiger);


free(lpZeiger);

[/PHP]

Das Ganze ist aber nicht nur in einer Dimension, sondern in beliebig vielen möglich.

Um z.B. ein zweidimensionales Array eines beliebigen Datentyps anzulegen benötigen wir einen Zeiger auf einen Zeiger.

Klingt konfus ist aber so;)

Als Beispiel soll uns wieder der char Datentyp dienen:

[PHP]
char **lpZeiger;

Wie bereits gesagt haben wir jetzt einen Zeiger auf einen Zeiger. Das folgende Beispiel sollte das etwas verdeutlichen. Wir reservieren uns jetzt Speicher für 4 Zeiger und lassen lpZeiger drauf verweisen:

lpZeiger = (char**) malloc(4*sizeof(char*));

[/PHP]

Wie wir sehen zeigt lpZeiger jetzt auf 4 einfache char Zeiger mit denen wir eben Speicher für den String "Hallo Welt!" reserviert haben. Genau das Selbe können wir jetzt auch mit unseren 4 Zeigern machen. Um die Sache zu vereinfachen reservieren für für alle 4 Zeiger einen gleich großen Speicherplatz und nehmen dazu eine Schleife:

[PHP]
for (int i=0; i<4; i++)
lpZeiger[i] = (char*) malloc(6*sizeof(char));

Nun zeigt lpZeiger also auf ein Array von 4 char Zeigern und jeder dieser char Zeiger auf ein Array für 6 Character. Um nun einen String in diese 4 Arrays zu Speichern können wir den [] Operator benutzen:

strcpy(lpZeiger[0],"Daß");

strcpy(lpZeiger[1],"ist");

strcpy(lpZeiger[2],"ein");

strcpy(lpZeiger[3],"Test.");

[/PHP]

Wenn wir auf ein einzelnes Zeichen innerhalb eines dieser Arrays zugreifen wollen können wir den [] Operator auch mehrmals verwenden:

[PHP]
lpZeiger[0][2] = 's';

Damit wäre z.B. der Rechtschreibfehler im ersten Array korrigiert:)

Wenn wir diese Arrays nun ausgeben wollen können wir wieder folgendermaßen vorgehen:

for (i=0; i<4; i++)

	printf ("%s ",lpZeiger[i]);

[/PHP]

Wenn wir nur ein Zeichen ausgeben wollen machen wir`s wieder wie oben:

[PHP]
printf ("%c\n",lpZeiger[1][0]);

Wenn wir jetzt den reservierten Speicher nicht mehr benötigen und wieder freigeben wollen, müssen wir zuerst mit der untersten Ebene, also mit den 4 Character Arrays, anfangen. Wenn wir zuerst den Platz für die 4 Zeiger freigeben würden, könntne wir über diese ja nicht mehr auf die Arrays zugreifen.

Das Ganze machen wir am Besten so:

for (i=0; i<4; i++)

	free(lpZeiger[i]);

[/PHP]

Somit sind die 4 * 6 Zeichen wieder freigegeben und wir können die 4 Zeiger freigeben:

[PHP]
free(lpZeiger);

Das war`s schon:)

Wie bereits gesagt lässt sich das mit jedem beliebigem Datentyp in C und mit beliebig vielen Dimensionen wiederholen. Bei mehr Dimensionen sollte man aber darauf achten, dass hier der Speicherverbrauch sehr schnell anwachsen kann. Für ein dreidimensionales Array vom Typ char mit je 100 Elementen wären das immerhin 100*100*100*sizeof(char) Byte, also 1000000 Byte und das sind ca. 1MB.

[Diablo999]

Gehts hier nur um C oder auch um CPP, wenn ja dann wäre

vielleicht new und delete noch interessant :floet:

Ansonsten echt super fürs FAQ

Gruß

Diablo999

[Guybrush Threepwood]

Mir gings erstmal um C. Aber du hast Recht, man sollte new und delete trotzdem noch mit aufnehmen, da diese ja Construktor und Destruktor aufrufen und das mitunter sehr wichtig sein kann.