DynamischerSpeicher

In einer Funktion wird z.B. mit der Deklarationint i;Speicher auf dem sogenannten Stack reserviert. Wenn die Funktion verlassen wird (nach dem Aufruf der Funktion), ist dieser Speicherbereich automatisch wieder freigegeben (nicht mehr reserviert).

Beispiel:

void f(){

int myfeld[10];

//...

}

int main(){

f();

//...

}

Erst wenn f aufgerufen wird, wird Speicher für myfeld auf dem Stack

reserviert.

Wieviel Byte sind dies ?

10 · Speicherbedarf (integer)

Nach dem Aufruf wird dieser Speicherplatz automatisch (ohne Zutun des Programmmierers) wieder freigegeben.

Beispiel:Man will die von einem Anwender (über Tastatur eingegebene) bestimmte

Anzahl von Zahlen in einem Feld abspeichern.

int main(){

int myfeld[1000];

//...

}Welchen Nachteil hat dies bezüglich des Speicherplatzverbrauchs

Der Anwender kann weniger Speicher – als reserviert – verbrauchen (z.B. bei Eingabe nur einer Zahl).

Dies ist dann Speicherverschwendung.

Um dies zu vermeiden kann der Anwender – während der Laufzeit des Programms – so viel Speicher reservieren, wie er benötigt.

Im Gegensatz zum Beispiel oben wird diese Reservierung nicht beim Compilieren, sondern während der Programmlaufs gemacht und heißt

deshalb dynamischer Speicher(reservierung).

Realisierung in C++

