sinnvolle Klassenbildung brauche hilfe

[gast99999999999]

Hallo,
ich habe grade ziemlichen Ärger mit einer Dozentin bzgl einer Projektaufgabe.
Wir sollen eigenständig ein c++Projekt schreiben, welches folgende aufgaben erfüllen soll:
-ich habe 2 Festkoordinaten, die ich aus datei 1 einlesen soll. aus diesen muss ich einen winkel berechnen.

-desweitern habe ich n Neupunkte, von denen jeweils strecke und winkel gemessen wurden diese messwerte soll ich aus datei 2 einlesen und daraus die neupunktkoordinaten berechnen

Nun meine Idee zur Vorgehensweise:
1. Klasse "festpunkt" die mir den benötigten winkel berechnet aus datei 1
2. Klasse "Neupunkt" die mir für die neupunkte alle benötigten werte berechnet. da das Programm ja für variabl viele Neupunkte laufen soll, habe ich in der main dann die messelemente aus datei 2 in einer verketteten liste gespeichert und lasse so für jeden neupunkt meine Klassenfunktionen durchlaufen.

->das programm läuft 1a, gibt mir alle werte richtig aus.

Problem: meine Dozentin hat mir das nicht anerkannt, weil es "keine sinnvolle klassenbildung" sei.
Ich habe bei ihr anchgefrgat, was daran falsch sei, aber sie sah es nicht ein, es mir zu erklären, da "sie das thema sinnvolle Klassenbildung" schon in der Vorlesung behandelt hat.

Was meint ihr denn?

[SeppJ]

Das was du gemacht hast, klingt eher danach als hättest du sehr imperativ anstatt objektorientiert programmiert. Da kann ich deine Dozentin schon verstehen.

1. Klasse "festpunkt" die mir den benötigten winkel berechnet aus datei 1

Das klingt grundverkehrt: Eine Klasse festpunkt hat nichts mit Datei 1 zu schaffen.

Die Klasse berechnet die benötigten Winkel? Heißt das, die Klasse kennt schon beide Festpunkte (kenne mich mit Geodäsie nicht aus)? Der Name suggeriert aber einen einzigen Punkt. Der Winkel wäre dann doch eine Funktion mehrerer Punkte. Das Beschränken auf den Grundfall (ein Punkt) ist auf jeden Fall auch sinnvolles Design, mehrere Punkte setzt man dann aus diesem Basisfall zusammen.

Gleiche Kritik für die neupunkte.

Weiterhin: Wie gesagt, weiß ich wenig über Geodäsie. Gibt es einen Zusammenhang zwischen Fest- und Neupunkten? Sind diese Spezialfälle eines gemeinsamen Basisfalls? Dies sollte dein Klassendesign gegebenenfalls auch berücksichtigen.

Konkreter kann ich ohne Code oder eine Einführung in Vermessungstechnik nicht werden.

[gast999999999999]

danke schon mal für deine hilfe. Ich bin noch nicht ganz dahinter gekommen, wieso das so nciht geht, aber vllt kommt das ja noch

Ich lese in der main die Koordinaten der festpunkte ein( sind immer 2)diese speicher ich dann mti den get und setfunktionen in die klassenvariablen und berechne damit den Richtungswinkel, was ebenfalls ne Memberfunktion der ersten klasse ist.

Diesen Richtungswinkel übergebe ich dann an die zweite klasse, die mit diesem winkel die weiteren Richtunsgwinkel berechnet.

Meinst du es wäre sinnvoller, nur eine einzige Klasse namens punkt zu bilden?

[SeppJ]

Kannst du das mal als Code zeigen? Da kann ich weitaus nützlichere Hilfe geben als bei einer groben Beschreibung. Außerdem wäre dein ungefährer technischer Kenntnisstand hilfreich, denn man kann immer vieles noch eleganter lösen, wenn man sich nur gut genug auskennt. Operatorüberladung bekannt? Templates bekannt? Konstruktoren bekannt? Vererbung bekannt? Virtuelle Funktionen bekannt?

Außerdem für Leute die sich nicht mit Vermessungswesen auskennen eine kleine Einführung, was man wie berechnen soll. Denn nur damit kann man beurteilen, ob das Klassendesign wirklich sinnvoll ist (z.B. ob man alles von einer Klasse Punkt ableiten kann). Ohne dieses Wissen kann ich nur was zu technischen Aspekten sagen.

[gast999999]

hat sich erledigt

[Geodäte]

gast999999 schrieb:

//Variablen, die später benötigt werden:
    double y,
           x,
           Y,
           X,
           s_y,
           s_x,
           s_r,
           s_S,
           standABS,
           standABr,
           y_P,
           s_yP,
           x_P,
           s_xP,
           y_A,
           s_yA,
           x_A,
           s_xA,
           s_neu,
           yA,
           xA,
           yP,
           xP,
           ta,
           syA,
           sxA,
           syP,
           sxP,
           s_mittel;

Allein schon das verstösst gegen die Objektorientierung. Als Faustregel gilt: nie mehr als 7 Variablen, weil das durchschnittliche Kurzzeitgedächtnis sich nicht mehr merken kann.
Aus dem Paar x,y könntest du den Punkt p machen, etc. - mit besseren Namen versteht sich. Vorschläge kann ich dazu jedoch keine machen, Geodäsie scheint nicht das Steckenpferd der normalen Programmierer zu sein.

