spieleprogrammierer.de - Forum und Wiki zur Spieleprogrammierung und Spieleentwicklung

C-/C++-Quelltext

:

#include <iostream.h>
#include <conio.h>

const int DefaultSize = 10;

class Array
{
    public:
       // Konstruktoren

      Array(int itsSize = DefaultSize);
      Array(const Array &rhs);
      ~Array() { delete [] pType;}

      // Operatoren

      Array& operator=(const Array&);
      int& operator[](int offSet);
      const int& operator[](int offSet) const;

      // Zugriffsfunktionen

      int GetitsSize() const { return itsSize; }

      // Friend-Funktion

      friend ostream& operator<< (ostream&, const Array&);

      // Exception-Klassen definieren

      class xBoundary {};
      class xSize
      {

          public:
             xSize(int size):itsSize(size) {}
            ~xSize(){}
            int GetSize() { return itsSize; }
         private:
            int itsSize;
        };

      class xTooBig : public xSize
      {
          public:
             xTooBig(int size):xSize(size){}
      };

       class xTooSmall : public xSize
      {
         public:
            xTooSmall(int size):xSize(size){}
      };

      class xZero  : public xTooSmall
      {
         public:
            xZero(int size):xTooSmall(size){}
      };

      class xNegative : public xSize
      {
         public:
            xNegative(int size):xSize(size){}
      };

    private:
         int *pType;
         int  itsSize;
};


Array::Array(int size):
itsSize(size)
{
    if (size == 0)
       throw xZero(size);
   if (size > 30000)
       throw xTooBig(size);
   if (size <1)
       throw xNegative(size);
   if (size < 10)                                                          //Hier wird die ausnahme erstellt

       throw xTooSmall(size);

   pType = new int[size];
    for (int i = 0; i<size; i++)
       pType[i] = 0;
}


int& Array::operator[] (int offSet)
{
    //int size = GetitsSize();

   if (offSet >= 0 && offSet < GetitsSize())
       return pType[offSet];
   throw xBoundary();
   // return pType[0];

}

const int& Array::operator[] (int offSet) const
{
    // int size = GetitsSize();

   if (offSet >= 0 && offSet < GetitsSize())
       return pType[offSet];
   throw xBoundary();
   //   return pType[0];

}

int main()
{


    try
   {
       Array intArray(8);
      for (int j = 0; j< 100; j++)

      {
          intArray[j] = j;
         cout << "intArray[" << j << "] OK..." << endl;
      }
   }
   catch (Array::xBoundary)
   {
       cout << "Kann Ihre Eingabe nicht verarbeiten.\n";
   }
   catch (Array::xZero theException)
   {
       cout << "Array von null Objekten angefordert." << endl;
      cout << "Empfangen " << theException.GetSize() << endl;
   }
   catch (Array::xTooBig theException)
   {
       cout << "Dieses Array ist zu groß..." << endl;
      cout << "Empfangen " << theException.GetSize() << endl;
   }
   catch (Array::xTooSmall theException)
   {
       cout << "Dieses Array ist zu klein..." << endl;
      cout << "Empfangen " << theException.GetSize() << endl;
   }
   catch (...)
   {
       cout << "Etwas ist schiefgelaufen. Keine Ahnung, was!\n";
   }

   cout << "Fertig.\n";

       getch();

   return 0;

//geht zu return - leider keine ahnung warum - nachdem das ausnahmeobjekt erstellt wurde //und will den destruktor aufrufen. dieses führt zu einer fehlermeldung und das programm //stürzt ab

}

C-/C++-Quelltext

using namespace std;
//Wäre es so nicht noch perfekter???