Designfrage

Ich habe eine Klasse Graphics, welche alles nötige hat um auf dem Bildschirm rumzuzeichnen. Und eine weitere Klasse Bitmap, welche eine grafische Resource verwaltet.

Ist es jetzt sinnvoller der Graphics die Daten der Bitmap zu geben, damit die Graphics die Bitmap zeichnen kann oder der Bitmap die nötigen Informationen zu geben, damit sie sich selbst zeichnen kann?

Quasi was ist besser:

instBitmap.Draw(instGraphics.getInfos());

oder

instGraphics.DrawBitmap(instBitmap.getInfos());

Eine Erklärung warum eins dem anderen vorzuziehen ist wäre auch gut oder eine noch bessere alternative.

XSpille

Generell finde ich die 2. Variante schöner, weil es die Aufgabe deiner
Graphics-Klasse ist das Objekt darzustellen.
Du sagst ja auch nicht einer Linie: Zeichne dich...

Wenn man jetzt allerdings z.B. verschiedene Bildtypen hat und die
Grafik-Klasse performantere (native) Funktionen verwenden kann, würde ich
persönlich eventuell vom Graphics-Objekt an das Bitmap delegieren und
von dort wieder zurück (mit dem genauen Typ als Parameter) um die performante
Implementierung zu verwenden.

So bleibt meine favorisierte Variante als Funktion der Graphics-Klasse
unabhängig von genauen Bildtyp mit der Möglichkeit die für den Bildtyp
optimierte zu nutzen.

EDIT: Etwa so:

class Graphic{
public:
	void draw(const Image& image){
		image.drawTo(*this);
	}

	void draw(const PNG& png){
		// fast native code
	}

	void draw(const JPG& jpg){
		// fast native code
	}

	// function for images without native code support
	void drawPixelBased(const Image& image){
		// slow code, reading every pixel separately
	}
};

class Image{
public:
	virtual void drawTo(Graphic& graphic) const = 0;
};

class PNG : public Image{
public:
	virtual void drawTo(Graphic& graphic) const{
		graphic.draw(*this);
	}
};

Der Code soll nur das Prinzip darstellen -> Nicht kompilierfähig (z.B. wegen fehlenden forward declarations)

Gruß,
XSpille

brotbernd

Dependency Inversion. Beide hängen von einer Abstraktion ab.
Wenn ich das Problem richtig verstanden habe:

class DrawContext
{
  // Schnittstelle zum malen
  virtual void Line(von, nach, Color) = 0;
};

class Graphics
{
public:
  virtual void Draw(DrawContext&) = 0;
};

class Line : public Graphics {};

class Screen : public DrawContext 
{
  // Implementiert Schnittstelle zum malen auf dem Bildschirm
};

class Bitmap : public DrawContext 
{
  // Implementiert Schnittstelle zum malen in ein Bitmap
};

int main()
{
  Line l;
  Bitmap bmp;
  l.Draw(bmp);
  l.Draw(Screen->Instance());
  return 0;
}

edit: Glaub ich habs doch falsch verstanden. Bitmap soll sich in Graphics malen. Ändert aber nichts am Prinzip.