5.1.1 Eindimensionale Felder

In einem Feld werden Daten (Elemente) gleichen Typs zusammengefaßt. Die allgemeine Vereinbarung eines statischen Feldes ist

<typ> <bezeichner>[dimension];

wobei die eckigen Klammern ``['' und ``]'' unabdingbarer Bestandteil der Vereinbarung sind. Ein eindimensionales Feld entspricht mathematisch einem Vektor.

//        Example array
{ 
 const int N=5;
 double x[N], y[10];       // Declaration

 x[0] = 1.0;               //  Manipulations
 x[1] = -2;
 x[2] = -x[1];
 x[3] = x[1]+x[2];
 x[4] = x[1]*x[2];
 
// access to x[5] , i.e., x[N] is not permitted
 
}

(siehe Ex510.cc)

Die eckigen Klammern dienen im Vereinbarungsteil der Dimensionsvereinbarung x[N] und im Anweisungsteil dem Zugriff auf einzelne Feldelemente x[3] . Das Feld kann schon bei Deklaration initialisiert werden:
double x[N] = {9,7,6,5,7}

Achtung : Die Numerierung der Feldelemente beginnt mit 0. Daher darf nur auf Feldelemente x_i, i = 0,..., N - 1 zugegriffen werden. Andernfalls sind mysteriöses Programmverhalten, unerklärliche Fehlberechnungen und plötzliche Programmabstürze zu erwarten, deren Ursache nicht offensichtlich ist da sie eventuell erst in weit entfernten Programmteilen auftreten können.

Typischer Fehler

//        Typical error
{
 const int N = 123;
       int ij[N] , i;
 ...
 for (i = 1; i <= N; i++)    // !! WRONG !!
   {
     cout << ij[i] << endl;
   }
}

Es werden die Feldelemente ij₁, ij₂, ij₃, ij₄ und der unsinnige Wert von ij₅ ausgegeben, jedoch nicht das allererste Feldelement ij₀ .

Die Dimension eines statischen Feldes muß zum Zeitpunkt der Compilierung bekannt sein, daher dürfen nur Konstanten oder aus Konstanten bestehende Ausdrücke als Dimension auftreten.

{
 const int N = 5, M = 1;
       int size;
 float x[5];            //  Correct
 short i[N];            //  Correct
 char  c[N-M+1];        //  Correct
 int   ij[size];        //  !! WRONG !!
}

Beispiel: Ein interessanter Spezialfall des Feldes ist die Zeichenkette (String). Wir initialisieren den String mit dem Wort ''Mathematik'' und geben ihn in Normalschrift und zeichenweise aus.

//                   String variables
#include <iostream.h>
#include <string.h>
main()
{
 const int L=11;                // 10+1
 char word[L];
 int  i;

 strcpy(word,"Mathematik");     // initialization
 
 cout << endl << word << endl;
 
 for (i = 0; i < L; i++)
  {
    cout << word[i] << " " ;
  }
 cout << endl;
}

(siehe Ex511.cc)

Die Zeichenkette hätte auch mit
char word[L] = "Mathematik";
oder
char word[] = "Mathematik";
initialisiert werden können, wobei in letzterem Fall die Länge des Feldes word aus der Länge der Zeichenkettenkonstante bestimmt wird.

Beispiel: Berechnung der L₂-Norm eines Vektors, d.h., || $\underline{{x}}$$\parallel_{{L_2}}^{}$ : = $\sqrt{{\sum\limits_{i=0}^{N-1} x_i^2}}$

//	Array: L_2 n
#include <iostream.h
#include <math.h>
main()
{
 const int N=10;
 double x[N], norm;
//                        Initialize x
 for (i = 0; i < N ; i++)
   {
     x[i] = sqrt(i+1.0);
   }
//                        L_2 norm calculation 
 norm = 0.0;
 for (i = 0; i < N; i++)
   {
     norm += x[i]*x[i];
   }
 norm = sqrt(norm);
 
 cout << "  L2-norm : " << norm << endl;
}

