Lektion 70:

Die Klasse Dictionary

Wie bereits erwähnt, soll die Klasse Dictionary bestimmten Werten andere Werte zuordnen. Gute Beispiele dafür sind Wörterbücher oder Telefonbücher. Es werden also Paare, bestehend aus Schlüssel und Wert (z.B. Name und Telefonnummer) abgespeichert. Der erste Ansatz der Klasse Dictionary sieht also so aus:

template<class KEY,class VALUE,class KEY_COMPARATOR=DefaultComparator<KEY> >
class Dictionary
{
};

Zum Testen könnte man folgende main-Funktion verwenden:

void main()
{
   Dictionary<string,int> d;
   d.insert("eins",1);
   d.insert("zwei",2);
   d.insert("drei",3);

   for(int i=0;i<d.getSize();++i)
      cout<<d[i].getKey()<<' '<<d[i].getValue()<<endl;
};

Die Funktionsweise der Klasse Dictionary ist recht einfach. Sie ist eigentlich nur ein SortedArray, das Paare aus Schlüssel und Wert verwaltet. Die Sortierung geschieht nur nach dem Schlüssel. Dafür wird ein geeigneter Comparator sorgen.

Die Klasse Dictionary ist also eine sehr einfache Klasse. Das liegt daran, daß die Klasse SortedArray so mächtig ist. Das einzige, worauf Sie achten müssen, ist bei den vielen Template-Verschachtelungen keinen Lachkrampf zu bekommen.

Für die Paare wird eine eigene Klasse gebildet.

template<class KEY,class VALUE>
class DictionaryEntry
{
private:
   KEY m_key;
   VALUE m_value;
public:
   DictionaryEntry()
   {
   };
   DictionaryEntry(const KEY &key,const Value &value)
      :m_key(key),m_value(value)
   {
   };
   const KEY &getKey()
   {
      return key;
   };
   Value &getValue()
   {
      return value;
   };
};

Beachten Sie das const. Es soll dafür sorgen, daß kein Benutzer der Klasse den Schlüssel nachträglich verändern kann, weil das die Sortierung durcheinander bringen würde. Der Wert (z.B. die Telefonnummer) kann beliebig verändert werden, weil er mit der Sortierung nichts zu tun hat.

Der Comparator ist auch nicht schwierig.

template<class KEY,class VALUE,class KEY_COMPARATOR>
class DictionaryEntryComparator
{
private:
   KEY_COMPARATOR m_comp;
public:
   bool lessThan(const DictionaryEntry<KEY,VALUE> &a,const DictionaryEntry<KEY,VALUE> &b)
   {
      return m_comp.lessThan(a.getKey(),b.getKey());
   };
   bool isEqual(const DictionaryEntry<KEY,VALUE> &a,const DictionaryEntry<KEY,VALUE> &b)
   {
      return m_comp.isEqual(a.getKey(),b.getKey());
   };
};

Mit allem Notwendigen ausgerüstet, kann jetzt an der Klasse Dictionary weitergearbeitet werden. Sie braucht als Attribut ein SortedArray, das als Werte DictionaryEntries verwaltet und als Comparator einen DictionaryEntryComparator verwendet.

template<class KEY,class VALUE,class KEY_COMPARATOR=DefaultComparator<KEY> >
class Dictionary
{
private:
   SortedArray
   <
      DictionaryEntry<KEY,VALUE>,
      DictionaryEntryComparator<KEY,VALUE,KEY_COMPARATOR> 
   > m_data;
};

Weil die Zeile etwas lang geworden ist, habe ich sie auf fünf Zeilen aufgeteilt. Eigentlich ist das nur eine Zeile.

Die eigenen Methoden in der Klasse Dictionary beschränken sich darauf, die entsprechenden Methoden der Klasse SortedArray aufzurufen.

   void insert(const KEY &key,const VALUE &value)
   {
      m_data.insert(DictionaryEntry<KEY,VALUE>(key,value));
   };
   int getSize()
   {
      return m_data.getSize();
   };
   DictionaryEntry<KEY,VALUE> &operator[](int index)
   {
      return m_data[index];
   };

Bis auf ein paar kleine Fehler, die alle mit dem Wort const zusammenhängen ist damit die Klasse Dictionary schon einsetzbar. Das war doch ein toller Spaß mit Templates!



Falls Ihnen Fehler im Text auffallen oder Sie Verbesserungsvorschläge haben, dann schicken Sie mir bitte eine Mail. Ich werde mich dann sofort darum kümmern.
[aktuelle Version] [inhalt] [index]      [Fehlerkorrektur, Verbesserungsvorschlag]

© Volkard Henkel <volkard@normannia.de>, last update: 08/25/00