====== Zeiger und Arrays - Zeigerarithmetik ======
Arrays nutzen das Modell des linearen Speichers, d.h., ein im Index nachfolgendes Element ist auch physisch im unmittelbar nachfolgenden Speicherbereich abgelegt. Dieser Fakt erlaubt die Interpretation von Zeigervariablen als Arraybezeichner und umgekehrt.

<code cpp>
{
  const int N = 10;
        int a[N], *pint;  // array and pointer
  
  pint = &a[0];           // init pointer
}
</code>

Arraybezeichner werden prinzipiell als Zeiger behandelt, daher ist die Programmzeile

<code cpp>
pint = &a[0];
</code>

identisch mit

<code cpp>
pint = a;
</code>

Folgerichtig stellen daher die Ausdrücke a[1] , *(a+1) , *(pint+1) , pint[1] den identischen Zugriff auf das Feldelement a1 dar. 

{{:inf:cpp:zeiger_und_arrays1.png?600|}}

++++ Testprogramm|
<code cpp>
//	pointer and arrays
#include <iostream>
using namespace std;
 
const int N =10;
      int a[N], *pint;  // array and pointer
     
int main()
{cout << "Uebungen zu Zeiger und Arrays\n";

 // Initialisieren des Arrays mit Quadrat des Index
 for (int i=0;i<N;i++) a[i]=i*i;
  
 // Verschiedene Zugriffsmöglichkeiten
 // a) herkömmlich
 for (int i=0;i<N;i++) cout << a[i] << ' ';
 cout << endl;   
    
 // b) über Pointer a
 pint = &a[0];
 cout << *pint << endl;   
 // pint = a[0];  // wrong!
 // pint = &a;    // wrong!
 pint = a; 
 cout << *pint << endl;   
 

 for (int i=0;i<N;i++) cout << *(a+i) << ' ';
 cout << endl;   

 // Ausgabe des Elements mit Index 6
 cout << *(pint+6) << endl;
 cout << *(pint+6) << endl;
 
 system("PAUSE");
 return EXIT_SUCCESS; 
}
</code>
++++

Die Adresse welche durch ''(pint+1)'' dargestellt wird ergibt sich zu ''(Adresse in pint) + sizeof(int)''. Dabei bezeichnet ''int'' den Datentyp, auf welchen der Zeiger ''pint'' verweist. Der Zugriff auf andere Feldelemente ''ai, i = 0 ... N-1'' ist analog.

Die folgenden Operatoren sind auf Zeiger anwendbar:

  * Vergleichsoperatoren: ''== , != , < , > , <= , >=''
  * Addition ''+'' und Subtraktion ''-''
  * Inkrement ''%%++%%'' , Dekrement ''%%--%%'' und zusammengesetzte Operatoren ''+='' , ''-=''

Zur Demonstration betrachten wir ein Beispiel, in welchem ein Feld erst auf konventionelle Weise definiert und initialisiert wird um danach mittels Zeigeroperationen ausgegeben zu werden. 

{{:inf:cpp:zeiger_und_arrays2.png?800|}}


<code cpp>
//	Pointers and arrays
#include <iostream.h>
main()
{
  const int N=10;
  double    a[N], *pa, *pp, *pi;
  int       i;
  
//                       initialize a
  pa = a;
  for (i=0;i<N;i++) *(pa+i)=(i+1)*(i+1);    // a[i] = ...
//                       output a; 
//                       pointer pi as loop variable
  pp = a+N-1;         // pointer at last element of a			
  for (pi=a;pi<=pp;pi++) cout<<"  "<<*pi << endl;
}
</code>

++++ gesamtes Programm|
<code cpp pointer_and_arrays2.cpp>
//	Pointers and arrays
#include <iostream>
using namespace std;

int main()
{ const int N=10;
  double    a[N], *pa, *pp, *pi;
  int       i;
  cout << "Pointers and arrays" << endl << endl;

  pa = &a[0];
  pp = a;
  if ( pa == pp) cout << endl << " pa and pp are identical" << endl;
// 		initialize a

  for (i=0;i<N;i++ ) *(pa+i)=(i+1)*(i+1);		// a[i] = ...  
//		check element 6
  i = 6;
  cout << endl;
  cout << a[i]    << endl; 
  cout << *(a+i)  << endl; 
  cout << pa[i]   << endl; 
  cout << *(pa+i) << endl << endl; 
//		output a;		    // pointer pi as loop variable
  pp = (a+N-1);				// pointer at last element of a			
  for (pi=a;pi<=pp;pi++)  cout << "  " << *pi ;
  cout << endl;
 
  system("PAUSE");
  return EXIT_SUCCESS; 
}
</code>
++++