OOP mit Java: Templates in C++

als abstrakte Klasse ohne Implementierungsteil

template <class E>
class Stack {
 
public:
 
  //--------------------
  // die Attribut-Funktionen
 
  virtual
  int isEmpty() const = 0;
 
  virtual
  E & top() const = 0;
 
  //--------------------
  // die modifizierenden Funktionen
 
  virtual
  Stack<E> & push(E & e) = 0;
 
  virtual
  Stack<E> & pop() = 0;
 
  //--------------------
  // die Vorbedingungen
 
  virtual
  int pre_pop() {
    return
      ! isEmpty();
  }
 
  virtual
  int pre_top() {
    return
      ! isEmpty();
  }
 
  //--------------------
  // der Destruktor
 
  virtual
  ~Stack() {}
};
 

mit konkreter Implementierung und Instanziierung

#include "TemplateStack.cc"
 
template <class E>
class SimpleStack : public Stack<E> {
 
private:
 
  // die Datenfelder: nicht nach aussen sichtbar
 
  struct StackStruct {
    unsigned top;
    E  elems[100];
  } * s;
 
public:
 
  //--------------------
  // der Konstruktor
 
  SimpleStack() {
    s = new StackStruct;
    s->top = 0;
  }
 
  //--------------------
  // der Destruktor
 
  ~SimpleStack() {
    delete s;
  }
 
  //--------------------
  // die Attribut-Funktionen
 
  virtual
  int isEmpty() const {
    return
      s->top == 0;
  }
 
  virtual
  E & top() const {
    return
      s->elems[s->top-1];
  }
 
  //--------------------
  // die modifizierenden Funktionen
 
  virtual
  Stack<E> & push(E & e) {
    s->elems[s->top++] = e;
    return
      *this;
  }
 
  virtual
  Stack<E> & pop() {
    s->top--;
    return
      *this;
  }
 
  // Vorbedingungen sind schon implementiert
};
 
//--------------------
// ein int Stack
 
typedef SimpleStack<int> SimpleIntStack;
 
// ein double Stack
 
typedef SimpleStack<double> SimpleDoubleStack;

Templates in C++

Ein template Stack in C++

Ein template Stack in C++