ich habe mir vor genommen, jetzt viel mehr mit Klassen zu arbeiten, um so mein Quelltext besser zu gestalten. Nun will ich ein neues Projekt starten und zwar will ich eine Klasse basteln mit der ich ein Linien-Diagramm in ein Fenster malen kann.

Ich habe schon folgenden Ansatz gemacht (ich male mir meistens immer erst alles so als Skizze aufs Papier ):

So sollte das Diagramm ausschaun:

(Fenster in das das Diagramm gezeichnet werden soll)
+---------------------------------------------------------+
|+--------------------------------++---------------------++
||      Titel des Diagramm        ||                     ||
|+--------------------------------+|                     ||
|                                  |                     ||
|   ^+----------------------------+|  Eineige Infos aus  ||
|   ||                            ||    dem Diagramm     ||
|   ||                            ||                     ||
|   ||                            ||                     ||
|   ||    Das Diagramm selbst     |+---------------------+|
|   ||                            |+---------------------+|
|   ||                            ||                     ||
|   |+----------------------------+|       Legende       ||
|   +----------------------------->|                     ||
|   (Achsen mit Einteilung)        |                     ||
|                                  +---------------------+|  
+---------------------------------------------------------+

Soweit so gut, es ist klar zu sehen was rein soll:
- Titel des Diagramms
- Ein paar kleine Infos die man auf einen Blick sehen soll
- Die Legende
- Das Diagramm selber
- Die Achsen, mit Einteilung

An dieser Stelle kommen mir doch aber schon einige Fragen:
- Sollte ich eine große Klasse bilden, die ich mit allen Membern die ich benötige, füttere?

oder

- Sollte ich mehre "kleine" Klassen bilden, z.B. eine für das Ausrichten aller Rechtecke( also wie oben in der Skizze zu sehen ist: Titel, Legende ect. ), eine für das Neuberechnen der Einteilung, eine für die Legende, für die Infos, für den Title und schließlich für das Diagramm bild. Und letzt endlich erbt eine Klasse - sagen wir "CLineChart" - alle diese kleinen Klassen und arbeitet mit ihnen ?!

Also ganz ehrlich ich würde sehr gerne nach dem zweiten Verfahren arbeiten, aber ich kann mir im Moment noch nicht ganz vorstellen wie ich dann alles mit der "CLineChart" Klasse abarbeiten soll?!

Also ich hoffe ihr habt mein Problem etwas erkannt und könnt mir hier auch helfen, ich möchte das ganze auch soweit es geht Objekt orientiert gestalten.

Für eure Hilfe schon mal: Danke!

Gruß Tobi.

Eine Klasse "Diagramm" welche die Daten eines Diagrammes beschreibt. Also ein "char* titel", ein "int farbe", eine Funktion "virtual float evaluateAtPoint( float point )", ...

Und dann ganz viele Klassen welche einen Teil eines Diagramm-Objektes anzeigen können.
- TitelPanel, zeigt z.B. den String "Diagramm -> titel" an
- InfoPanel
- DiagrammPanel
- ...

Schlussendlich ein "FensterPanel" welches alles zusammenkittet. Nicht durch Vererbung, sondern durch ganz einfach Referenzen.

Ich weiss nicht wie gut du programmierst, wenn dir das also alles zu trivial vorkommt, dann wirf mir ein Keks nach...

Folgende zwei Dinge sind IMHO für dein Problem wichtig:
- Trennung zwischen Daten und Darstellung, am Besten wäre es, wenn die Daten nicht wissen wie und wo sie dargestellt werden (das erhöht schlussendlich die Übersicht).
- Komposition anstelle von Vererbung, ist in diesem Fall ja auch irgendwie logisch: ein Fenster hat einen Titel und eine Legende, aber es ist nicht ein Titel und eine Legende.

Wenn du nur ein Element darstellen müsstest, würde ich dir recht geben. Aber ich zähle bereits jetzt mindestens 5 Dinge die du zeichnen willst.
- Einiges davon wird sich nicht in 10 Zeilen Code unterbringen lassen. Wenn du alles in eine Klasse quetschst, wird es dann bald unübersichtlich.
- Es macht nichts, kleine Klassen zu haben. Solange eine Klasse etwas neues macht, hat sie eine Existenzberechtigung.
- Und du willst das wohl auch noch irgendwie ausrichten (so dass die Panels sich nicht gegenseitig überlagern), da ist eine Abstraktion "ordne Rechtecke an" anstelle von "Ordne A, B, C, D, E-Panels an" wohl passend. Mit ein bisschen Vererbung und mehreren Klassen ist das kein Problem.
- Und es ist eine gute Übung

Du könntest z.B. das TitelPanel, LegendenPanel, ... von einer Basisklasse "Panel" ableiten, und in Panel definierst du Dinge wie Position und Grösse.

Codemässig würdest du das folgendermassen benutzen :

class Panel{
  int x, y, width, height;
  Diagramm* diagramm;
}
class TitelPanel : Panel{...}
class LegendePanel : Panel{...}

// das Diagramm wird irgendwann mal definiert
Diagramm* diagramm = ...
// die Panels herstellen
Panel* titel = new TitelPanel();
Panel* legende = new LegendePanel();
...
// Die Panels verteilen
titel->setLocation( 0, 0 );
titel->setSize( 100, 20 );
legende->setLocation( 100, 50 );
legende->setSize( 50, 10 );

...
// Panels sagen, was sie anzuzeigen haben
titel->setDiagramm( diagramm );
legende->setDiagramm( diagramm );

oder

Sollte ich einfach nur eine Methode in der Basisklasse schreiben, die x, y, width, heigth des Rechtecks setzt und alle Daten ausserhalb der Klasse berechnet werden?

Gruß Tobi.

Meld mich dann sicher noch mal hier, wenn was unklar ist. Danke erst einmal.

Gruß Tobi.