Wenn fertig, bitte Fenster schließen

Beispiel Safe-Array

Das Safe-Array wird durch die (minimale) Klasse SaveArray realisiert. Diese Klasse überlädt den Indexoperator [ ] um die indizierten Zugriffe auf die Elemente zu kontrollieren. Dazu erhält der Konstruktor die Anzahl der Elemente, speichert sich diese ab und erstellt dann das erforderliche Feld.

Wird nun indiziert auf dieses Safe-Array zugegriffen, so erfolgt innerhalb des überladenen Indexoperators eine entsprechende Bereichsüberprüfung. Im Beispiel wird beim Über- bzw. Unterschreiten der Feldgrenzen eine Meldung ausgegeben und der Wert des ersten bzw. letzten Feldelements zurückgegeben. In der Praxis ist dies ein Fall für eine Ausnahme, die aber erst später erläutert wird.

In main() wird dann ein Safe-Array erstellt und mit Werten gefüllt. Beim Auslesen der Elemente wird jetzt versucht, über die obere Feldgrenze hinaus zuzugreifen, was dann auch mit einer Fehlermeldung quittiert wird. Aber nicht nur die Lesezugriffe werden kontrolliert sondern auch die Schreibzugriffe. Solche fehlerhaften Schreibzugriffe auf ein Feld sind besonders kritisch, da sie ein undefiniertes Verhalten des Programms zur Folge haben können. Um dies zu demonstrieren wird im Programm versucht, das Element -1 zu beschreiben. Und dieser Schreibzugriff wird ebenfalls mit einer Fehlermeldung quittiert. Im Beispiel wird beim Schreiben auf ein unzulässiges Element entweder das erste bzw. das letzte Feldelement überschrieben. Aber wie schon erwähnt, in einer realen Anwendung würden Sie in diesem Fall eine Ausnahme auslösen.

PgmHeader// Beispiel für ein Safe-Array
// Hinweis: Diese Beispiel dient nur zur Demonstration
// des ueberladenen Index-Operators. Wollen Sie diese Klasse
// real einsetzen, so müssen Sie noch den copy-ctor und den
// Zuweisungsoperator entsprechend implementieren.

// Zuerst Dateien einbinden

#include <iostream>

using std::cout;
using std::endl;

// Klassendefinition des Safe-Arrays
class SafeArray
{
    short   size;           // Grösse des Feldes
    short   *pData;         // Zeiger auf Datenfeld
public:
    SafeArray(short size);
    ~SafeArray();
    short& operator[] (int index);
};
// Definition der Memberfunktionen
// Konstruktor

SafeArray::SafeArray(short s)
{
    size = s;                  // Grösse des Feldes merken
    pData = new short[size];   // Feld anlegen
}
// Destruktor
SafeArray::~SafeArray()
{
    delete [] pData;           // Feld freigeben
}
// Überladener Indexoperator
short& SafeArray::operator [](int index)
{
    // Falls Index kleiner 0 ist
    if (index<0)
    {
        cout << "Index kleiner 0!\n";
        return pData[0];
    }
    // Falls Index über das Feld hinausgreift
    if (index>=size)
    {
        cout << "Index ueberschreitet obere Grenze!\n";
        return pData[size-1];
    }
    // Referenz auf Datum zurückgeben
    return pData[index];
}

// main() Funktion
int main()
{
    const short ARRAYSIZE = 10;     // Feldgrösse
    short   loop;                   // Schleifenzähler

    // Feldobjekt mit 10 Einträgen anlegen
    SafeArray myArray(ARRAYSIZE);

    // Feld füllen
    for (loop=0; loop<ARRAYSIZE; loop++)
        myArray[loop] = loop;

    // Feld wieder auslesen
    // Es wird hier versucht hinter das Feld zu greifen

    for (loop=0; loop<=ARRAYSIZE; loop++)
        cout << loop << ". Wert: " << myArray[loop] << endl;

    // Versuch das Element mit dem Index -1 zu beschreiben
    cout << "Versuch das Element -1 zu beschreiben!\n";
    myArray[-1] = 111;
    // Erstes Element ausgeben
    cout << "Erstes Element nun " << myArray[0] << endl;
}
Programmausgabe0. Wert: 0
1. Wert: 1
2. Wert: 2
3. Wert: 3
4. Wert: 4
5. Wert: 5
6. Wert: 6
7. Wert: 7
8. Wert: 8
9. Wert: 9
Index überschreitet obere Grenze!
10. Wert: 9
Versuch das Element -1 zu beschreiben!
Index kleiner 0!
Erstes Element nun 111