újra kifogott rajtam a gcc (g++)

Kedves Fórumozók!

Egy példaprogramot kellene irnom c++ban, de sajnos nem tudom mi lehet, a gond és miért nem fordul le és hogy hogyan tudnám megjavitani. A lényeg az lenne, hogy warning nélkül forduljon -Wall-al, és még működjön is. Ez amúgy egy ilyen kis DFA természetes szám felismerő példaprogram lenne.

Ezt a hibaüzenetet kapom:
janos@janos_mobil:~/Desktop/botondos/01$ make
gcc -c exception.cpp -Wall -O2 -o exception.o
gcc -c dfa.cpp -Wall -O2 -o dfa.o
In file included from dfa.cpp:2:
dfa.hpp:15: error: parse error before `&' token
dfa.hpp:17: error: parse error before `&' token
dfa.hpp:32: error: parse error before `&' token
dfa.cpp:48: error: prototype for `bool basicDFA::checkIfAccepted(const
std::string&) const' does not match any in class `basicDFA'
dfa.hpp:17: error: candidate is: bool basicDFA::checkIfAccepted(...) const
dfa.cpp:85: error: prototype for `bool cardinalNumbersDFA::acceptedByDFA(const
std::string&) const' does not match any in class `cardinalNumbersDFA'
dfa.hpp:32: error: candidate is: virtual bool
cardinalNumbersDFA::acceptedByDFA(...) const
make: *** [dfa] Error 1
janos@janos_mobil:~/Desktop/botondos/01$

A fájlok pedig innen elérhetők/letölthetők: http://chaosrider.uw.hu/stuff/janos_01.tgz

Ha valaki tudna valami jó ötlete, annak nagyon tudnék örülni.
Üdv:
János

Illetve a fájlokat berakom ide is, tehát:

dfa.cpp:

#include
#include "dfa.hpp"
#include "exception.hpp"

basicDFA::basicDFA() {
numberOfStates = 0;
initialState = 0;
finalStates = 0;
transitionMap = 0;
}

basicDFA::~basicDFA() {
cout << "Called!" << endl;
if (finalStates != 0) delete finalStates;

if ((transitionMap != 0) && (numberOfStates != 0)) {
for (int i=0;i
delete transitionMap[i];
}
delete transitionMap;
}

}

void basicDFA::initializeTransitionMap() {
if ((transitionMap != 0) || (numberOfStates == 0)) return;
transitionMap = new int*[numberOfStates];

if (transitionMap == 0) throw new outOfMemoryException();

for (int i=0;i
transitionMap[i] = new int[CHARSET_SIZE];
if (transitionMap[i] == 0) throw new outOfMemoryException();
memset(transitionMap[i], -1, CHARSET_SIZE);
}
}

void basicDFA::initializeFinalStates() {
if ((finalStates != 0) || (numberOfStates == 0)) return;

finalStates = new int[numberOfStates];

if (finalStates == 0) throw new outOfMemoryException();

memset(transitionMap, false, numberOfStates);
}

bool basicDFA::checkIfAccepted(const string & input) const {
int currentState = initialState;
if (currentState >= numberOfStates) throw invalidInitialStateException();
if ((numberOfStates == 0) || (initialState == 0) || (finalStates == 0) || (transitionMap == 0)) return false;
size_t inputLength = input.length();
for (size_t i=0;i

currentState = transitionMap[currentState][ (unsigned) input[i]];
if (currentState == -1) throw uninitializedTransitionException();
if ((currentState < 0) || (currentState >= numberOfStates)) throw invalidTransitionException();
}
if (finalStates[currentState] == true) return true;
else return false;
}

