Klassenschablonen

        Ziel: Definition generischer Klassen

Beispiel:

    template <class T, int size> class array
    { private : T inhalt[size];
      public:   array(T);
                void print();
                int getsize() {return size;}
    };
    template <class T, int size> 
    array<T,size>::array(T elemval)
    { for (int i = 0; i < size; i++)
        inhalt[i] = elemval;
    }
    template <class T, int size> 
    void array<T,size>::print()
    { for (int i = 0; i < size; i++)
        cout << inhalt[i] << " ";
    }
    
    int main()
    { array<char,10> carray('p');
      carray.print();
      array<double,7> darray(12.0);
      darray.print();
    }

• Eine Deklaration einer Schablonenklasse hat die folgende Form:

       template <class T, int size> class array;

• Die Klasse heißt

       array<T, size>

  Das wird gebraucht z.B. in der Definition der Elementfunktionen:

      // der einstellige Konstruktor
      array<T,size>::array(T elemval)

• Elementfunktionen, Konstruktoren und Destruktoren, die außerhalb der Schablonenklassen-Definition geschrieben werden, sind als Schablonenfunktionen zu formulieren:

      template <class T, int size> 
      void array<T,size>::print()
      { for (int i = 0; i < size; i++)
          cout << inhalt[i] << " ";
      }

• Auch normale Funktionen, die Schablonenklassen als Parametertypen haben, werden zu Schablonenfunktionen:

      template <class T, int size>   
      // z.Z. nur fuer g++ 
      void printsize(array<T,size> a)
      { cout << a.getsize();
      }

• Um Objekte und Funktionen mit Schablonenklassenparametern zu kreieren muß angegeben werden:
  • für Typparameter: der konkrete Typ
  • für andere Parameter: konstante Ausdrücke, deren Typ exakt mit der Schablone übereinstimmt.

  void printsize(array<char,100> a)
  { cout << "noe";
  }
  
  int main()
  { array<double,7> darray(12.0);
    array<char,100> carray(' ');
    printsize(carray);
  }

Ein vollständiges Beispiel

#include <iostream.h>

template <class T>      // declaration tset
class tset;             // (forward)

template <class T>      // definition elem
class elem
{ friend class tset<T>; // tset uses these linked
private:                // lists to represent sets
  T val;                // the element value
  elem* next;           // pointer to next list elem
public:
  elem() : val((T)0), next(0) {}   // default constr.
  elem(T v, elem* n);   // constructor
  ~elem();              // destructor
};

template <class T>   // definition tset
class tset
{ private: elem<T>* objects;   // element list
  public: tset();              // default constructor
          ~tset();             // destructor
          int in(T e);         // member test
          void add(T e);       // adds an element
          void printset(void); // output set
};

template <class T>  // print T objects
void print(T e)     // ordinary template function
{ cout << e; 
}

template <class T>      // constructor
elem<T>::elem(T v, elem<T>* n) 
: val(v), next(n)        
{}

template <class T>   // destructor
elem<T>::~elem() 
{ val = 0;
  next = 0;
}

template <class T>   // default constructor
tset<T>::tset() : objects(0) 
{ 
}

template <class T>   // destructor
tset<T>::~tset()
{ elem<T> *optr;
  while (objects)
    { optr = objects;
      objects = objects->next;
      delete optr;
    }
}

template <class T>   // check if e is in set
int tset<T>::in(T e)
{ elem<T> *optr = objects;
  while (optr)
  { if (optr->val == e)
     return 1;
    optr=optr->next;
  }
  return 0;
}

template <class T>   // add element to set
void tset<T>::add(T e)
{ if (!in(e))
  {  elem<T> *eptr = new elem<T>(e, objects);
     objects=eptr;
  }
}

template <class T>   // print all set elements
void tset<T>::printset(void)
{ elem<T> *optr = objects;
  while (optr)
  { print(optr->val);
    cout << endl;
    optr=optr->next;
  }
}

int main()               
{ tset<int> s;
  int i;
  while (cin >> i)   // read integers 
    s.add(i);        // add them to set
  s.printset();      // print set
  cout << endl;
}