ich spiele gerade ein wenig mit INLINE und Klassendefinitionen herum. Das klappt soweit ganz gut, nur wenn ich Klassen in Verbindung mit DGArray verwenden will, habe ich noch einige Probleme, weil die Klassendefinition dann innerhalb von __MainGameSub_ lokal angelegt werden.
Der einzige Weg, wie ich es bisher zu einer fehlerfreien Kompilierung bringen konte, ist, die Klassendefinitionen in eine Header-Datei zu packen und diese z.B. in glb.h einzubinden. Kennt jemand vielleicht noch eine andere Möglichkeit, includes VOR __MainGameSub_ einzubinden?
musst die mainsub erst beenden:
INLINE
}
#include <lala>
namespace __GLBASIC__ {
ENDINLINE
ja, das Beispiel von dir hatte ich mir auch schon angeschaut und probiert, also z.B. Einbinden des Include nach MAIN etc. Hat alles nicht so recht hingehauen. Ist aber auch nicht so wichtig, wie gesagt nur Spielerei.
die maingamesub beendest Du mit:
FUNCTION foo:
ENDFUNCTION
INLINE
}
// hier include
namespace __GLBASIC__ {
ENDINLINE
das ist schon klar, nur wenn die Header-Datei so einbinde, sind die Klassendefinitionen innerhalb von __MainGameSub_ nicht bekannt.
Ich bekomme dann immer die Fehlermeldung "<class> was not declared in this scope"
Prüf auf schreibfehler (gernots post z.b.) vielleicht hast du ja auch einen.
*ggg* ja den Buchstabendreher in Gernots Post habe ich gefunden, aber das schließe ich beim restlichen Coding eigentlich aus. Wie gesagt, wenn ich die Klassendef. in glb.h einbinde per #include, funktioniert es ja. glb.h wird ja letztendlich in gpc_temp.h eingebunden und diese wiederum zu Beginn des Hauptprogrammes gpc_temp0.cpp. Somit ist die Klassendef. ja auch innerhalb von __MainGameSub__ bekannt.
Ach.. kapiert.
Nee, vor die MainGameSub bekommst Du das nicht. Ist aber doch egal, mach halt eine Function "MyMain" oder so...
ähh sorry, verstehe nicht, was mir das bringen soll. Wenn ich die Klassendefinition innerhalb einer Funktion packe, ist sie innerhalb von __MainGameSub__ genau so wenig bekannt?
Nein, Du sollst Sie "unterhalb" eine Funktion packen, damist ist sie global für diese gbas Datei bekannt für allen Code unterhalb des #include's.
Und die MyMain musst Du desshalb unter das INLCUDE packen.
Sollte die gbas keinen MainGame Teil haben, kannst Du "foo" weglassen.
hmmm, bin mir nicht sicher, ob ich dich verstehe. Dachte ich hätte jetzt alle Möglichkeiten durchgespielt, die du und trucidare mir aufgezeigt haben.
Vielleicht ist ein Beispiel besser:
ein einfache Klasse mit den Attributen x, y und einigen Methoden, um diese Attribute zu setzen und zu lesen. Das funktioniert auch wunderbar
INLINE
// Beispielklasse
class cplayer
{
private:
DGInt x;
DGInt y;
public:
cplayer()
{
x = 0;
y = 0;
}
void setxy(DGInt new_x, DGInt new_y)
{
x = new_x;
y = new_y;
}
DGInt getx() { return x; }
DGInt gety() { return y; }
};
ENDINLINE
INLINE
// eine Instanz der Klasse erzeugen
cplayer ship;
ENDINLINE
WHILE TRUE
INLINE
ship.setxy(ship.getx() + 1, ship.gety() + 1);
PRINT(ship.getx(), 0, 0);
PRINT(ship.gety(), 0, 20);
SHOWSCREEN();
ENDINLINE
WEND
Nun will man ja manchmal nicht ein einelnes Objekt, sondern eine ganze Reihe davon (z.B. für feindliche Raumschiffe). Da dachte ich halt in meiner Naivität, ich könnte die Template-Klasse DGArray dazu nutzen (incl. DIM, REDIM, DIMPUSH), um mich nicht selbst um die Verwaltung mit Arrays oder verketteten Listen oder schlimmerem kümmern zu müssen.
mit
DGArray<cplayer> ships;
bekomme ich jedoch die Fehlermeldung
compiling:
C:\DOKUME~1\Thomas\LOKALE~1\Temp\glbasic\gpc_temp0.cpp: In function `int __GLBASIC__::__MainGameSub_()':
C:\DOKUME~1\Thomas\LOKALE~1\Temp\glbasic\gpc_temp0.cpp:49: error: `__GLBASIC__::__MainGameSub_()::cplayer' uses local type `__GLBASIC__::__MainGameSub_()::cplayer'
C:\DOKUME~1\Thomas\LOKALE~1\Temp\glbasic\gpc_temp0.cpp:49: error: trying to instantiate `template<class T> class __GLBASIC__::DGArray'
C:\DOKUME~1\Thomas\LOKALE~1\Temp\glbasic\gpc_temp0.cpp:49: error: invalid type in declaration before ';' token
*** FATAL ERROR - Bitte die Compiler-Ausgabe ins Forum kopieren
Hier noch mal der komplette Code. In der Hilfe ist beschrieben, daß man die Operatoren " und () überladen müsse bei Verwendung von DGArray. Die Meldung bleibt sich jedoch gleich auch ohne die Überladung.
INLINE
// Beispielklasse
class cplayer
{
private:
DGInt x;
DGInt y;
public:
cplayer()
{
x = 0;
y = 0;
}
void setxy(DGInt new_x, DGInt new_y)
{
x = new_x;
y = new_y;
}
DGInt getx() { return x; }
DGInt gety() { return y; }
cplayer& operator = (const cplayer& inp)
{
this->x = inp.x;
this->y = inp.y;
return *this;
}
cplayer& operator () (void) { return *this; }
};
ENDINLINE
INLINE
// eine Instanz der Klasse erzeugen
cplayer ship;
DGArray<cplayer> ships;
ENDINLINE
WHILE TRUE
INLINE
ship.setxy(ship.getx() + 1, ship.gety() + 1);
PRINT(ship.getx(), 0, 0);
PRINT(ship.gety(), 0, 20);
SHOWSCREEN();
ENDINLINE
WEND
Und, wenn ich die Klassendefintion von cplayer in glb.h einbinde, also VOR __MainGameSub__, wird ohne Fehler kompiliert.
sry für Doppelpost, aber das war jetzt ein AHA-Erlebnis ;)
glaube, ich habs jetzt verstanden. Danke Gernot.
so gehts dann:
mymain()
FUNCTION __foo:
ENDFUNCTION
INLINE
// Beispielklasse
class cplayer
{
private:
DGInt x;
DGInt y;
public:
cplayer()
{
x = 0;
y = 0;
}
void setxy(DGInt new_x, DGInt new_y)
{
x = new_x;
y = new_y;
}
DGInt getx() { return x; }
DGInt gety() { return y; }
cplayer& operator = (const cplayer& inp)
{
this->x = inp.x;
this->y = inp.y;
return *this;
}
cplayer& operator () (void) { return *this; }
};
ENDINLINE
FUNCTION mymain:
INLINE
DGArray<cplayer> ships;
ENDINLINE
WHILE TRUE
WEND
ENDFUNCTION