int main(){ int anz, zahl, i; int *panf; cout << "Anzahl eingeben:"; cin >> anz; panf = new int[anz]; cout << "Zahlen eingeben:"; for(i=0; i<anz; i++){ cin >> zahl; *(panf+i)=zahl; } // panf[i]=zahl delete panf;}

eingelesener Wert wird in anz gespeichert

für ein Feld von anz integer-Werten

panf zeigt auf das erste Element des Feldes

Mögliche (gleichwertige) Formen des Zugriffs

Reserviert dynamisch Speicher:

gibt Speicher wieder frei

020...

int main(){ int anz, zahl, i; int *panf; cout << "Anzahl eingeben:"; cin >> anz; panf = new int[anz]; cout << "Zahlen eingeben:"; for(i=0; i<anz; i++){ cin >> zahl; *(panf+i)=zahl; }//...

... ...panf

WelchenWert hatpanf an dieser Stelle des Programmms ?

Annahme: anz = 2

In der 1. Spalte stehen die Adressen der Variablen

In der 2. Spalte stehen die Inhalte der Adressen (Werte der Variablen)

020...

?... ...

panf

int main(){ int anz, zahl, i; int *panf; cout << "Anzahl eingeben:"; cin >> anz; panf = new int[anz]; cout << "Zahlen eingeben:"; for(i=0; i<anz; i++){ cin >> zahl; *(panf+i)=zahl; }//...

Was veranlasst diese Anweisungen ?

Es wird im Arbeitsspeicher Platz für 2 integer-Zahlen reserviert und die (Anfangs)Adresse dieses Speicherbereichs der Variable panf zugewiesen.

Auf die (Anfangs)Adresse dieses Speicherbereichs hat der Programmierer keinen Einfluß. Diese legt der Compiler bzw. Programmlader fest.

020...

0700... ...

panf

int main(){ int anz, zahl, i; int *panf; cout << "Anzahl eingeben:"; cin >> anz; panf = new int[anz]; cout << "Zahlen eingeben:"; for(i=0; i<anz; i++){ cin >> zahl; *(panf+i)=zahl; }//...

0700 ??

??

Speicherreservierung für 2 integer-Zahlen,die z.B. bei der Adresse 0700 beginnen

?

zeigt auf:

???

Annahme:Die 1. über Tastatur eingegebene Zahl sei 17 und die 2. eingegebene Zahl sei 13.Was bewirkt dann jeweils (insgesamt zweimal) diese Anweisung ?

020...

0700... ...

panf

int main(){ int anz, zahl, i; int *panf; cout << "Anzahl eingeben:"; cin >> anz; panf = new int[anz]; cout << "Zahlen eingeben:"; for(i=0; i<anz; i++){ cin >> zahl; *(panf+i)=zahl; }//...

0700

0704

0017

0013

Man kann auch für Objekte dynamisch Speicher

allokieren:

int main(){ Konto *pk; pk = new Konto; // Anweisungen delete pk;}

new reserviert dynamisch Speicher. Die Anfangsadresse des dynamischen Speichers wird in einem Zeiger festgehalten, damit man später darauf zugreifen kann. Zusätzlich wird automatisch der Konstruktor aufgerufen.

Falls kein Speicher mehr allokiert werden kann, bekommt pk den Wert NULL, den sogenannten Nullzeiger, zugewiesen. Dieser Nullzeiger zeigt auf kein Objekt !

delete gibt den dynamisch erzeugten Speicher wieder frei.Zusätzlich wird automatisch der Destruktor aufgerufen. Falls pk gleich NULL ist, wird keine Operation ausgeführt.

In der schließenden Klammer } wird kein Destruktor aufgerufen, da pk eine Zeigervariable ist.

Ein weiteres Beispiel:

Die Klasse Bank hat u.a. das Attribut art (Datentyp char), in dem gespeichert ist, ob ein

Konto einem Mitarbeiter gehört (‘M‘), oder einer fremden Person (‘F‘).

Die zugehörigen Methoden, die diesen Modus setzen bzw. lesen heissen (aus Platzgründen verkürzt):

setM getM

class Bank { private: char art; ... public: void setM(...) ... };

In art wird die Art des Mitarbeiters gespeichert, also: 'M' oder 'F'

Annahme:Ein Objekt der Klasse Bank sei 100 Byte groß.

int main(){ int anz; int *pi; Konto *pk, *pkk; anz = rand(); pi = new int; pk = new Konto; pkk = new Konto[anz]; ...

Hier wird nachher jeweils der Anfang des dynamischen Speichers (in einem

Zeiger) festgehalten.

einen integer-Wert

Zufallszahl

die folgenden 3 Befehle reservieren Speicher für:

für ein Objekt der Klasse Konto

für ein Feld von anz Objekten der Klasse Konto

0100...0120pk... ...0140pkk

int main(){ int anz; int *pi; Konto *pk, *pkk; anz = rand(); pi = new int; pk = new Konto; pkk = new Konto[anz];

... ...pi

Welchen Wert haben pi, pk, pkkan dieser Stelle des Programmms ?

Annahmen: anz = 2Speicherplatz Konto: 100 Byte

In der 1. Spalte stehen die Adressen der Variablen

In der 2. Spalte stehen die Inhalte der Adressen (Werte der Variablen)

100...

?

120 ?pk... ...140 ?pkk

... ...pi

int main(){ int anz; int *pi; Konto *pk, *pkk; anz = rand(); pi = new int; pk = new Konto; pkk = new Konto[anz];

Was veranlasst diese Anweisung ?

Es wird im Arbeitsspeicher Platz für eine integer-Zahl reserviert und die (Anfangs)Adresse dieses Speicherbereichs der Variable pi zugewiesen.

Auf die (Anfangs)Adresse des reservierten Speichers hat der Programmierer keinen Einfluß. Dies legt der Compiler (bzw. Programmlader fest).

0100...

0500

0120 ?pk... ...0140 ?pkk

... ...pi

int main(){int anz;int *pi;Konto *pk, *pkk;anz = rand();pi = new int;pk = new Konto;pkk = new Konto[anz];

0500 ??

?

Speicherreservierung für ein integer, das

z.B. bei der Adresse 0500 beginnt

?

zeigt auf:

0100...

0500

0120 0504pk... ...0140 ?pkk

... ...pi

int main(){int anz;int *pi;Konto *pk, *pkk;anz = rand();pi = new int;pk = new Konto;pkk = new Konto[anz];

0500 ?

??

?

Speicherreservierung für ein Objekt der

Klasse Konto (hier: 100 Byte)

?

zeigt auf:

...

...?

0504

0100...

0500

0120 0504pk... ...0140 0604pkk

... ...pi

int main(){int anz;int *pi;Konto *pk, *pkk;anz = rand();pi = new int;pk = new Konto;pkk = new Konto[anz];

0504 ?

??

...Speicherreservierung für ein Feld der Länge 2 mit

Objekten der Klasse Konto (hier: 2*100 Byte) ...

zeigt auf:

...

...?

0704 ?......?

0604

0100...

0500

0120 0504pk... ...0140 0604pkk

... ...pi

*pi = 5;(*pk).setM('M');// pk->setM('M');(*(pkk+1)).setM('F');// pkk[1].setM('F');// (pkk+1)->setM('F');delete pi;delete pk;delete [] pkk;}

0504 ?

??

...

...

...

...?

0704 ?......?

0604

0100...

0500

0120 0504pk... ...0140 0604pkk

... ...pi

*pi = 5;(*pk).setM('M');// pk->setM('M');(*(pkk+1)).setM('F');// pkk[1].setM('F');// (pkk+1)->setM('F');delete pi;delete pk;delete [] pkk;}

0500

0005

gleiche Befehle, nur anders geschrieben

Bemerkung:Die Zahl (hier 5) wird in den zur Verfügung stehenden 32 Bit gespeichert (in welchen Bits die einzelnen Ziffern der Zahl stehen, interessiert uns hier nicht).

0100...

0500

0120 0504pk... ...0140 0604pkk

... ...pi

*pi = 5;(*pk).setM('M');// pk->setM('M');(*(pkk+1)).setM('F');// pkk[1].setM('F');// (pkk+1)->setM('F');delete pi;delete pk;delete [] pkk;}

0504 ‘M‘

0604??

...

...

...

...?

0704 ?......?

gleiche Befehle, nur anders geschrieben

0100...

0500

0120 0504pk... ...0140 0604pkk

... ...pi

*pi = 5;(*pk).setM('M');// pk->setM('M');(*(pkk+1)).setM('F');// pkk[1].setM('F');// (pkk+1)->setM('F');delete pi;delete pk;delete [] pkk;}

0504 ‘M‘

0604??

...

...

...

...?

0704 ‘F‘......?

Was macht das gleiche Programm, aber ohne die folgenden Anweisungen:

pi = new int;pk = new Konto;pkk = new Konto[anz];

int main(){ int anz; int *pi; Konto *pk, *pkk; anz = rand(); *pi = 5; (*pk).setM('M'); // pk->setM('M'); (*(pkk+1)).setM('F'); // pkk[1].setM('F'); // (pkk+1)->setM('F'); ...

Welchen Wert hat pi z.B. an dieser Stelle des Programms ?

int main(){ int anz; int *pi; Konto *pk, *pkk; anz = rand(); *pi = 5; (*pk).setM('M'); (*(pkk+1)).setM('F');

0100...

?

0120 ...pk... ...0140 ...pkk

... ...pi

? bedeutet:irgendein unbekannter, zufälliger Wert.Zum Beispiel: 0815

int main(){ int anz; int *pi; Konto *pk, *pkk; anz = rand(); *pi = 5; (*pk).setM('M'); (*(pkk+1)).setM('F');

0100...

0815

0120 ...pk... ...0140 ...pkk

... ...pi

Was steht an der Adresse 0815 im Arbeitsspeicher ?

Der Programmier weiß es nicht, denn er hat an dieser Adresse keinen Speicherplatz reservieren lassen und diesen entsprechend belegt.

Im "schlimmsten" Fall könnte an der Adresse 0815 zum Beispiel...

Ein Teil des Betriebssystems beginnen !

int main(){ int anz; int *pi; Konto *pk, *pkk; anz = rand(); *pi = 5; (*pk).setM('M'); (*(pkk+1)).setM('F');

0100...

0815

0120 ...pk... ...0140 ...pkk

... ...pi

0815 Teildes

Syst.Betr.

int main(){ int anz; int *pi; Konto *pk, *pkk; anz = rand(); *pi = 5; (*pk).setM('M'); (*(pkk+1)).setM('F');

0100...

0815

0120 ...pk... ...0140 ...pkk

... ...pi

0815 50

00

Dieser Teil des Betriebssystems wird überschrieben

Analoges gilt auch für die folgenden Anweisungen