(Bitte umschliesse deinen Code mit [cpp]code[/cpp])

[SeppJ]

Die Klassen festpunkt und neupunkt hast jetzt natürlich schönerweise nicht gezeigt . Ging es nicht um das Klassendesign? Dein Code in der main lässt jedenfalls schon schlimmes ahnen:

Festpunkt riwin;
    riwin.set_yA(y_A);
    riwin.set_xA(x_A);
    riwin.set_yP(y_P);
    riwin.set_xP(x_P);
    yA=riwin.get_yA();
    xA=riwin.get_xA();
    yP=riwin.get_yP();
    xP=riwin.get_xP();
    syA=riwin.get_syA();
    syP=riwin.get_syP();
    sxA=riwin.get_sxA();
    sxP=riwin.get_sxP();

Und da kommt dir nicht in den Sinn, dafür mal eine hübsche Koordinatenklasse zu schreiben?

Zeilen 254-Ende:
Und du meinst nicht, dass man das irgendwie mit weniger Codewiederholungen schreiben könnte?

Zeilen 153-225:
Ich hab's nicht näher durchgelesen, aber das ist die wohl umständlichste Eingabeoperation die ich je gesehen habe.

Und das sind (neben Geodätes Bemerkung zu den Variablen) nur die dicksten Hauer.

[Paul Müller]

3 Punkte!
Du kannst Daten auf die gleiche Weise wieder einlesen, wie du sie raus geschrieben hast. Diese ganze Gefummel mit getline, erase und der C-Funktion atof, ist unnötig. Allein die Benutzung einer C-Funktion sollte dir zu denken geben, ob dein Weg der richtige ist.
Das selber bauen einer Liste ist sicher eine geeignete Übung, aber dafür gibt es vorgefertigte Klassen, die man nutzen kann. Es zeugt auch nicht von Faulheit etwas vorgefertigtes zu nutzen, ganz im Gegenteil, du zeigst dich mit der Materie beschäftigt zu haben.
Und zum letzten Punkt, nicht nur die Anzahl deiner Variablen erschlägt einen, sondern auch die Gewaltigkeit deines Codes. Ich hab gute Erfahrungen mit kleinen Funktionen gemacht, die auf einem Blick erfassbar sind. Das schöne dabei ist, dass die Dokumentation anhand von Kommentaren, die man gerne vergisst, damit auch überflüssig wird.
Und noch ein Punkt 3.1., nicht einfach drauf los schreiben. Setze dich hin und skizziere dir auf einem Blatt, was du eigentlich möchtest. Dabei zeigen sich auch schnell Fehler in der Logik, die dir so im Code nicht auffallen. (redundanter Code; zusammenhängende Daten, die du getrennt behandelst; ungültige Logikpfade; Bugs)

[Werner Salomon]

gast99999999999 schrieb:

Was meint ihr denn?

nix für ungut, aber Deine Dozentin hat Recht. In Sachen 'sinnvoller Klassenbildung' liegst Du mit diesem Code ziemlich daneben. Einige Argumente sind hier schon gesagt worden - man sieht sogar an Deiner Namensgebung der Variablen, dass Du eher einen prozeduralen denn einen objektorientierten - also einen Ansatz mit Klassen - gewählt hast. Du schreibst 'yA' statt 'Ay' - das was vorn steht, ist wichtig. Wichtig ist, dass es sich hier um den Punkt A handelt, und nur an zweiter Stelle ist entscheidend, ob es die X- oder Y-Koordinate ist.

Denn ein Punkt ist ein Punkt ist ein Punkt - das gilt wohl immer. Und ein Punkt hat in der Ebene zwei Koordianten und nicht vier von zwei Punkten.

gast999999999999 schrieb:

Meinst du es wäre sinnvoller, nur eine einzige Klasse namens punkt zu bilden?

Ja - zumindest ist eine Klasse Punkt ein Anfang. Es muss ja nicht die einzige Klasse bleiben, wie wäre es mit einer Klasse Anschlussrichtungswinkel (was mathematisch eher eine Anschlussrichtungsstrecke ist) - obwohl bei der Problemstellung der Punkt vielleicht schon ausreicht.

Ein Punkt kann aus seinen zwei Koordinaten gebildet werden oder aus einer Richtung (Winkel) und der Entfernung zum Punkt. Schau Dir dazu mal die Klasse std::complex und die Funktion std::polar an. Das Koordinatensystem muss auch nicht immer das selbe sein.

Paul Müller hat es schon angedeutet; von einem Punkt würde ich erwarten, dass man ihn einlesen und auch wieder ausgeben kann. Der Code sollte etwa so aussehen:

Punkt a,p;
    ifstream dat_1(DatEin1);
    if( dat_1 >> a >> p ) {
        //  Punkte wurden korrekt aus 'DatEin1' gelesen
        cout << "Gelesen: a=" << a << " p=" << p << endl;

falls Du nicht weist, wie man das macht, so frage nach.

Das ganze mit der Objektorientierung ist nicht so einfach - das kann man nicht lernen wie Vokabeln oder so. Schau Dir diesen Thread über Setter an oder diesen Beitrag über Transformationen mit complexen Zahlen .. aber letzteres nur, wenn Dir der mathematische Background in etwa geläufig ist.

Weiter lohnt es sich für Dich, sich die Containerklassen (z.B. std::vector) und die Strings (std::string) anzusehen.

:xmas2: Werner