(siehe Ex512.cc)

Als kleines Beispiel diene uns die Fibonacci Zahlenfolge, welche über die zweistufige Rekursion

f (n)_: = f (n - 1) + f (n - 2)        n = 2,...

mit den Anfangsbedingungen f (0) = 0, f (1) = 1 definiert ist. (siehe Fibo1.cc) Zur Kontrolle können wir die Formel von Binet bzw. de Moivre verwenden.

f (n) = $${\frac{{1}}{{\sqrt{5}}}}$$$$\left(\vphantom{ \left(\frac{1+\sqrt{5}}{2}\right)^n - \left(\frac{1-\sqrt{5}}{2}\right)^n }\right.$$$$\left(\vphantom{\frac{1+\sqrt{5}}{2}}\right.$$$${\frac{{1+\sqrt{5}}}{{2}}}$$$$\left.\vphantom{\frac{1+\sqrt{5}}{2}}\right)^{n}_{}$$ - $$\left(\vphantom{\frac{1-\sqrt{5}}{2}}\right.$$$${\frac{{1-\sqrt{5}}}{{2}}}$$$$\left.\vphantom{\frac{1-\sqrt{5}}{2}}\right)^{n}_{}$$$$\left.\vphantom{ \left(\frac{1+\sqrt{5}}{2}\right)^n - \left(\frac{1-\sqrt{5}}{2}\right)^n }\right)$$

//                      Demo of Fibonacci numbers
#include <iostream.h>
#include <math.h>
main()
{
  const int N = 20;
        int i;
        int x[N+1];     //  !!   N+1   !!
     double fib;   
//                      Calculate Fibonacci numbers
  x[0] = 0; x[1] = 1;
  for ( i = 2; i <= N; i++ )
     x[i] = x[i-1] + x[i-2]; 
//                      Output x
  ...
///                     Check last Fibonacci number  
  fib = ( pow(0.5*(1.0+sqrt(5.0)),N)
         -pow(0.5*(1.0-sqrt(5.0)),N) )/sqrt(5.0);
  
  cout << "fib(" << N << ") = " << fib << endl;
}

Als weiteres Beispiel sollen Minimum und Maximum eines Vektors bestimmt und die entsprechenden Vektorelemente miteinander vertauscht werden (analog zu Pivotisierung). (siehe Ex513.cc) Dies beinhaltet die beiden Teilaufgaben:

a).

Bestimme Minimum und Maximum (und markiere die Positionen).
Struktogramm:

b).

Vertausche Min/Max-Einträge. Bei Vektorlänge 0 oder bei identischen Vektorelementen ist kein Vertauschen notwendig.
Struktogramm:

Beim Vertauschen führt
die naheliegende, erste Idee x[kmin] = x[kmax]
x[kmax] = x[kmin]
nicht zum Erfolg. Warum?

//	Pivot for a vector
#include <iostream.h>
#include <float.h>
main()
{
 const int N=10;
 double x[N], xmin, xmax, tmp;
 int    kmin, kmax, i;
//                               Initialize x
 for (i = 0; i < N ; i++)
   {
     cin >> x[i];
   }
//                               Initialize min/max 
 xmin =  DBL_MAX;		// in floats.h
 xmax = -DBL_MAX;
//				 Initialize indices
 kmin = kmax = -1;
//				 Determine min/max
 for (i = 0; i < N; i++)
   {
     if ( xmin > x[i] )
      {
       xmin = x[i];
       kmin = i;
      }
     if ( xmax < x[i] )
      {
       xmax = x[i];
       kmax = i;
      }
   }
//				Swap Pivot elements
//			Do nothing for N=0 or constant vector
 if ( kmax != kmin )
  {
   tmp     = x[kmin];
   x[kmin] = x[kmax];
   x[kmax] = tmp;
  }
//				 Print Pivot vector
  ...
}