Für eine GUI wollt ich gern SDL und Guichan verwenden. Hab nun eine Factory für Views und das ganze mal mit den Standardein- und ausgaben umgesetzt. Soweit so gut.

Für eine SDL Anwendung muss ich ja einiges initialisieren und Ressourcen (Zeiger, Screenobjekte, Bitmaps und Fonts, etc..) anfordern und wieder ordentlich freigeben.

1. Mach ich nun die Initialisierung in den Ctor und das Aufräumen in den Dtor der Factory oder lass ich den eine andere Klasse aufrufen, die sich darum kümmert?
2. Sollte ich für jedes Bitmap etc. eine eigene, Ressourcen verwaltende Klasse machen oder würdet ihr das alle in eine gemeinsame (ev. die gleiche wie in 1.?) packen?

Bitte habt Nachsicht, ich versuch mir selbst gutes Design beizubringen, und wär sehr froh um Tipps von Provis

Danke im voraus
Grüsse
Sebi

PS: Hier noch die Init. und Aufräum Funktionen aus dem Tutorial. Diesen Code möcht ich schön verpacken, globale Variablen und Zeiger mit new/delete loswerden:

/*
 * SDL Stuff we need
 */
SDL_Surface* screen;
SDL_Event event;

/*
 * Guichan SDL stuff we need
 */
gcn::SDLInput* input;             // Input driver
gcn::SDLGraphics* graphics;       // Graphics driver
gcn::SDLImageLoader* imageLoader; // For loading images

/*
 * Guichan stuff we need
 */
gcn::Gui* gui;            // A Gui object - binds it all together
gcn::Container* top;      // A top container
gcn::ImageFont* font;     // A font
gcn::Label* label;        // And a label for the Hello World text

/**
 * Initializes the Hello World
 */
void init()
{
	/*
	 * Here we initialize SDL as we would do with any SDL application.
	 */
	SDL_Init(SDL_INIT_VIDEO);
	screen = SDL_SetVideoMode(640, 480, 32, SDL_HWSURFACE);
	// We want unicode
	SDL_EnableUNICODE(1);
	// We want to enable key repeat
	SDL_EnableKeyRepeat(SDL_DEFAULT_REPEAT_DELAY, SDL_DEFAULT_REPEAT_INTERVAL);

	/*
	 * Now it's time for Guichan SDL stuff
	 */
	imageLoader = new gcn::SDLImageLoader();
	// The ImageLoader in use is static and must be set to be
	// able to load images
	gcn::Image::setImageLoader(imageLoader);
	graphics = new gcn::SDLGraphics();
	// Set the target for the graphics object to be the screen.
	// In other words, we will draw to the screen.
	// Note, any surface will do, it doesn't have to be the screen.
	graphics->setTarget(screen);
	input = new gcn::SDLInput();

	/*
	 * Last but not least it's time to initialize and create the gui
	 * with Guichan stuff.
	 */
	top = new gcn::Container();
	// Set the dimension of the top container to match the screen.
	top->setDimension(gcn::Rectangle(0, 0, 640, 480));
	gui = new gcn::Gui();
	// Set gui to use the SDLGraphics object.
	gui->setGraphics(graphics);
	// Set gui to use the SDLInput object
	gui->setInput(input);
	// Set the top container
	gui->setTop(top);
	// Load the image font.
	font = new gcn::ImageFont("fixedfont.bmp", " abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ0123456789");
	// The global font is static and must be set.
	gcn::Widget::setGlobalFont(font);

	// Create a label with test hello world
	label = new gcn::Label("Hello World");
	// Set the labels position
	label->setPosition(280, 220);
	// Add the label to the top container
	top->add(label);
}

/**
 * Halts the application
 */
void halt()
{
	/*
	 * Destroy Guichan stuff
	 */
	delete label;
	delete font;
	delete top;
	delete gui;

	/*
	 * Destroy Guichan SDL stuff
	 */
	delete input;
	delete graphics;
	delete imageLoader;

	/*
	 * Destroy SDL stuff
	 */
	SDL_Quit();
}

Dtoren funktionieren aber implizit. Daher sind die zum aufräumen vorzuziehen...

seperate funktionen zum releasen sind OK, sogar gut (laut irgend so nem C++ buch das ich vor jahren las, koennte http://www.amazon.com/Effective-C%2B%2B-Addison-Wesley-Professional-Computing/dp/0321334876/ sein).

Wichtig ist dabei, das die Init function prueft ob schonmal initialisiert wurde und dann entweder einen errorcode zurueckliefert, oder erstmal das release aufruft.

release sollte dann auch immer pruefen ob ueberhaupt was zum freigeben ist. das kann man auch pro variable machen, dazu wird oft SAFE_RELEASE benutzt (google mal danach, du findest es tausend mal und immer gleich implementiert (c&p ;))

so ein paar anmerkungen:
- es bieten sich singletons fuer factories an.
- es ist zwar schoen einzelne labels usw. zu erstellen, aber genau so wie man keine polygonmeshes im code erzeugt, sollte man das bei GUI nicht machen und versuchen auch sie zu laden, gerade dafuer bietet sich XML sehr an. es gibt auch schon bekannte formate wie z.b. von das von Gnom.

Eine resource hat ja klar definiete funktionen, egal ob font oder bitmap oder...
Also machst du dir eine Resource klasse die sich um alles noetige kuemmert.
Falls du eine spezielle Bitmap brauchst, weil sie z.b. erst bei der ersten verwendung die bitmap wirklich laedt, leitest du von der resource ab und spezialisiert die noetigen funktionen oder packst neue hinzu.

Was mir noch unklar ist, ob die Factory selbst die API initialisieren soll, oder eine weitere Klasse braucht, die dann die API Funktionen kapselt..quasi delegiert.