6.1.4 C++-Version

// Time-stamp: "(13.05.02 22:39) SucheStudenten.cpp [Klaus@Wachtler.de]" /*   1 */
//                                                                       /*   2 */
// Demonstriert eine Containerklasse in C++ (realisiert als template)    /*   3 */
                                                                         /*   4 */
#include <iostream>                                                      /*   5 */
#include <string>                                                        /*   6 */
                                                                         /*   7 */
using namespace std;                                                     /*   8 */
                                                                         /*   9 */
// Klasse der einzelnen Elemente:                                        /*  10 */
class Student                                                            /*  11 */
{                                                                        /*  12 */
public:                                                                  /*  13 */
                                                                         /*  14 */
  // Konstruktor                                                         /*  15 */
  Student( string v = "", string n = "", int m = -1 )                    /*  16 */
    : Vorname(v ),                                                       /*  17 */
      Nachname( n ),                                                     /*  18 */
      Matrikelnummer( m )                                                /*  19 */
  {                                                                      /*  20 */
  }                                                                      /*  21 */
                                                                         /*  22 */
  // copy-Konstruktor                                                    /*  23 */
  Student( const Student &rechteSeite )                                  /*  24 */
    : Vorname( rechteSeite.Vorname ),                                    /*  25 */
      Nachname( rechteSeite.Nachname ),                                  /*  26 */
      Matrikelnummer( rechteSeite.Matrikelnummer )                       /*  27 */
  {                                                                      /*  28 */
  }                                                                      /*  29 */
                                                                         /*  30 */
  // Destruktor                                                          /*  31 */
  virtual ~Student()                                                     /*  32 */
  {                                                                      /*  33 */
  }                                                                      /*  34 */
                                                                         /*  35 */
  // Zuweisung Student = Student                                         /*  36 */
  Student & operator=( const Student &rechteSeite )                      /*  37 */
  {                                                                      /*  38 */
    Vorname = rechteSeite.Vorname;                                       /*  39 */
    Nachname = rechteSeite.Nachname;                                     /*  40 */
    Matrikelnummer = rechteSeite.Matrikelnummer;                         /*  41 */
                                                                         /*  42 */
    return *this;                                                        /*  43 */
  }                                                                      /*  44 */
                                                                         /*  45 */
  // Ausgabe auf einen ostream                                           /*  46 */
  virtual void streamout( ostream & s ) const                            /*  47 */
  {                                                                      /*  48 */
    s << Vorname;                                                        /*  49 */
    s << ",";                                                            /*  50 */
    s << Nachname;                                                       /*  51 */
    s << ",";                                                            /*  52 */
    s << Matrikelnummer;                                                 /*  53 */
  }                                                                      /*  54 */
                                                                         /*  55 */
  // Kopie von sich selbst allokieren                                    /*  56 */
  virtual Student &clone() const                                         /*  57 */
  {                                                                      /*  58 */
    return *(new Student(*this));                                        /*  59 */
  }                                                                      /*  60 */
                                                                         /*  61 */
  bool operator==( const Student &rS ) const                             /*  62 */
  {                                                                      /*  63 */
    return Matrikelnummer==rS.Matrikelnummer;                            /*  64 */
  }                                                                      /*  65 */
                                                                         /*  66 */
protected:                                                               /*  67 */
                                                                         /*  68 */
                                                                         /*  69 */
private:                                                                 /*  70 */
                                                                         /*  71 */
  // Nutzdaten:                                                          /*  72 */
  string Vorname;                                                        /*  73 */
  string Nachname;                                                       /*  74 */
  int    Matrikelnummer;                                                 /*  75 */
                                                                         /*  76 */
                                                                         /*  77 */
}; // class Student...                                                   /*  78 */
                                                                         /*  79 */
