hallo Zusammen,
kann mir jemand erklären wie Array , Pointer , Allokierte Speicher funtionnieren .
ich bedanke mich im Voraus
Also Array lässt sich noch teilweise in paar Sätzen erklären, bei Pointer müsste ich vorher Wissen wie groß dein Wissen in der Speicherverwaltung ist genauso bei Allokierten Speicher.
Zu Array, ich versuchs mal einfach zu erklären. Man kann sich Arrays als Variablen vorstellen in denen mehrere Werte gespeichert werden können.
z.B. :
int GegnerHp[1] // So sieht ein Array aus, die 1 bedeutet wie viele Elemente gespeichert werden können (denke drann das dein in C++ von 0 an gezählt wird, hier ale 0,1)
GegnerHp[0] = 100 // wir geben nun den ersten Gegner eine Hp von 100
GegnerHp[1] = 120 // und den zweiten Gegner 120 Hp
Eine Abfrage ist wie folgt möglich:
int aktuelleGegnerHp = Gegner[0];
Es gibt dann nur verschachtelte Arrays. Das kann man sich als eine Art 2. Ebene in einem Array vorstellen.
hallo ,
hi ich bin Anfängerin beim c++ aber ich habe viel die letzte Zeit über c++ gelesen mir interessiert und will weiter kommen mit diesem Thema .
Also ich habe es soweit verstanden denke ich was sie geschrieben haben : heißt das so
int GegnerHP[1] ; // hier ist ein Array definiert ohne Initialisierung und er hat 2 Adressen Speicher
GegnerHP[0]= 100; //an der Adresse 0 wird 100 gespeichert
GegnerHP[1]=120; //an der Adresse 1 wird die 120 gespeichert
wir können es auch so schreiben , oder ?
int GegnerHP[1]={100, 120};
Hallo Mamy,
das ist natürlich eine ganz schön offenen Frage. Ich empfehle dir, dir erstmal ein Buch zur Hand zu nehmen und nachzulesen. Ich empfehle dir das Buch von Bjarne Stroustrup „Die C+±Programmiersprache“. Als Anfänger benötigt man für dieses Buch zwar noch viel Sekundärliteratur, aber ich glaube als „Erfinder“ von C++ hat der Mann auch die meiste Ahnung, was die Standard-Bibliotheken betrifft.
Wenn dann konkrete Fragen auftreten, kannst du dich gern wieder an die Menge hier wenden.
Beste Grüße und viel Erfolg.
Hubdehoe
Hallo Mamy, wenn du dir nicht gleich ein Buch kaufen möchtest, dann ist bestimmt der folgende Wikipedia-Artikel nicht schlecht zum Verständnis.
http://de.wikipedia.org/wiki/Dynamischer_Speicher
Pointer sind einfach nur die Adressen von Speicherbereichen. Auf 32Bit-Systemen sind sie 32 Bit lang und auf 64Bit-Systemen 64 Bit usw. Wenn ich den Pointer selbst ändere, dann ändere ich die Adresse auf die der Pointer zeigt. Will ich den Inhalt an dem Speicherbereich ändern, muss ich zusätzlichen Aufwand betreiben.
Generell unterscheiden sich Arrays von Pointern mit dynamisch zugewiesenem Speicher nur dahingehend, dass das Array seinen Speicher auf dem Stack reserviert und der Pointer seinen zugewiesenen Speicher auf dem Heap reserviert bekommt. Auf dem Stack sollten nur überschaubare Mengen Speicher reserviert werden. Andernfalls bekommt man einen Stack-Overflow. Auf dem Heap ist die Menge des Speichers - vereinfacht gesagt - durch den Hauptspeicher des Rechners begrenzt.
char Array[10] = {0}; // initialisieren nciht vergessen
char\* Pointer0 = (char\*)malloc( sizeof(char)\*10 ); // c
// Auf NULL prüfen nicht vergessen
char\* Pointer1 = new char[10]; // c++
// Kann exceptions werfen, wenn keine Speicher verfügbar ist
//...
//tu was damit
//...
free Pointer0; // c, Freigabe des Speicher nicht vergessen
delete[] Pointer1; // c++, Niemals C und C++ Speicher Allokierung und Deallokierung mischen!
Die Freigabe sollte natürlich erst passieren, wenn man den Speicher nicht mehr benötigt.
\*Array = Array[1] = 'a'; // Würde dem Element 0 und dem Element 1 den Ascii-Code für den Buchstaben "a" zuweisen
// Einmal durch den Dereferenzierungsoperator und einmal durch den Zugriffsoperator.
D.h.:
\*( Array + 2 ) = 'd'; // Nimm die Adresse, addiere 2 und greife auf das Element an der Adresse zu
…macht das gleiche wie…
Array[2] = 'd'; // Gut, sich besser aus, aber manchmal braucht man auch die andere Variante
\*Pointer = Pointer[1] = 'b'; // würde was ähnliches für Pointer tun, nur auf dem Heap!
Jedoch kann ein Pointer auf auf andere Dinge verweisen. Hier zum Beispiel verweist der Pointer „Point“ auf ein Array, dass sein Speicher auf dem Stack hat.
char Buffer[10] = {0};
char\* Point = Buffer;
// Vorsicht mit den längen der Arrays
// Wenn der Stack versehentlich manipuliert wird, passiert irgendwas,
// nur nicht das was man will.
// Also z.B. Point[10] = 'f';
// Letzter gültiger Index ist 9, da bei 0 beginnt!
Oder auch auf Funktionen.
void Do( void ) // irgendeine Funktion
{ }
// Durch den typedef bekommt man einen lesbaren Typ.
typedef void(\*TFunctionPointer)( void );
// Unser Function-Pointer
TFunctionPointer FPoint = &Do;
(\*FPoint)(); // führt Do aus!
Nicht vergessen, selbstverständlich kann man dann das ganze auch schachteln;
char Matrix[3][3] = {{1,2,3},{4,5,6},{7,8,9}};
Wobei dann das erste Array als Inhalt die Pointer zu den inneren Speicherbereichen enthält.
Ich persönlich finde es wichtig, wenn man schon mit Pointern usw. umgeht, das mann auch die Rolle von const versteht. Auch wenn das jetzt nur am Rande mit den eigentlichen Pointern zu tun hat.
const char Array[3] = {'a','b','c'}; // alles const
char\* Pointer = Array; // geht nicht, da Array const ist, Pointer aber komplett veränderbar deklariert ist.
char const\* Pointer = Array; // geht, da der Inhalt des Pointers als const deklariert ist, der Pointer selbst ist jedoch noch veränderbar
const char\* Pointer = Array; // geht auch, aber Pointer kann dann nicht mehr geändert werden
const bezieht sich auf das was lins davon seht, außer const steht am Anfang der Deklaration, dann gilt es für die gesamte Deklaration, also Pointer und Inhalt (Initialisierung dann natürlich zwingend).
Ich hoffe das verwirrt dich nicht zu sehr. Falls ja, frag einfach weiter oder vielleicht hat auch jemand anderes noch schönere Erklärungen.
http://www.parashift.com/c+±faq-lite/
Ist sicherlich auch sehr hilfreich.
Grüße
Sascha
Hallo Sascha ,
vielen Dank für die Erklärung .
Beim Pointer , array , feld habe ich versucht zu verstehen wie die funktionieren und zwar ich habe kleine Beispiel genommen und Ergebnis über Debugger zu beobachten . ich habe nur einfache beispiele genommen .
int i;
int feld[10] = {1,2,3,4,5,6,7,8,9,10}; // 10 Elemente, mit Initialisierung
for (i=0; i
int\* Pointer = NULL;
Pointer = new int[10]; // can throw exceptions
for ( unsigned int Index = 0; Index delete[]
// new -\> delete
// malloc -\> free
Pointer = NULL;
In Zeile 1 wird ersteinmal nur ein Pointer deklariert. Das heißt auf einem 32 Bit-System werden 4 Byte auf dem Stack zum Aufnehmen einer Adresse reserviert. Pointer sollten IMMER sofort mit NULL oder etwas gültigem initialisiert werden. Damit ist dann jedoch noch kein Speicher für den Inhalt reserviert. Das kannst du mit new bzw. mit new[] auf dem Heap machen. Erst danach ist Platz für den eigentlichen Inhalt geschaffen. Als Resultat kann das dann prinzipiell genau wie ein Feld benutzt werden. Wenn man den Speicher nicht mehr benötigt, ruft man delete oder delete[] auf, was den Speicherbereich auf dem Heap wieder freigibt. Man könnte dann zur Sicherheit auch noch den Pointer wieder mit NULL überschreiben. Das macht in diesem Beispiel sicherlich nicht viel Sinn, ist aber bei komplexen Geschichten sinnvoll bzw. auch guter Stil.
Grüße
Sascha
ich versuch’s mal - und vereinfache dabei etwas:
Ein Array ist ein Feld (engl. „array“) festgelegter Größe, das eine bestimmte Menge gleichartiger (betr. Datentyp) Elemente enthält. Beispielsweise die Menge ganzzahliger Werte (Datentyp ‚integer‘) wie [1, 3, 5, 7, 9].
Das Array zeichnet sich insbesondere dadurch aus, dass seine Gesamt-Größe festgelegt ist. Denn „festgelegte Größe“ und „bestimmte Menge“ (s.o.) meint „festgelegte Anzahl von Elementen“. Und „gleichartige Elemente“ meint „alle Elemente haben dieselbe Struktur“ - d.h. insbesondere auch: denselben Speicherbedarf.
Für ein Programm steht daher schon beim Übersetzen (eigentlich schon beim Erstellen (Programmieren)) fest, wie groß der Speicherbedarf des Arrays ist.
Daher kann schon der Programm-Compiler („at compile time“) dafür eine Zuordnung des Speichers vornehmen, die nicht mehr verändert werden muß. Das ermöglicht dann eine einfache Verwaltung und Verwendung.
Für „Allokierten Speicher“ hingegen wird erst zur Laufzeit des Programmes ermittelt für welche Art von Elementen (und damit auch deren Speicherbedarf) und für WIEVIELE Elemente Speicherplatz benötigt wird. Dieser Speicher wird dann dynamisch, d.h. zur Laufzeit des Programmes, vom Betriebssystem (auf dem das Program abläuft) angefordert. „zur Laufzeit“ heißt dann im Englischen „at run time“ (im Gegensatz zu „at compile time“ - für das Array oben).
Man spricht bei Dingen, die „at compile time“ entschieden werden können, auch von „statisch“. Und bei Dingen, die „at run time“ bestimmt werden, von „dynamisch“.
„statisch“, weil „at compile time“ unveränderlich ist; dafür kommt bei jedem Ablauf des Programmes dasselbe heraus.
„dynmisch“, weil für „at runt time“ bei jedem neuen Ablauf des Programmes etwas anderes herauskommen kann Bei unserem Fall jeweils was den Speicherbedarf angeht.
Beispiel:
Array:
int NurEinstelligeZahlen[4] = {2, 3, 5, 7};
Diese Array von #4 Elementen wird immer nur (maximal) #4 einstellige Zahlen enthalten. Es ist hier schon mit bestimmten Werten belegt. Das ist aber keine zwingend notwendige Eigenschaft eines Arrays. Nur seine Größe ist „statisch“ (fest). WELCHE Werte es enthält, das kann während des Programm-Ablaufs verändert werden.
Allokierter Speicher:
Programm-Ausgabe: „wieviele Primzahlen willst Du?:“
Programm-Eingabe: „10“
Programm-Ausgabe: „2, 3, 5, 7, 11, 13, 17, 19, 23, 29“
Wenn Du bei der Programm-Eingabe aber anstelle von „10“ z.B. „100“ eingibst, dann möchtest Du die #100 ersten Primzahlen haben. Dafür muß das Programm dann auch mehr Speicher heranziehen. (Wir gehen mal davon aus, dass das Programm die Zahlen alle erst ermitteln, dabei abspeichern und anschließend aus diesem Speicher wiedergeben soll).
Und für dynamisch Allokierten Speicher schließlich BENÖTIGT man die Pointer (Zeiger).
In Deinem Programm mußt Du einen Pointer (eine Pointer Variable) definieren, den Du dann dem Betriebsystem gibst, wenn Du von ihm einen zur Laufzeit bestimmten Speicherbereich anforderst. Das Betriebsystem erledigt dass dann und setzt den Pointer auf den Anfang dieses Speicherblocks. Dann kann man mittels des Pointers auf diesen Bereich zugreifen.
Ein Pointer KANN allerdings auch dazu verwendet werden, um auf ein Array zu zeigen (bzw. ein Element eines Arrays).
Z.B. könntest Du zwei (statische) Arrays haben, die jeweils die gradzahlen bzw. die ungradzahligen Zahlen kleiner als #10 enthalten:
int GeradeZahlen[5] = {0, 2, 4, 6, 8};
int UngeradeZahlen[5] = {1, 3, 5, 7, 9};
Und Dein Programm könnte fragen:
„möchtest Du die geraden (‚g‘) oder die ungeraden (‚u‘) Zahlen kleiner als #10 sehen? (‚g‘ / ‚u‘) : ?“
Abhängig von der Antwort müßte das Programm die Elemente von GeradeZahlen[5] oder UngeradeZahlen[5] ausgeben.
Die eigentliche Ausgabe könnte das Programm über einen Pointer machen. Den müßte das Programm dann unmittelbar vor der Ausgabe auf GeradeZahlen[5] oder UngeradeZahlen[5] setzen.
Ich hoffe es hilft für den Einstieg. Wikipedia und Google helfen bestimmt weiter. Oder auch z.B. in der Bücherei mal nach dem Buch „Programmieren in C“ (von Kernighan & Ritchie) stöbern. Da sollte es besser beschrieben drin stehen.
Gruss,
Frank
Hallo Mamy,
was die einzelnen Begriffe bedeuten, oder wie man diese konkret in C++ nutzt?
hallo Zusammen,
kann mir jemand erklären wie Array , Pointer , Allokierte
Speicher funtionnieren .
ich bedanke mich im Voraus