[Home]
für Einsteiger!
C++ Einführung
C++ Variablen im Speicher, Zeiger
C++ Texte etc.
C++ Dateien, Formatierte Ausgabe, ...
C++ OOP
Hilfe / Anhang
Downloads / Links
Partner
 
Fehler melden / Kontakt
Impressum
 
Powered by GeSHi
Valid HTML 4.01 Transitional
Seite:  [1] - Drucken

Inhalt:


Arrays

Arrays sind Felder von Variablen eines Typs (z.B.: "int"). Man kann sich Arrays als Listen vorstellen:
 
Kopfschmerztablettenverbrauch
Tag: (Mo-So) 0 1 2 3 4 5 6
Verbrauch: 3 1 1 2 1 31 7

 
In C++ würdest du jetzt vermutlich sieben Variablen anlegen, aber es geht auch einfacher:
Quelltext
  1. int kopfweh[7];
  2.  

 
Füllen kannst du solch ein Array mit:
Quelltext
  1. array[/*index*/]=/*wert*/;
  2.  
  3. //z.B.:
  4. kopfweh[0]=3;
  5.  
  6. //Alternativ:
  7. int kopfweh[7]={3,1,1,2,1,31,7};
  8.  

 
Auslesen kann man ein Array ebenfalls über den Index in eckigen Klammern! (Beginnt mit "0") Meist wirst du dabei eine Schleife benutzen, die alle Indizes durchiteriert (hier z.B. von 0 bis 6):
Quelltext
  1. for (int i=0; i<=6; i++)
  2. {
  3.  std::cout << kopfweh[i] << std::endl;
  4. }
  5.  

 
Ein Array mit der Größe "[7]" kann genau sieben Elemente enthalten, wobei das erste den Index "[0]" und das letzte den Index "[6]" besitzt! Zugriffe auf zu große oder zu kleine Werte lassen das Programm zum Abstürzen!

 
"kopfweh" belegt im Speicher nun 7*4=28 Bytes (7 Integer a 4 Bytes). Ein Aufruf von "sizeof" bestätigt dies:
arraygroesse
 
Der Computer merkt sich allerdings nur die Addresse vom ersten Wert ("0") des Arrays im Speicher, für alle anderen Werte wird im Speicher dann nur weitergezählt, d.h.: der Zeiger wird um eins erhöht ("Zeigerarithmetik"). Aus diesem Grund sollte man auch nicht auf zu große Werte zugreifen!
 

Offsets

Legst du ein Array "int test[]" an, kannst du mittels "std::cout << test;" die Anfangsadresse ausgeben lassen!
 
Mithilfe der eckigen Klammern kann auf Elemente des Arrays zugegriffen werden. Dabei wird im Speicher um ein Offset weitergezählt (Startaddresse+Offset):
OFFSET=sizeof(/*typ*/)*index
 
Die Ausgabe des Arraynamens ohne eckige Klammern gibt die Startaddresse aus, also die Addresse, an der das Feld im Speicher beginnt! Erhöhst oder veringerst du einen solchen Zeiger, musst du ihn vor dem Aufruf von "delete []" unbedingt wieder auf den Ausgangswert zurücksetzen, da ab der Addresse einfach Größe * sizeof(/*typ*/) Bytes im Speicher freigegeben werden. Zeigt der Zeiger nicht mehr auf die ursprüngliche Addresse, so kann das Programm den Speicher nicht mehr korrekt abgeben und stürzt vermutlich ab...
 

Mehrdimensionale Arrays

Man kann auch "Arrays in Arrays" speichern, also eine Tabelle erstellen:
Quelltext[221B]Download
  1. //feld2d.cpp
  2. #include <iostream>
  3.  
  4. int main()
  5. {
  6.  int feld[2][3]={{1,2,3},{4,5,6}};
  7.  for (int i=0; i<2; i++)
  8.  {
  9.   for (int j=0; j<3; j++)
  10.   {
  11.    std::cout << feld[i][j] << " ";
  12.   }
  13.   std::cout << std::endl;
  14.  }
  15.  return 0;
  16. }
  17.  

array2d
 
Meist reichen aber eindimensionale Arrays vollkommen aus!
Ein 3-dimensionales Array der Größe 10x10x10, das Integer enthält, belegt allerdings schon stolze 1000*sizeof(int) Byte, also auf meinem 32-Bit-System ganze 4000 Byte= 3.90625 Kilobyte (1024B=1Kb)
 

Dynamische Arrays?

Die Größe eines solchen Arrays kann zur Laufzeit nicht verändert werden! Allerdings kann man auf dem Heap einen neuen Array anlegen, der größer ist, und die Werte des alten, zu kleinen, Arrays hinüberkopieren. Hier empfiehlt sich allerdings der Gebrauch der STL-Klasse (quasi ein neuer Datentyp) "std::vector" aus "#include <vector>", auf den wir später (nach der OOP) zurückkommen werden!

Wie geht's weiter?

Nach diesem Kapitel über den Speicher kommen jetzt noch Beispiele und die Zusammenfassung, bevor wir dann deinen Namen einlesen können! Weiter!
Seite:  [1] - Drucken