// ggf. nach Student.cpp kopieren:                                       /*  80 */
ostream &operator<<( ostream &s, const Student &obj )                    /*  81 */
{                                                                        /*  82 */
  obj.streamout( s );                                                    /*  83 */
  return s;                                                              /*  84 */
}                                                                        /*  85 */
                                                                         /*  86 */
                                                                         /*  87 */
template <class T> class Feld                                            /*  88 */
{                                                                        /*  89 */
public:                                                                  /*  90 */
                                                                         /*  91 */
  // Konstruktor                                                         /*  92 */
  Feld( int n = 0 )                                                      /*  93 */
    : Nutzdaten( NULL ),                                                 /*  94 */
      Anzahl( n )                                                        /*  95 */
  {                                                                      /*  96 */
    if( n>0 )                                                            /*  97 */
    {                                                                    /*  98 */
      Nutzdaten = new T[n];                                              /*  99 */
    }                                                                    /* 100 */
  }                                                                      /* 101 */
                                                                         /* 102 */
  // Destruktor                                                          /* 103 */
  virtual ~Feld()                                                        /* 104 */
  {                                                                      /* 105 */
    delete[] Nutzdaten;                                                  /* 106 */
  }                                                                      /* 107 */
                                                                         /* 108 */
  void setzeElement( int index, const T &t )                             /* 109 */
  {                                                                      /* 110 */
    Nutzdaten[index] = t;                                                /* 111 */
  }                                                                      /* 112 */
                                                                         /* 113 */
  const T&sucheLinear( const T&key ) const                               /* 114 */
  {                                                                      /* 115 */
    for( int i=0; i<Anzahl; i++ )                                        /* 116 */
    {                                                                    /* 117 */
      if( key==Nutzdaten[i] )                                            /* 118 */
      {                                                                  /* 119 */
        return Nutzdaten[i];                                             /* 120 */
      }                                                                  /* 121 */
    }                                                                    /* 122 */
    throw "nix gefunden!";                                               /* 123 */
  }                                                                      /* 124 */
                                                                         /* 125 */
private:                                                                 /* 126 */
                                                                         /* 127 */
  // Nutzdaten                                                           /* 128 */
  T    *Nutzdaten;                                                       /* 129 */
                                                                         /* 130 */
  // Anzahl der Elemente:                                                /* 131 */
  int   Anzahl;                                                          /* 132 */
                                                                         /* 133 */
                                                                         /* 134 */
}; // class Feld...                                                      /* 135 */
                                                                         /* 136 */
                                                                         /* 137 */
                                                                         /* 138 */
int main( int nargs, char **args )                                       /* 139 */
{                                                                        /* 140 */
  try                                                                    /* 141 */
  {                                                                      /* 142 */
    Feld<Student>  f( 5 );                                               /* 143 */
    f.setzeElement( 0, Student( "Kurt", "Pappnase", 978123 ) );          /* 144 */
    f.setzeElement( 1, Student( "Hein", "Meier", 987456 ) );             /* 145 */
    f.setzeElement( 2, Student( "Fritz", "Schmidt", 998159 ) );          /* 146 */
    f.setzeElement( 3, Student( "Klaus", "Lahm", 988123 ) );             /* 147 */
    f.setzeElement( 4, Student( "Sina", "Flink", 977111 ) );             /* 148 */
                                                                         /* 149 */
    cout << " gefunden: "                                                /* 150 */
         << f.sucheLinear( Student( "", "", 988123 ) )                   /* 151 */
         << endl;                                                        /* 152 */
  }                                                                      /* 153 */
  catch( const char *Fehler )                                            /* 154 */
  {                                                                      /* 155 */
    cerr << Fehler << "\n";                                              /* 156 */
  }                                                                      /* 157 */
  catch( ... )                                                           /* 158 */
  {                                                                      /* 159 */
    cerr << "???\n";                                                     /* 160 */
  }                                                                      /* 161 */
                                                                         /* 162 */
                                                                         /* 163 */
  return 0;                                                              /* 164 */
} // main( int nargs, char **args )                                      /* 165 */



www.wachtler.de