C++ Speicher und Zeiger

• "Normale" Variablen werden auf dem Stack abgelegt, einem Speicherbereich, der zwar schnell ist, aber nur eine begrenzte Größe besitzt!
• Daher kann man auch Speicher auf dem wesentlich größeren Heap reservieren, nur begrenzt durch physikalisch verfügbaren Speicherplatz... (Auf 32 Bit-Systemen knapp 4 GB Gesamtspeicher)
• Jeder Wert im Speicher hat eine Addresse, die angibt, wo man den Wert im Speicher findet. Dabei handelt es sich um einen hexadezimalen Wert, den man in speziellen Variablen, sog. "Pointern" speichern kann.
  

  //Variable:
  int test=3;
   
  //Pointer für "int"s:
  int* ptest;
   
  //Addresse herausfinden und speichern:
  ptest=&test;
   
  //Nun die Addresse und den Inhalt ausgeben:
  std::cout << "ptest  = " << ptest << std::endl
            << "*ptest = " << *ptest << std::endl;
   

Anwendungsgebiete

• "Call-by-reference" beschreibt die Übergabe von Addressen an Funktionen, damit man anschließend den dahinterliegenden Wert verändern kann. Dabei handelt es sich um eine Möglichkeit, Werte aus einer Funktion zurückzugeben!
  

  //Tauschen: (Funktion ohne Fehler)
   
  void tausche(int* zahl1, int* zahl2)
  {
    int temp=*zahl1; //Die Werte werden getauscht...
      *zahl1=*zahl2;
      *zahl2=temp;
  }
   
  //Beispielaufruf:
  int a=3;
  int b=5;
  tausche(&a,&b); //Addressen übergeben!
   

• Dynamische Reservierung von Speicher:
  • Durch "new" kann man Speicher reservieren. Diesen sollte man mit "delete" wieder freigeben!
  • Auf diesem Speicher kann man ganz normal Werte ablegen oder damit arbeiten
    

    [481B]

    #include <iostream>
     
    int main()
    {
      int* pint=NULL;  //Pointer definieren
      pint=new int;    //Freien Speicher anfordern...
     
      if (pint==NULL)
      {
        std::cerr << "err: Kein Speicher!\n";
        return -1;
      }
     
      std::cout << "Vorher: " << *pint << std::endl;
      *pint=5;
      std::cout << "Nacher: " << *pint << std::endl;
     
      delete pint;
      //Wenn das Programm weiter laufen sollte:
      //  pint=NULL;
      //Ist hier etwas schwachsinnig,
      //da das Programm hier endet... ;)
      return 0;
    }
     
     

Referenzen

• Referenzen sind Aliasnamen für Variablen
• Eine Referenz zeigt quasi auf den gleichen Speicherbereich, wie die Ur-Variable
• Man kann Referenzen nicht wieder neu zuweisen!
• Auch mit Referenzen kann man Call-by-reference implementieren:
  

  [358B]

  //referenzen.cpp
  #include <iostream>
   
  void tausche(int &eins, int &zwei)
  {
    int temp = eins;
        eins = zwei;
        zwei = temp;
  }
   
  int main()
  {
    int a=5;
    int b=3;
   
    std::cout << "Es steht " << a << ":" << b << std::endl;
   
    tausche(a,b); //Halbzeit: Schiedsrichter best*****!
   
    std::cout << "Es steht " << a << ":" << b << std::endl;
   
    return 0;
  }
   

Arrays

• Arrays sind Listen von Variablen eines Typs
• Arrays haben eine feste Gröe, können aber ebenfalls dynamisch angelegt werden!
• Du kannst Arrays so anlegen
  

  int kopfweh[7];
   

  
  
• Füllen kannst du solch ein Array mit:

  array[/*index*/]=/*wert*/;
   
  //z.B.:
  kopfweh[0]=3;
   
  //Alternativ:
  int kopfweh[7]={3,1,1,2,1,31,7};
   

  
  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):

  for (int i=0; i<=6; i++)
  {
   std::cout << kopfweh[i] << std::endl;
  }
   

  
  

  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!

Offsets (Arrays)

Mehrdimensionale Arrays

[221B]

//feld2d.cpp
#include <iostream>
 
int main()
{
 int feld[2][3]={{1,2,3},{4,5,6}};
 for (int i=0; i<2; i++)
 {
  for (int j=0; j<3; j++)
  {
   std::cout << feld[i][j] << " ";
  }
  std::cout << std::endl;
 }
 return 0;
}