Felder beliebigen Typs mit konstanten Grenzen

Im folgenden eine Musterlösung zur Aufgabe, Felder beliebigen Typs zu vereinbaren, deren Elementanzahl zur Übersetzungszeit frei ist, aber zur Laufzeit dann konstant.

Die Lösung basiert auf einer template-Klasse mit einem Typparameter und der Anzahl der Elemente.

// Time-stamp: "(12.12.01 21:25) ConstArr.cpp [Klaus Wachtler (aw38)]"
// 
// 

#include <iostream>
#include <cstdio>

using namespace std;

// Wenn FELDGRENZENPRUEFEN definiert ist, dann wird bei jedem
// Zugriff der Wert des Index geprüft:
#define FELDGRENZENPRUEFEN

template<class T, int N> class Feld
{
public:

  // Konstruktor
  Feld()
  {
  }

  // Konstruktor mit einem Wert, der anfangs an jedes
  // Element zugewisen werden soll:
  Feld( const T &Anfangswert )
  {
    for( int i=0; i<N; i++ )
      {
        array[i] = Anfangswert;
      }
  }

  // copy-Konstruktor
  Feld( const Feld &rechteSeite )
  {
    for( int i=0; i<N; i++ )
      {
        array[i] = rechteSeite.array[i];
      }
  }

  // Die Verwendung von [index] liefert eine
  // Referenz auf das Element in array[index]:
  T &operator[]( int index )
  {

#ifdef FELDGRENZENPRUEFEN

    if( index<0 || index>=N )
      {
        static char puffer[200];
        sprintf( puffer,
                 "Feldgrenzenüberschreitung in Feld<class T,int N>:\n"
                 "%d liegt nicht im Bereich %d...%d-1",
                 index,
                 0,
                 N
                 );
        throw( (const char*)puffer );
      }

#endif // ifdef FELDGRENZENPRUEFEN

    return array[index];
  }

private:

  // das eigentliche Feld mit den Elementen
  T array[N];


}; // class Feld...


// Testprogramm für Feld<int,10>:

int main( int nargs, char **args )
{
  try
    {
      Feld<int,10>  feld(-99);

      // Elemente belegen:
      for( int i=0; i<5; i++ )
        {
          feld[i] = i*i;
        }

      // Elemente ausgeben:
      for( int i=0; i<10; i++ )
        {
          cout << "feld[" << i << "] = " << feld[i] << endl;
        }

      // "versehentlicher" Zugriff neben das Feld:
      cout << "feld[" << 10 << "] = " << feld[10] << endl;
    }
  catch( const char *Fehler )
    {
      cerr << "Fehler in main():\n" << Fehler << endl;
    }
  catch( ... )
    {
      cerr << "Unbekannter Fehler in main()\n";
    }
  return 0;
} // main( int nargs, char **args )