/*-------------------- Cardinal Numbers --------------------*/
cardinalNumbersDFA::cardinalNumbersDFA() {
numberOfStates = 3;
initialState = 0;
initializeFinalStates();
finalStates[1] = true;
initializeTransitionMap();

for (unsigned i=0;i
for (unsigned i=0;i<9;i++) transitionMap[0][(unsigned) ('1'+i)] = 1;

for (unsigned i=0;i
for (unsigned i=0;i<10;i++) transitionMap[1][(unsigned) ('0'+i)] = 1;

for (unsigned i=0;i
}

cardinalNumbersDFA::~cardinalNumbersDFA() {
//basicDFA::~basicDFA();
}

bool cardinalNumbersDFA::acceptedByDFA(const string &input) const {
return basicDFA::checkIfAccepted(input);
}

//-------------------------------------------------------------------------

dfa.hpp:

#ifndef __DFA_HPP__
#define __DFA_HPP__

#include

using namespace std;

const unsigned int CHARSET_SIZE = 256; //Let's assume ANSI

class basicDFA {
public:
basicDFA();
virtual ~basicDFA();

virtual bool acceptedByDFA(const string &) const = 0;
protected:
bool checkIfAccepted(const string &) const;
void initializeTransitionMap();
void initializeFinalStates();

int numberOfStates;
int initialState;
int *finalStates;
int **transitionMap;
};

class cardinalNumbersDFA: public basicDFA {
public:
cardinalNumbersDFA();
~cardinalNumbersDFA();

bool acceptedByDFA(const string &) const;
};

#endif //__DFA_HPP__

//-------------------------------------------------------------------------

exception.cpp:

#include "exception.hpp"

basicException::basicException() {
}

basicException::~basicException() {
}

void basicException::printMessage() const {
cerr << msg;
}

outOfMemoryException::outOfMemoryException() : basicException::basicException() {
msg = "\nOut of memory...\nThe program will now terminate...\n";
}

outOfMemoryException::~outOfMemoryException() {
}

void outOfMemoryException::dumpInfo() const {
basicException::printMessage();
}

invalidInitialStateException::invalidInitialStateException() : basicException::basicException() {
msg = "\nInvalid initial state...\nThe program will now terminate...\n";
}

invalidInitialStateException::~invalidInitialStateException() {
}

void invalidInitialStateException::dumpInfo() const {
basicException::printMessage();
}

uninitializedTransitionException::uninitializedTransitionException() : basicException::basicException() {
msg = "\nAn uninitialized transition was encountered...\nThe program will now terminate...\n";
}

uninitializedTransitionException::~uninitializedTransitionException() {
}

void uninitializedTransitionException::dumpInfo() const {
basicException::printMessage();
}

invalidTransitionException::invalidTransitionException() : basicException::basicException() {
msg = "\nAn invalid transition was encountered...\nThe program will now terminate...\n";
}

invalidTransitionException::~invalidTransitionException() {
}

void invalidTransitionException::dumpInfo() const {
basicException::printMessage();
}

//-------------------------------------------------------------------------

exception.hpp:

#ifndef __EXCEPTION_HPP__
#define __EXCEPTION_HPP__

#include
#include

using namespace std;

class basicException {
public:
basicException();
virtual ~basicException();

virtual void dumpInfo() const = 0;
protected:
void printMessage() const;

string msg;
};

class outOfMemoryException: public basicException {
public:
outOfMemoryException();
~outOfMemoryException();

void dumpInfo() const;
};

class invalidInitialStateException: public basicException {
public:
invalidInitialStateException();
~invalidInitialStateException();

void dumpInfo() const;
};

class uninitializedTransitionException: public basicException {
public:
uninitializedTransitionException();
~uninitializedTransitionException();

void dumpInfo() const;
};

class invalidTransitionException: public basicException {
public:
invalidTransitionException();
~invalidTransitionException();

void dumpInfo() const;
};

#endif //__EXCEPTION_HPP__

//-------------------------------------------------------------------------

main.cpp:

#include
#include
#include "dfa.hpp"
#include "exception.hpp"

using namespace std;

int main() {
cout << "Hello World!" << endl;
try {
basicDFA *a = new cardinalNumbersDFA();
if ( a->acceptedByDFA("1234567890") == true) cout << "OK." << endl;
else cout << "Failed!" << endl;
}
catch (basicException *e) {
e->dumpInfo();
delete e;
return -1;
}
return 0;
}

//-------------------------------------------------------------------------

Makefile:

# Copyright (c) János Szigetvári, 2006.
# 2006-07-08
#

# OPTIONS
CC = gcc

WARNINGS = -Wall
OPTIMIZATION = -O2
OUTFILESPEC = -o
COMPILEONLY = -c
LINKONY =

REMOVE = rm -f

# COMMANDS
binary: main
$(CC) $(LINKONLY) main.o dfa.o exception.o $(WARNINGS) $(OPTIMIZATION) $(OUTFILESPEC) botondos01.bin
$(REMOVE) *.o

main: dfa exception
$(CC) $(COMPILEONLY) main.cpp $(WARNINGS) $(OPTIMIZATION) $(OUTFILESPEC) main.o

dfa: dfa.hpp exception
$(CC) $(COMPILEONLY) dfa.cpp $(WARNINGS) $(OPTIMIZATION) $(OUTFILESPEC) dfa.o

exception: exception.hpp
$(CC) $(COMPILEONLY) exception.cpp $(WARNINGS) $(OPTIMIZATION) $(OUTFILESPEC) exception.o

clean:
$(REMOVE) *.o