Hilfe beim programmieren eines Moore- Automat

[emmper89]

Hallo Leute...

ich habe folgendes Problem. Ich soll / muss ein Moore- Automat programmieren mit vorgegebenen Header und Quelldatei.
Leider sehe ich in der der vorgegebene Sache überhaupt nicht durch.
Eventuell kann mir ja jemand von euch weiter helfen.

DANKE.

Folgende Vorgaben/ Aufgabe:

Es werden Ihnen Klassen zur Konstruktion von Automaten
vorgegeben (automat.h, automat.cpp).

Von einer ausgewählten Basisklasse ist Ihr Automat abzuleiten
(mittels Vererbung).

Die Methode f()ist entsprechend der Anforderungen
zu überladen.
Das „Zustandsspiel“ Ihres Automaten ist im Hauptprogramm
nachzubilden. Die Ausgabe ist in eine Datei zu schreiben.

Aufgabe:

Ein Moore-Automat erbt aus den Basisklassen:
void init();
Diese Methode ist durch Sie vor der ersten Eingabe und dem
ersten Zeitschritt auszuführen.
int zeitschritt(char e[]);
hier ist ein 2-Zeichen-Array als Eingabevektor E0, E1 zu übergeben,
den Sie vorher entsprechend der für Sie vorgegebenen Eingabe-
sequenz belegen sollen. Die Methode gibt 1 zurück, wenn der
Automat bereits initialisiert wurde, sonst 0.
int ausgabe(char a[]);
hier ist ebenfalls ein 2-Zeichen-Array als Ausgabevektor A0, A1 zu
übergeben. Aus diesem Array können Sie die Ausgabe des
Automaten entnehmen und weiterverarbeiten. Die Methode gibt 1
zurück, wenn der Automat bereits initialisiert wurde, sonst 0.

[code="cpp"]:

Header:

class automat {
private:
bool initialized;
protected:
char E[2], Z[2], Z_neu[2], A[2];
virtual void f()=0; // Zustandsuebergangsfunktion f (E,Z) -> Z_neu;
virtual void g()=0; // Ausgabefunktion g(Z) -> A
virtual void a()=0; // Setzen des Anfangszustands a() -> Z
public:
automat() ;
void init();
bool is_initialized() const;
};

class moore_automat: public automat {
public:
moore_automat();
int zeitschritt(char e[]);
int ausgabe(char a[]);
};

class mealy_automat: public automat {
public:
mealy_automat();
int zeitschritt( char e[], char a[]);

};

automat.cpp:

#include <memory.h>
#include "automat.h"

// --- Methodenimplementation für KLasse automat ---
automat::automat()
{
initialized=false;
}
void automat::init()
{
a();
initialized=true;
}
bool automat::is_initialized() const
{
return initialized;
}

moore_automat::moore_automat(): automat() { }

int moore_automat::zeitschritt(char e[])
{
if (!is_initialized())
return 0;
memcpy(E,e,sizeof(E));
f();
memcpy(Z, Z_neu, sizeof(Z));
return 1;
}
int moore_automat::ausgabe(char a[])
{
if (!is_initialized())
return 0;
g();
memcpy(a,A,sizeof(A));
return 1;
}

mealy_automat::mealy_automat(): automat() { }

int mealy_automat::zeitschritt( char e[], char a[])
{
if (!is_initialized())
return 0;

memcpy(E,e,sizeof(E));
g();
memcpy(a,A,sizeof(A));
f();
memcpy(Z, Z_neu, sizeof(Z));
return 1;
}

Vorlage.cpp:

#include <fstream>
using namespace std;

#include "automat.h"

const int n_schritte=10;
char eingabe_A[10][2] = { {0,1},{0,1},{0,1},{0,1},{0,1},{0,1},{0,1},{0,1},{0,1},{1,1}};

// Definieren Sie hier Ihre Klasse als Spezialisierung von moore_automat
// oder mealy_automat

// Überschreiben Sie die Methoden f(), g(), und a() ensprechend der für Sie
// personalisierten Variante

int main()
{

cout << "Nachbildung eines Automaten" << endl;

// Instanziieren Sie hier Ihre Automaten-Klasse

// Rufen Sie die Methode init() für Ihr Objekt auf

// Simulieren Sie 10 Schritte bei aufeinanderfolgender Eingabe von Vektoren (E[1], E[0])),
// die Sie aus eingabe_A, eingabe_B oder eingabe_C entnehmen.
// Die Eingabedatei wählen Sie bitte entsprechend Ihrer Aufgabenvariante

// Schreiben Sie die Ausgabe Ihres Automaten in eine Textdatei, die für jeden Schritt eine Zeile
// enthalten soll.

return 0;
}

Wäre echt richtig cool, wenn mir das jemand erklären könnte.
Ich sehe echt überhaupt kein STICH...

Danke.