| Autor |
Beitrag |
baphumet
Beiträge: 44
Windows XP
Delphi 7
|
Verfasst: Mo 28.09.09 19:13
Hi,
benutze Delphi Version 7 und habe 4 Klassen, dabei werden die 3 letzten von der ersten abgeleitet, es handelt sich um eine abstrakte Klasse, die Methoden werden erst in den anderen Klassen implementiert. Im Konstruktor wird eine Methode Korrektur aufgerufen, die eine Winkelkorrektur vornimmt und ist nur in den letzten beiden Klassen deklariert und implementiert da diese nur dort benötigt werden. Hier mein Code um es besser nachzuvollziehen zu können.
1:
2:
3:
4:
5:
6:
7:
8:
9:
10:
11:
12:
13:
14:
15:
16:
17:
18:
19:
20:
21:
22:
23:
24:
25:
26:
27:
28:
29:
30:
31:
32:
33:
34:
35:
36:
37:
38:
39:
40:
41:
42:
43:
44:
45:
46:
47:
48:
49:
50:
51:
52:
53:
54:
55:
56:
57:
58:
59:
60:
61:
62:
63:
64:
65:
66:
67:
68:
69:
70:
| unit KOMPLEX;
interface
uses
sysutils,math;
type
TKlasse=class
private
a,b,c,d,e: EXTENDED;
public
function add(z1,z2: TKlasse):TKlasse;virtual;abstract;
function sub(z1,z2: TKlasse):TKlasse;virtual;abstract;
function mul(z1,z2: TKlasse):TKlasse;virtual;abstract;
function div(z1,z2: TKlasse):TKlasse;virtual;abstract;
...
end;
TForm1=class(TKlasse)
constructor Create(a1,b1: EXTENDED);
function add(z1,z2: TKlasse):TKlasse;override;
function sub(z1,z2: TKlasse):TKlasse;override;
function mul(z1,z2: TKlasse):TKlasse;override;
function div(z1,z2: TKlasse):TKlasse;override;
...
end;
TForm2=class(TKlasse)
constructor Create(a1,b1: EXTENDED);
function Korrektur(b1: EXTENDED):EXTENDED;
function add(z1,z2: TKlasse):TKlasse;override;
function sub(z1,z2: TKlasse):TKlasse;override;
function mul(z1,z2: TKlasse):TKlasse;override;
function div(z1,z2: TKlasse):TKlasse;override;
...
end;
TForm3=class(TKlasse)
constructor Create(a1,b1: EXTENDED);
function Korrektur(b1: EXTENDED):EXTENDED;
function add(z1,z2: TKlasse):TKlasse;override;
function sub(z1,z2: TKlasse):TKlasse;override;
function mul(z1,z2: TKlasse):TKlasse;override;
function div(z1,z2: TKlasse):TKlasse;override;
...
end;
...
constructor TForm2.Create(a1,b1: EXTENDED);
begin
a:=a1;
b1:=Korrektur(b1); b:=b1; end;
function TForm2.Korrektur(b1 :EXTENDED):EXTENDED;
begin
result:=b1;
end;
...
constructor TForm3.Create(a1,b1: EXTENDED);
begin
a:=a1;
b1:=Korrektur(b1); b:=b1; end;
function TForm3.Korrektur(b1 :EXTENDED):EXTENDED;
begin
result:=b1;
end; |
Bei diesem Aufruf der Funktion ist noch alles ok, das hab ich mit Debuggen herausgefunden und das Ergebnis wird an b1 zurückgegeben, aber bei der Wertzuweisung gibt b:=b1; es Probleme, aber nur wenn ich aus den Methoden heraus den Constructor aufrufe, also bei so etwas:
  Delphi-Quelltext
1:
2:
3:
4:
5:
6:
7:
8:
9:
10:
11:
12:
| function TForm3.mul(z1,z2: TKlasse):TKlasse;
begin
a:=z1.a*z2.a;
b:=z1.b+z2.b;
result:=TForm3.Create(a,b); end;
function TForm3.div(z1,z2: TKlasse):TKlasse;
begin
a:=z1.a/z2.a;
b:=z1.b-z2.b;
result:=TForm3.Create(a,b); end; |
Wie man aus den Namen der Methoden erkennen kann soll gerechnet werden, hierbei werden die 4 Grundrechenarten gezeigt. Ansonsten wenn ich nicht aus den Methoden heraus
ein neues Objekt von TForm3 erstelle funktioniert die letzte Wertzuweisung im Constructor einwandfrei.
Meine Frage, ist das normal, gibt es dafür eine logische Ursache oder handelt es sich um einen Bug in Delphi?
Zuletzt bearbeitet von baphumet am Di 29.09.09 13:54, insgesamt 7-mal bearbeitet
|
|
Zyklame
Beiträge: 41
Erhaltene Danke: 1
Win 7 Professional
Delphi XE, Visual Studio 2010
|
Verfasst: Mo 28.09.09 19:38
Mal Abgesehen von den nicht gerade viel Aussagenden Klassennamen ist der Fehler sicher an der makierten Stelle
Delphi-Quelltext
1:
2:
3:
4:
5:
6:
7:
| constructor TKlasse3.Create(a1,b1: EXTENDED): EXTENDED;
begin
a:=a1;
b1:=Korrektur(b1);
b:=b1; Result := b1; end; |
|
|
Tryer
Beiträge: 226
Erhaltene Danke: 7
|
Verfasst: Mo 28.09.09 20:01
- Wo steckt der inherited - Aufruf des Constructors? Sollte man immer machen.
- Meckert der Compiler da nicht: constructor TKlasse3.Create(a1,b1: EXTENDED): EXTENDED Ein Constructor sollte immer den Zeiger auf die Instanz zurückgeben (-> OH). Für alles andere gibt es reguläre Funktionen.
|
|
Xentar
Beiträge: 2077
Erhaltene Danke: 2
Win XP
Delphi 5 Ent., Delphi 2007 Prof
|
Verfasst: Mo 28.09.09 20:04
1. Äh, nanü..? Einen Constructor mit Rückgabewert? Hab ich was verpasst? Ich dachte immer, der liefert eine Instanz eben dieser Klasse zurück..
2. im Con- / Destructor inherited aufrufen
3. Warum glauben die Leute eigentlich, wenn so etwas simples nicht geht, immer sofort an einen Bug in Delphi?  _________________ PROGRAMMER: A device for converting coffee into software.
|
|
Tryer
Beiträge: 226
Erhaltene Danke: 7
|
Verfasst: Mo 28.09.09 20:18
 Xentar hat folgendes geschrieben  : | | Warum glauben die Leute eigentlich, wenn so etwas simples nicht geht, immer sofort an einen Bug in Delphi? |
Nicht immer, und in diesem Fall ist die Idee aufgrund vorheriger Probleme nicht ganz abwegig.. auch wenn Delphi diesmal unschuldig ist.
|
|
baphumet 
Beiträge: 44
Windows XP
Delphi 7
|
Verfasst: Mo 28.09.09 22:13
Hi, hab mich an der Stelle verschrieben, Constructor hat keinen Rückgabewert, außerdem schieb ich die Schuld nicht auf Delphi, es war nur eine Frage und beim compilieren hab ich ohne inherited auch keine Probleme. Die Funktion Korrektur wird aufgerufen und der Rückgabewert der Variable b1 zugewiesen, das Problem leigt bei der Werzuweisung b:=b1.
Delphi-Quelltext
1:
2:
3:
4:
5:
6:
7:
8:
| procedure Button1.Click(Sender: TObject);
var
test: TKlasse;
begin
test:=TForm3.Create(1,390);
end; |
aber
Delphi-Quelltext
1:
2:
3:
4:
5:
6:
7:
8:
9:
10:
11:
12:
| function TForm3.M1(z1,z2: TKlasse):TKlasse;
begin
a:=z1.a*z2.a; b:=z1.b+z2.b; result:=TForm3.Create(a,b);
end;
...
|
Meine Constructoren sehen wie folgt aus:
Delphi-Quelltext
1:
2:
3:
4:
5:
6:
7:
8:
9:
10:
11:
12:
13:
14:
15:
| constructor TForm2.Create(a1,b1: EXTENDED);
begin
inherited Create();
a:=a1;
b1:=Korrektur(b1); b:=b1;
end;
constructor TForm3.Create(a1,b1: EXTENDED);
begin
inherited Create();
a:=a1;
b1:=Korrektur(b1); b:=b1;
end; |
Hat erstmal trotzdem nichts gebracht, deshalb frag ich ist das korrekt oder muß das anders aussehen, inherited; hat nicht funktioniert da erhalte ich Compilerfehler?
Einzige Möglichkeit damit ich es zum Laufen bekomme ist das ich Korrektur in jeder Methode vor dem erzeugen eines Objektes aufrufe, aber ich finde das nicht sehr gut. Denn es werden ja Objekte erzeugt und genau dann und nur an einer Stelle ist eine Korrektur notwendig, falls irgendwelche Fehler auftreten brauch man nur an einer Stelle schauen wenn es Korrektur betrifft und nicht nachvollziehen welche Methode aufgerufen worden ist und dort der Aufruf erfolgte, ich spare mir Aufrufe, alle weg von den Methoden und ein Aufruf im Constructor, spart Speicher.
|
|
baka0815
Beiträge: 489
Erhaltene Danke: 14
Win 10, Win 8, Debian GNU/Linux
Delphi 10.1 Berlin, Java, C#
|
Verfasst: Di 29.09.09 10:02
Delphi-Quelltext
1:
2:
3:
4:
5:
6:
7:
8:
| TKlasse=class
private
a,b,c,d,e: EXTENDED;
public
function add(z1,z2: TKlasse):TKlasse;virtual;abstract;
function sub(z1,z2: TKlasse):TKlasse;virtual;abstract;
function mul(z1,z2: TKlasse):TKlasse;virtual;abstract;
function div(z1,z2: TKlasse):TKlasse;virtual;abstract; |
Wenn du aus den anderen Klassen heraus auf die privaten Felder a,b,c,d und e zugreifen möchtest, solltest du diese nicht als private, sondern als strict protected deklarieren.
So funktioniert es zwar auch, weil man auf private Felder auch aus der Unit zugreifen kann, sauberer wäre es aber sicher anders. Vielleicht liegt da auch das Problem?
|
|
jaenicke
Beiträge: 19314
Erhaltene Danke: 1747
W11 x64 (Chrome, Edge)
Delphi 11 Pro, Oxygene, C# (VS 2022), JS/HTML, Java (NB), PHP, Lazarus
|
Verfasst: Di 29.09.09 10:34
| baka0815 hat folgendes geschrieben : | | Wenn du aus den anderen Klassen heraus auf die privaten Felder a,b,c,d und e zugreifen möchtest, solltest du diese nicht als private, sondern als strict protected deklarieren. |
Oben steht, dass es um Delphi 7 geht. Das kannte so etwas leider noch nicht. 
Ab Delphi 2006/Turbo Delphi würden noch ganz andere Sachen gehen, z.B. könnte man da einfach das normale + verwenden, wenn man die Methoden entsprechend der Operatoren deklariert. Dann müsste man add und so etwas gar nicht mehr als Funktion aufrufen. Geht aber hier alles nicht.
Die Klassennamen TForm1, TForm2 und TForm3 sind natürlich sehr günstig gewählt, da Delphi diese selbst nie vewendet und man sofort am Namen sieht was das für Klassen sind und wozu die dienen...
|
|
baphumet
Beiträge: 44
Windows XP
Delphi 7
|
Verfasst: Di 29.09.09 14:01
Ich gebe ja zu das die Klassennamen nicht gerade gut gewählt worden sind, ist doch aber nur ein Quelltextbeispiel, bedeutet das meine Klassen und Methoden und die Attribute anders heißen, aber es funktioniert genauso. Ich muß doch hier nicht mein Programm offen legen was es genau macht und dann klaut mir jemand meine Programmieridee und kopierts, das möchte ich nicht.
Die letzten Antworten waren wenig konstruktiv, gibt es in Delphi 7 eine Möglichkeit das die Wertzuweisung im Constructor sicher gestellt wird, wenn nicht dann ruf ich Korrektur eben in jeder Methode(add,sub,...) auf bevor ein Objekt von TForm2 oder TForm3 erzeugt wird. Das funktioniert 100%ig, ist für mich aber keine optimale Lösung.
|
|
Tastaro
Beiträge: 414
Erhaltene Danke: 23
|
Verfasst: Di 29.09.09 14:13
Tausche doch einfach mal das Wörtchen "public" gegen "protected" aus.
Beste Grüße
|
|
Tryer
Beiträge: 226
Erhaltene Danke: 7
|
Verfasst: Di 29.09.09 17:27
Ich würde nicht erwarten das sich da was ändert, denn die Felder gehören ja dennoch zu der Instanz
|
|
Narses
Beiträge: 10183
Erhaltene Danke: 1256
W10ent
TP3 .. D7pro .. D10.2CE
|
Verfasst: Di 29.09.09 17:56
Moin!
| baphumet hat folgendes geschrieben : | [...] nur ein Quelltextbeispiel, bedeutet das meine Klassen und Methoden und die Attribute anders heißen, aber es funktioniert genauso. Ich muß doch hier nicht mein Programm offen legen was es genau macht [...]
Die letzten Antworten waren wenig konstruktiv [...] |
Was man wohl kaum uns anlasten kann.  Halten wir fest: du zeigst keinen real eingesetzten Code (warum auch immer sei jetzt mal dahingestellt), also können wir schlecht feststellen, ob dein Beispiel angemessen ist oder ob du Fehler machst, die du gar nicht bemerkst. 
Ich habe mal versucht, dein "Beispiel" in lauffähigen Code abzubilden:
1:
2:
3:
4:
5:
6:
7:
8:
9:
10:
11:
12:
13:
14:
15:
16:
17:
18:
19:
20:
21:
22:
23:
24:
25:
26:
27:
28:
29:
30:
31:
32:
33:
34:
35:
36:
37:
38:
39:
40:
41:
42:
43:
44:
45:
46:
47:
48:
49:
50:
51:
52:
53:
54:
| type
TAbstrakteKlasse = class(TObject)
private
a,b: Extended;
function GetAusgabe: String;
public
function Machwas(z1,z2: TAbstrakteKlasse): TAbstrakteKlasse; virtual; abstract;
property GibAus: String read GetAusgabe;
end;
TSpezielleKlasse = class(TAbstrakteKlasse)
public
constructor Create(a1, b1: Extended);
function Machwas(z1, z2: TAbstrakteKlasse): TAbstrakteKlasse; override;
end;
function TAbstrakteKlasse.GetAusgabe: String;
begin
Result := Format('a: %f b: %f',[a,b]);
end;
constructor TSpezielleKlasse.Create(a1, b1: Extended);
begin
inherited Create;
a := a1;
b := b1;
end;
function TSpezielleKlasse.Machwas(z1, z2: TAbstrakteKlasse): TAbstrakteKlasse;
begin
a := z1.a *z2.a;
b := z1.b +z2.b;
Result := TSpezielleKlasse.Create(a,b);
end;
procedure TForm1.Button1Click(Sender: TObject);
var
K1, K2: TAbstrakteKlasse;
begin
K1 := TSpezielleKlasse.Create(10,20);
try
Memo1.Lines.Add(K1.GibAus);
K2 := K1.Machwas(K1,K1);
try
Memo1.Lines.Add(K2.GibAus);
finally
K2.Free;
end;
finally
K1.Free;
end;
end; | Ist das "Beispiel" zutreffend für dein Problem? Wenn nicht, was muss anders sein?
cu
Narses _________________ There are 10 types of people - those who understand binary and those who don´t.
|
|
baphumet
Beiträge: 44
Windows XP
Delphi 7
|
Verfasst: Di 29.09.09 19:14
Hi,
an alle und ich will niemanden zu nahe treten, aber wer lesen kann und gründlich ließt und auch den Quelltext durchschaut der sieht das ich keine proberties benutzt habe, aber trotzdem werde ich jetzt meinen richtigen Code darlegen, für alle Fälle.
Und eine Zusammenfassung für alle die es mehrmals lesen müssen, ich benutze Delphi 7 und mein Programm besteht aus 4 Klassen, 3 von diesen sind von der ersten abgeleitet und erst dort sind die Methoden implementiert. Das Programm soll mit Komplexen Zahlen rechnen, eine Komplexe Zahl besteht aus zwei Teilen, deshalb in meinen Methoden immer zwei Parameter, es gibt aber verschiedene Formen in denen verschieden damit gerechnet wird, wer mehr wissen will schaut bei Wikipedia rein.
Das sind jetzt alle nötigen Infos die ihr braucht, hoffe ich, falls nicht dann frag ich mich was ihr noch braucht, denn der Quelltext ist auch zu finden, jetzt bitte keine unsinnigen Aussagen machen die keinem weiter helfen, bringt nichts. Das einzige was passiert ist das ich wirklich sauer werde und mich irgendwann vergesse und dann bleibt kein Auge trocken. Eins möchte ich noch anmerken, ich meine nicht alle, denn es gibt wirklich Leute die gründlich lesen und auch hilfreiche Antworten geben, diese sollten sich nicht angesprochen fühlen, wollt ich nur sagen bevor es Missverständnisse gibt.
1:
2:
3:
4:
5:
6:
7:
8:
9:
10:
11:
12:
13:
14:
15:
16:
17:
18:
19:
20:
21:
22:
23:
24:
25:
26:
27:
28:
29:
30:
31:
32:
33:
34:
35:
36:
37:
38:
39:
40:
41:
42:
43:
44:
45:
46:
47:
48:
49:
50:
51:
52:
53:
54:
55:
56:
57:
58:
59:
60:
61:
62:
63:
64:
65:
66:
67:
68:
69:
70:
71:
72:
73:
74:
75:
76:
77:
78:
79:
80:
81:
82:
83:
84:
85:
86:
87:
88:
89:
90:
91:
92:
93:
94:
95:
96:
97:
98:
99:
100:
101:
102:
103:
104:
105:
106:
107:
108:
109:
| unit KOMPLEX;
interface
uses
Sysutils,math;
type
TKomplexeZahl=class
private
a,b,r,alpha,phi: EXTENDED;
public
function Addition(z1,z2: TKomplexeZahl):TKomplexeZahl;virtual;abstract;
function Subtraktion(z1,z2: TKomplexeZahl):TKomplexeZahl;virtual;abstract;
function Multiplikation(z1,z2: TKomplexeZahl):TKomplexeZahl;virtual;abstract;
function Division(z1,z2: TKomplexeZahl):TKomplexeZahl;virtual;abstract;
...
function Umwandlung1(z1: TKomplexeZahl):TKomplexeZahl; virtual;abstract;
function Umwandlung2(z1: TKomplexeZahl):TKomplexeZahl; virtual;abstract;
end;
TKForm1=class(TKomplexeZahl)
public
constructor Create(a1,b1: EXTENDED);
function Addition(z1,z2: TKomplexeZahl):TKomplexeZahl;override;
function Subtraktion(z1,z2: TKomplexeZahl):TKomplexeZahl;override;
function Multiplikation(z1,z2: TKomplexeZahl):TKomplexeZahl;override;
function Division(z1,z2: TKomplexeZahl):TKomplexeZahl;override;
...
function Umwandlung1(z1: TKomplexeZahl):TKomplexeZahl;override;
function Umwandlung2(z1: TKomplexeZahl):TKomplexeZahl;override;
end;
TKForm2=class(TKomplexeZahl)
constructor Create(r1,alpha1: EXTENDED);
function Winkelkorrektur(alpha1: EXTENDED):EXTENDED;
function Addition(z1,z2: TKomplexeZahl):TKomplexeZahl;override;
function Subtraktion(z1,z2: TKomplexeZahl):TKomplexeZahl;override;
function Multiplikation(z1,z2: TKomplexeZahl):TKomplexeZahl;override;
function Division(z1,z2: TKomplexeZahl):TKomplexeZahl;override;
...
function Umwandlung1(z1: TKomplexeZahl):TKomplexeZahl;override;
function Umwandlung2(z1: TKomplexeZahl):TKomplexeZahl;override;
public
end;
TKForm3=class(TKomplexeZahl)
public
constructor Create(r1,phi1: EXTENDED);
function Winkelkorrektur(alpha1: EXTENDED):EXTENDED;
function Addition(z1,z2: TKomplexeZahl):TKomplexeZahl;override;
function Subtraktion(z1,z2: TKomplexeZahl):TKomplexeZahl;override;
function Multiplikation(z1,z2: TKomplexeZahl):TKomplexeZahl;override;
function Division(z1,z2: TKomplexeZahl):TKomplexeZahl;override;
...
function Umwandlung1(z1: TKomplexeZahl):TKomplexeZahl;override;
function Umwandlung2(z1: TKomplexeZahl):TKomplexeZahl;override;
end;
...
constructor TKForm2.Create(r1,alpha1: EXTENDED);
begin
r:=r1;
alpha1:=Winkelkorrektur(alpha1);
alpha:=alpha1; end;
function TKForm2.Winkelkorrektur(alpha1: EXTENDED):EXTENDED;
begin
result:=alpha1;
end;
...
function TKForm2.Multiplikation(z1,z2: TKomplexeZahl):TKomplexeZahl;
begin
r:=z1.r*z2.r;alpha:=z1.alpha+z2.alpha;
result:=TKForm2.Create(r,alpha);
end;
function TKForm2.Division(z1,z2: TKomplexeZahl):TKomplexeZahl;
begin
r:=z1.r/z2.r;alpha:=z1.alpha-z2.alpha;
result:=TKForm2.Create(r,alpha);
end;
...
constructor TKForm3.Create(r1,phi1: EXTENDED);
begin
r:=r1;
phi1:=Winkelkorrektur(phi1);
phi:=phi1; end;
function TKForm3.Winkelkorrektur(phi1: EXTENDED):EXTENDED;
begin
result:=phi1;
end;
...
function TKForm3.Multiplikation(z1,z2: TKomplexeZahl):TKomplexeZahl;
begin
r:=z1.r*z2.r;phi:=z1.phi+z2.phi;
result:=TKForm3.Create(r,phi);
end;
function TKForm3.Division(z1,z2: TKomplexeZahl):TKomplexeZahl;
begin
r:=z1.r/z2.r;phi:=z1.phi-z2.phi;
result:=TKForm3.Create(r,phi);
end; |
|
|
Kha
Beiträge: 3803
Erhaltene Danke: 176
Arch Linux
Python, C, C++ (vim)
|
Verfasst: Di 29.09.09 22:23
| baphumet hat folgendes geschrieben : | | an alle und ich will niemanden zu nahe treten, aber wer lesen kann und gründlich ließt und auch den Quelltext durchschaut der sieht das ich keine proberties benutzt habe, [...] |
Ich will dir nicht zu nahe treten, aber du solltest einen Quelltext erst einmal verstehen, bevor du über ihn urteilst. Schau dir bitte noch einmal an, wozu Narses die Property eingeführt hat...
Jetzt aber zum Problem: Deine ganzen Methoden wie "Multiplikation" verarbeiten insgesamt vier TKomplexeZahl-Instanzen: Zwei Parameter, ein Rückgabewert... und die Self-Instanz! Das macht keinen Sinn, es sollten natürlich nur drei Instanzen insgesamt beteiligt sein.
Du rufst den Code wahrscheinlich so auf:
Delphi-Quelltext
Damit schmeißt du aber das Ergebnis weg, es müsste vielmehr so aussehen:
Delphi-Quelltext
1:
| zResult := zDummy.Add(z1, z2); |
Diese Dummy-Instanz ist wie gesagt vollkommen unnötig, mache aus deiner function eine class function (ich hoffe mal, dass D7 das schon kann, sonst eben eine ganz normale globale Funktion), dann sieht das Ganze so aus:
Delphi-Quelltext
1:
| zResult := TKForm1.Add(z1, z2); |
Wofür du hier Polymorphie überhaupt brauchst (getrennte Typen für jede Darstellung wären imho sinnvoller), ist eine andere Frage, was aber vielleicht lieber in einem neuen Topic besprochen werden sollte.
PS: Was mich interessieren würde - Polarform und algebraische Form sind ja bekannt, was für Formen unterstützt du denn noch? _________________ >λ=
|
|
Narses
Beiträge: 10183
Erhaltene Danke: 1256
W10ent
TP3 .. D7pro .. D10.2CE
|
Verfasst: Di 29.09.09 22:47
Moin!
Fachlich hat dir Sebastian ja schon Nachhilfe gegeben. Fehlt nur noch der Hinweis, dass D7 bereits Klassenfunktionen kennt.
| baphumet hat folgendes geschrieben : | | jetzt bitte keine unsinnigen Aussagen machen die keinem weiter helfen, bringt nichts. Das einzige was passiert ist das ich wirklich sauer werde und mich irgendwann vergesse und dann bleibt kein Auge trocken. |
Was war das denn jetzt?  Du hast dich beim Schreiben dieser Zeilen offenbar schon vergessen. Wenn du in dem Ton weiter machst, wird es mich nicht wundern, wenn du hier gar keine Antworten mehr kriegst.
Viel Erfolg noch
Narses _________________ There are 10 types of people - those who understand binary and those who don´t.
|
|
baphumet
Beiträge: 44
Windows XP
Delphi 7
|
Verfasst: Mi 30.09.09 00:07
| Kha hat folgendes geschrieben : |
Damit schmeißt du aber das Ergebnis weg, es müsste vielmehr so aussehen:
Delphi-Quelltext
1:
| zResult := zDummy.Add(z1, z2); |
Diese Dummy-Instanz ist wie gesagt vollkommen unnötig, mache aus deiner function eine class function (ich hoffe mal, dass D7 das schon kann, sonst eben eine ganz normale globale Funktion), dann sieht das Ganze so aus:
Delphi-Quelltext
1:
| zResult := TKForm1.Add(z1, z2); |
|
Es gibt die Kartesische Form, die Polarform und die Exponentialform von Komplexen Zahlen, letztere entsteht durch die Eulerformel, diese gibt einen Zusammenhang zwischen den trigonometrischen Funktionen und der Eulerschen Zahl, man ersetzt einfach in der Polarform cos alpha+sin alphai=e^(phi*i), der Betrag r bleibt erhalten und die Rechnungen sind analog der in Polarform, der Logarithmus lässt sich einfacher ermitteln.
Ich gebe dir recht, es müssen nur 3 und nicht 4 Objekte sein und so wie du es gesagt hast, hab ich die Methoden auch aufgerufen, wodurch ich das Ergebnis wegschmeiße. class function ist in Delphi 7 möglich, aber ich habe keine Ahnung wie das bei mir jetzt aussehen müsste. Muß ich meine gesamten Methoden als class function deklarieren oder nur die Winkelkorrektur und wenn wie, ein anschauliches Beispiel würde mir sehr weiterhelfen.
Meine eine Unit Komplex sieht ie folgt aus:
1:
2:
3:
4:
5:
6:
7:
8:
9:
10:
11:
12:
13:
14:
15:
16:
17:
18:
19:
20:
21:
22:
23:
24:
25:
26:
27:
28:
29:
30:
31:
32:
33:
34:
35:
36:
37:
38:
39:
40:
41:
42:
43:
44:
45:
46:
47:
48:
49:
50:
51:
52:
53:
54:
55:
56:
57:
58:
59:
60:
61:
62:
63:
64:
65:
66:
67:
68:
69:
70:
71:
72:
73:
74:
75:
76:
77:
78:
79:
80:
81:
82:
83:
84:
85:
86:
87:
88:
89:
90:
91:
92:
93:
94:
95:
96:
97:
98:
99:
100:
101:
102:
103:
104:
105:
106:
107:
108:
109:
110:
111:
112:
113:
114:
115:
116:
117:
118:
119:
120:
121:
122:
123:
124:
125:
126:
127:
128:
129:
130:
131:
132:
133:
134:
135:
136:
137:
138:
139:
140:
141:
142:
143:
144:
145:
146:
147:
148:
149:
150:
151:
152:
153:
154:
155:
156:
157:
158:
159:
160:
161:
162:
163:
164:
165:
166:
167:
168:
169:
170:
171:
172:
173:
174:
175:
176:
177:
178:
179:
180:
181:
182:
183:
184:
185:
186:
187:
188:
189:
190:
191:
192:
193:
194:
195:
196:
197:
198:
199:
200:
201:
202:
203:
204:
205:
206:
207:
208:
209:
210:
211:
212:
213:
214:
215:
216:
217:
218:
219:
220:
221:
222:
223:
224:
225:
226:
227:
228:
229:
230:
231:
232:
233:
234:
235:
236:
237:
238:
239:
240:
241:
242:
243:
244:
245:
246:
247:
248:
249:
250:
251:
252:
253:
254:
255:
256:
257:
258:
259:
260:
261:
262:
263:
264:
265:
266:
267:
268:
269:
270:
271:
272:
273:
274:
275:
276:
277:
278:
279:
280:
281:
282:
283:
284:
285:
286:
287:
288:
289:
290:
291:
292:
293:
294:
295:
296:
297:
298:
299:
300:
301:
302:
303:
304:
305:
306:
307:
308:
309:
310:
311:
312:
313:
314:
315:
316:
317:
318:
319:
320:
321:
322:
323:
324:
325:
326:
327:
328:
329:
330:
331:
332:
333:
334:
335:
336:
337:
338:
339:
340:
341:
342:
343:
344:
345:
346:
347:
348:
349:
350:
351:
352:
353:
354:
355:
356:
357:
358:
359:
360:
361:
362:
363:
364:
| unit KOMPLEX; interface
uses Sysutils,math;
type
TKomplexeZahl=class
private
a,b,r,alpha,phi: EXTENDED;
public
function addieren(z1,z2: TKomplexeZahl):TKomplexeZahl; virtual;abstract;
function subtrahieren(z1,z2: TKomplexeZahl):TKomplexeZahl; virtual;abstract;
function multiplizieren(z1,z2: TKomplexeZahl):TKomplexeZahl; virtual;abstract;
function dividieren(z1,z2: TKomplexeZahl):TKomplexeZahl; virtual;abstract;
function konjugieren(z1: TKomplexeZahl):TKomplexeZahl;virtual;abstract;
function potenzieren(z1: TKomplexeZahl;n: SmallInt):TKomplexeZahl; virtual;abstract;
function radizieren(z1: TKomplexeZahl;k,n: SmallInt):TKomplexeZahl; virtual;abstract;
function logarithmieren(z1: TKomplexeZahl):TKomplexeZahl; virtual;abstract;
function Umwandlung1(z1: TKomplexeZahl):TKomplexeZahl; virtual;abstract;
function Umwandlung2(z1: TKomplexeZahl):TKomplexeZahl; virtual;abstract;
function Ausgabe1():String;
function Ausgabe2():String;
function Ausgabe3():String;
end;
TKartesischeForm=class(TKomplexeZahl)
private
public
constructor Create(a1,b1: EXTENDED);
function addieren(z1,z2: TKomplexeZahl):TKomplexeZahl; override;
function subtrahieren(z1,z2: TKomplexeZahl):TKomplexeZahl; override;
function multiplizieren(z1,z2: TKomplexeZahl):TKomplexeZahl; override;
function dividieren(z1,z2: TKomplexeZahl):TKomplexeZahl; override;
function konjugieren(z1: TKomplexeZahl):TKomplexeZahl; override;
function potenzieren(z1: TKomplexeZahl;n: SmallInt):TKomplexeZahl; override;
function radizieren(z1: TKomplexeZahl;k,n: SmallInt):TKomplexeZahl; override;
function Umwandlung1(z1: TKomplexeZahl):TKomplexeZahl; override;
function Umwandlung2(z1: TKomplexeZahl):TKomplexeZahl; override;
end;
TPolarform=class(TKomplexeZahl)
private
public
constructor Create(r1,alpha1: EXTENDED);
function Winkelkorrektur(alpha1: EXTENDED):EXTENDED;
function addieren(z1,z2: TKomplexeZahl):TKomplexeZahl; override;
function subtrahieren(z1,z2: TKomplexeZahl):TKomplexeZahl; override;
function multiplizieren(z1,z2: TKomplexeZahl):TKomplexeZahl; override;
function dividieren(z1,z2: TKomplexeZahl):TKomplexeZahl; override;
function konjugieren(z1: TKomplexeZahl):TKomplexeZahl; override;
function potenzieren(z1: TKomplexeZahl;n: SmallInt):TKomplexeZahl; override;
function radizieren(z1: TKomplexeZahl;k,n: SmallInt):TKomplexeZahl; override;
function logarithmieren(z1: TKomplexeZahl):TKomplexeZahl; override;
function Umwandlung1(z1: TKomplexeZahl):TKomplexeZahl; override;
function Umwandlung2(z1: TKomplexeZahl):TKomplexeZahl; override;
end;
TExponentialform=class(TKomplexeZahl)
private
public
constructor Create(r1,phi1: EXTENDED);
function Winkelkorrektur(phi1: EXTENDED):EXTENDED;
function addieren(z1,z2: TKomplexeZahl):TKomplexeZahl; override;
function subtrahieren(z1,z2: TKomplexeZahl):TKomplexeZahl; override;
function multiplizieren(z1,z2: TKomplexeZahl):TKomplexeZahl; override;
function dividieren(z1,z2: TKomplexeZahl):TKomplexeZahl; override;
function konjugieren(z1: TKomplexeZahl):TKomplexeZahl; override;
function potenzieren(z1: TKomplexeZahl;n: SmallInt):TKomplexeZahl; override;
function radizieren(z1: TKomplexeZahl;k,n: SmallInt):TKomplexeZahl; override;
function logarithmieren(z1: TKomplexeZahl):TKomplexeZahl; override;
function Umwandlung1(z1: TKomplexeZahl):TKomplexeZahl; override;
function Umwandlung2(z1: TKomplexeZahl):TKomplexeZahl; override;
end;
implementation
function TKomplexeZahl.Ausgabe1():String;
begin
if (a<>0) then begin
if ((b>0) or (b<0)) then
if (b>0) then
if (b<>1) then result:='z='+FloatToStr(a)+'+'+FloatToStr(b)+'i'
else result:='z='+FloatToStr(a)+'+i'
else
if (b<>-1) then result:='z='+FloatToStr(a)+FloatToStr(b)+'i'
else result:='z='+FloatToStr(a)+'-i'
else result:='z='+FloatToStr(a);
end else begin
if ((b>0) or (b<0)) then
if (b>0) then
if (b<>1) then result:='z='+FloatToStr(b)+'i'
else result:='z=i'
else
if (b<>-1) then result:='z='+FloatToStr(b)+'i'
else result:='z=-i'
else result:='z=0';
end;
end;
function TKomplexeZahl.Ausgabe2():String;
begin
result:='z='+FloatToStr(r)+'(cos '+FloatToStr(alpha)+'+sin '+FloatToStr(alpha)+'i)';
end;
function TKomplexeZahl.Ausgabe3():String;
begin
if(r<>1) then result:='z='+FloatToStr(r)+'e^('+FloatToStr(phi)+'i)'
else result:='z=e^('+FloatToStr(phi)+'i)';
end;
constructor TKartesischeForm.Create(a1,b1: EXTENDED);
begin
a:=a1;b:=b1;
end;
function TKartesischeForm.addieren(z1,z2: TKomplexeZahl):TKomplexeZahl;
begin
a:=z1.a+z2.a;b:=z1.b+z2.b;
result:=TKartesischeForm.Create(a,b);
end;
function TKartesischeForm.subtrahieren(z1,z2: TKomplexeZahl):TKomplexeZahl;
begin
a:=z1.a-z2.a;b:=z1.b-z2.b;
result:=TKartesischeForm.Create(a,b);
end;
function TKartesischeForm.multiplizieren(z1,z2: TKomplexeZahl):TKomplexeZahl;
begin
a:=z1.a*z2.a-z1.b*z2.b;b:=z1.a*z2.b+z2.a*z1.b;
result:=TKartesischeForm.Create(a,b);
end;
function TKartesischeForm.dividieren(z1,z2: TKomplexeZahl):TKomplexeZahl;
begin
if ((z2.a<>0) or (z2.b<>0)) then begin
a:=(z1.a*z2.a+z1.b*z2.b)/(SQR(z2.a)+SQR(z2.b));
b:=(z2.a*z1.b-z1.a*z2.b)/(SQR(z2.a)+SQR(z2.b));
result:=TKartesischeForm.Create(a,b);
end else raise ERangeError.Create('Division durch null(r²=0 von z2)');
end;
function TKartesischeForm.konjugieren(z1: TKomplexeZahl):TKomplexeZahl;
begin
a:=z1.a;b:=-z1.b;result:=TKartesischeForm.Create(a,b);
end;
function TKartesischeForm.potenzieren(z1: TKomplexeZahl;n: SmallInt):TKomplexeZahl;
var
z2,z3: TKomplexeZahl;
a2,b2: EXTENDED;
k: WORD;
begin
z3:=TKartesischeForm.Create(1,0);
k:=1;a2:=z1.a;b2:=z1.b;
if (n=0) then
if ((z1.a<>0) or (z1.b<>0)) then a:=1
else raise ERangeError.Create('0^0 ist nicht definiert');
if (n=1) then begin
a:=z1.a;b:=z1.b;
end else begin
while (k<ABS(n)) do begin
a:=z1.a*a2-z1.b*b2;
b:=z1.a*b2+a2*z1.b;
a2:=a;b2:=b;
INC(k);
end;
end;
z2:=TKartesischeForm.Create(a2,b2);
if (n<0) then result:=dividieren(z3,z2)
else result:=TKartesischeForm.Create(a,b);
end;
function TKartesischeForm.radizieren(z1: TKomplexeZahl;k,n: SmallInt):TKomplexeZahl;
begin
a:=SQRT(( SQRT(SQR(z1.a)+SQR(z1.b)) +z1.a)/2);
if (z1.b>0) then b:=SQRT(( SQRT(SQR(z1.a)+SQR(z1.b)) -z1.a)/2) else b:=-SQRT(( SQRT(SQR(z1.a)+SQR(z1.b)) -z1.a)/2);
if (k=2) then begin
a:=-a;b:=-b;
end;
result:=TKartesischeForm.Create(a,b);
end;
function TKartesischeForm.Umwandlung1(z1: TKomplexeZahl):TKomplexeZahl;
begin
r:=hypot(z1.a,z1.b);
alpha:=arctan2(z1.b,z1.a);alpha:=RadToDeg(alpha);
result:=TKartesischeForm.Create(r,alpha);
end;
function TKartesischeForm.Umwandlung2(z1: TKomplexeZahl):TKomplexeZahl;
begin
r:=hypot(z1.a,z1.b);
phi:=arctan2(z1.b,z1.a);
result:=TKartesischeForm.Create(r,phi);
end;
constructor TPolarform.Create(r1,alpha1: EXTENDED);
begin
if (r1>0) then begin
r:=r1;alpha:=Winkelkorrektur(alpha1);
end else raise ERangeError.Create('Betrag hat den Wert 0');
end;
function TPolarform.Winkelkorrektur(alpha1: EXTENDED):EXTENDED;
begin
if (ABS(alpha1)>=360) then
alpha1:=alpha1-360*int(alpha1/360);
if (ABS(alpha1)>=180) then
if (ABS(alpha1)=180) then alpha1:=180
else alpha1:=alpha1-360*ABS(alpha1)/alpha1;
result:=alpha1;
end;
function TPolarform.addieren(z1,z2: TKomplexeZahl):TKomplexeZahl;
begin
z1.alpha:=DegToRad(z1.alpha);z2.alpha:=DegToRad(z2.alpha);
r:=hypot(z1.r*cos(z1.alpha)+z2.r*cos(z2.alpha),
z1.r*sin(z1.alpha)+z2.r*sin(z2.alpha));
if (iszero(r)) then begin
r:=0;alpha:=0;
end else
alpha:=
arctan2(z1.r*cos(z1.alpha)+z2.r*cos(z2.alpha),
z1.r*sin(z1.alpha)+z2.r*sin(z2.alpha));
alpha:=RadToDeg(alpha);
result:=TPolarform.Create(r,alpha);
end;
function TPolarform.subtrahieren(z1,z2: TKomplexeZahl):TKomplexeZahl;
begin
z1.alpha:=DegToRad(z1.alpha);z2.alpha:=DegToRad(z2.alpha);
r:=hypot(z1.r*cos(z1.alpha)-z2.r*cos(z2.alpha),
z1.r*sin(z1.alpha)-z2.r*sin(z2.alpha));
if (iszero(r)) then begin
r:=0;alpha:=0;
end else
alpha:=arctan2(z1.r*cos(z1.alpha)-z2.r*cos(z2.alpha),
z1.r*sin(z1.alpha)-z2.r*sin(z2.alpha));
alpha:=RadToDeg(alpha);
result:=TPolarform.Create(r,alpha);
end;
function TPolarform.multiplizieren(z1,z2: TKomplexeZahl):TKomplexeZahl;
begin
r:=z1.r*z2.r;alpha:=Winkelkorrektur(z1.alpha+z2.alpha);
result:=TPolarform.Create(r,alpha);
end;
function TPolarform.dividieren(z1,z2: TKomplexeZahl):TKomplexeZahl;
begin
r:=z1.r/z2.r;alpha:=Winkelkorrektur(z1.alpha-z2.alpha);
result:=TPolarform.Create(r,alpha);
end;
class function TPolarform.konjugieren(z1: TKomplexeZahl):TKomplexeZahl;
begin
r:=z1.r;
alpha:=Winkelkorrektur(z1.alpha);
if (alpha<>180) then alpha:=-alpha;
result:=TPolarform.Create(r,alpha);
end;
function TPolarform.potenzieren(z1: TKomplexeZahl;n: SmallInt):TKomplexeZahl;
begin
r:=EXP(LN(z1.r)*n);
alpha:=Winkelkorrektur(n*z1.alpha);
result:=TPolarform.Create(r,alpha);
end;
function TPolarform.radizieren(z1: TKomplexeZahl;k,n: SmallInt):TKomplexeZahl;
begin
r:=EXP(LN(z1.r)*(1/n));
alpha:=(z1.alpha+2*k*180)/ABS(n);
if (n<0) then alpha:=-alpha;
alpha:=Winkelkorrektur(alpha);
result:=TPolarform.Create(r,alpha);
end;
function TPolarform.logarithmieren(z1: TKomplexeZahl):TKomplexeZahl;
begin
a:=LN(z1.r);
alpha:=Winkelkorrektur(z1.alpha);
b:=DegToRad(alpha);
result:=TPolarform.Create(a,b);
end;
function TPolarform.Umwandlung1(z1: TKomplexeZahl):TKomplexeZahl;
begin
a:=z1.r*cos(DegToRad(z1.alpha));b:=z1.r*sin(DegToRad(z1.alpha));
result:=TKartesischeForm.Create(a,b);
end;
function TPolarform.Umwandlung2(z1: TKomplexeZahl):TKomplexeZahl;
begin
r:=z1.r;
alpha:=Winkelkorrektur(z1.alpha);phi:=DegToRad(alpha);
result:=TExponentialform.Create(r,phi);
end;
constructor TExponentialform.Create(r1,phi1: EXTENDED);
begin
if (r1>0) then begin
r:=r1;phi:=phi1;
end else raise ERangeError.Create('Betrag hat den Wert 0');
end;
function TExponentialform.Winkelkorrektur(phi1: EXTENDED):EXTENDED;
begin
if (ABS(phi1)>=360) then
phi1:=phi1-360*int(phi1/360);
if (ABS(phi1)>=180) then
if (ABS(phi1)=180) then phi1:=180
else phi1:=phi1-360*ABS(phi1)/phi1;
result:=phi1;
end;
function TExponentialform.addieren(z1,z2: TKomplexeZahl):TKomplexeZahl;
begin
r:=hypot(z1.r*cos(z1.phi)+z2.r*cos(z2.phi),
z1.r*sin(z1.phi)+z2.r*sin(z2.phi));
if (iszero(r)) then begin
r:=0;phi:=0;
end else
phi:=arctan2(z1.r*cos(z1.phi)+z2.r*cos(z2.phi),
z1.r*sin(z1.phi)+z2.r*sin(z2.phi));
result:=TExponentialform.Create(r,phi);
end;
function TExponentialform.subtrahieren(z1,z2: TKomplexeZahl):TKomplexeZahl;
begin
r:=hypot(z1.r*cos(z1.phi)-z2.r*cos(z2.phi),
z1.r*sin(z1.phi)-z2.r*sin(z2.phi));
if (iszero(r)) then begin
r:=0;phi:=0;
end else
phi:=arctan2(z1.r*cos(z1.phi)-z2.r*cos(z2.phi),
z1.r*sin(z1.phi)-z2.r*sin(z2.phi));
result:=TExponentialform.Create(r,phi);
end;
function TExponentialform.multiplizieren(z1,z2: TKomplexeZahl):TKomplexeZahl;
begin
r:=z1.r*z2.r;phi:=Winkelkorrektur(z1.phi+z2.phi);
result:=TExponentialform.Create(r,phi);
end;
function TExponentialform.dividieren(z1,z2: TKomplexeZahl):TKomplexeZahl;
begin
r:=z1.r/z2.r;phi:=Winkelkorrektur(z1.phi-z2.phi);
result:=TExponentialform.Create(r,phi);
end;
function TExponentialform.konjugieren(z1: TKomplexeZahl):TKomplexeZahl;
begin
r:=z1.r;
phi:=WInkelkorrektur(z1.phi);
if (phi<>PI) then phi:=-phi;
result:=TExponentialform.Create(r,phi);
end;
function TExponentialform.potenzieren(z1: TKomplexeZahl;n: SmallInt):TKomplexeZahl;
begin
r:=EXP(LN(z1.r)*n);
phi:=Winkelkorrektur(n*z1.phi);
result:=TExponentialform.Create(r,phi);
end;
function TExponentialform.radizieren(z1: TKomplexeZahl;k,n: SmallInt):TKomplexeZahl;
begin
r:=EXP(LN(z1.r)*(1/n));
phi:=(z1.phi+2*k*PI)/ABS(n);
if (n<0) then phi:=-phi;
phi:=Winkelkorrektur(phi);
result:=TExponentialform.Create(r,phi);
end;
function TExponentialform.logarithmieren(z1: TKomplexeZahl):TKomplexeZahl;
begin
a:=LN(z1.r);
b:=Winkelkorrektur(z1.phi);
result:=TExponentialform.Create(a,b);
end;
function TExponentialform.Umwandlung1(z1: TKomplexeZahl):TKomplexeZahl;
begin
a:=z1.r*cos(z1.phi);b:=z1.r*sin(z1.phi);
result:=TKartesischeForm.Create(a,b);
end;
function TExponentialform.Umwandlung2(z1: TKomplexeZahl):TKomplexeZahl;
begin
r:=z1.r;
phi:=Winkelkorrektur(z1.phi);alpha:=RadToDeg(phi);
result:=TPolarform.Create(r,alpha);
end;
end. |
Meine andere Unit die KOMPLEX einbindet und für die GUI verantwortlich ist sieht wie folgt aus.
1:
2:
3:
4:
5:
6:
7:
8:
9:
10:
11:
12:
13:
14:
15:
16:
17:
18:
19:
20:
21:
22:
23:
24:
25:
26:
27:
28:
29:
30:
31:
32:
33:
34:
35:
36:
37:
38:
39:
40:
41:
42:
43:
44:
45:
46:
47:
48:
49:
50:
51:
52:
53:
54:
55:
56:
57:
58:
59:
60:
61:
62:
63:
64:
65:
66:
67:
68:
69:
70:
71:
72:
73:
74:
75:
76:
77:
78:
79:
80:
81:
82:
83:
84:
85:
86:
87:
88:
89:
90:
| unit GUI;
interface
uses
Windows,Messages,SysUtils,Variants,Classes,Graphics,Controls,Forms,
Dialogs,StdCtrls,KOMPLEX,INFO, Menus, ExtCtrls;
type
TfmKZ = class(TForm)
Label1: TLabel;
Label2: TLabel;
Label3: TLabel;
Edit1: TEdit;
Edit2: TEdit;
Edit3: TEdit;
Edit4: TEdit;
Edit5: TEdit;
CBAuswahl1: TComboBox;
CBAuswahl2: TComboBox;
btnRechnen: TButton;
btnEnde: TButton;
ListBox1: TListBox;
PopupMenu1: TPopupMenu;
MainMenu1: TMainMenu;
Datei1: TMenuItem;
Hilfe1: TMenuItem;
Hilfe2: TMenuItem;
INFO1: TMenuItem;
Leeren1: TMenuItem;
Beenden1: TMenuItem;
Leeren2: TMenuItem;
Beenden2: TMenuItem;
procedure Edit1KeyPress(Sender: TObject;var Key: Char);
procedure Edit5KeyPress(Sender: TObject;var Key: Char);
procedure CBAuswahl1KeyPress(Sender: TObject;var Key: Char);
procedure CBAuswahl1Change(Sender: TObject);
procedure CBAuswahl2Change(Sender: TObject);
procedure Leeren1Click(Sender: TObject);
procedure btnRechnenClick(Sender: TObject);
procedure btnEndeClick(Sender: TObject);
procedure Hilfe2Click(Sender: TObject);
procedure INFO1Click(Sender: TObject);
private
public
end;
var
fmKZ: TfmKZ;
implementation
{$R *.dfm}
...
procedure TfmKZ.btnRechnenClick(Sender: TObject);
var
z1,z2,erg: TKomplexeZahl;
k: WORD;
begin
k:=0;
if ((CBAuswahl1.ItemIndex<>-1) and (CBAuswahl2.ItemIndex<>-1)) then begin
try
if (Listbox1.Items.Count<>0) then Listbox1.Clear;
...
z1:=TKartesischeForm.Create(StrToFloat(Edit1.Text),StrToFloat(Edit3.Text));
if (CBAuswahl2.ItemIndex<4) then
z2:=TKartesischeForm.Create(StrToFloat(Edit2.Text),StrToFloat(Edit4.Text));
case CBAuswahl2.ItemIndex of
0: erg.addieren(z1,z2);
1: erg.subtrahieren(z1,z2);
2: erg.multiplizieren(z1,z2);
3: erg.dividieren(z1,z2);
4: erg.konjugieren(z1);
5: erg.potenzieren(z1,StrToInt(Edit5.Text));
...
end;
except
...
end;
end;
end;
procedure TfmKZ.btnEndeClick(Sender: TObject);
begin
close;
end; |
|
|
Tryer
Beiträge: 226
Erhaltene Danke: 7
|
Verfasst: Mi 30.09.09 18:55
|
|
Kha
Beiträge: 3803
Erhaltene Danke: 176
Arch Linux
Python, C, C++ (vim)
|
Verfasst: Mi 30.09.09 19:26
@ Tryer: Ich glaube, das hat er verstanden ...
| baphumet hat folgendes geschrieben : | | der Betrag r bleibt erhalten |
Alphi und Phi enstprechen sich doch genauso. Du hast zwei Klassen, die exakt die gleichen Parameter enthalten und in fast allen Fällen genau gleich rechnen, deswegen ist die trigonometrische Form imo unnötig. Exponential- und algebraische Form reichen vollkommen aus.
| baphumet hat folgendes geschrieben : | | class function ist in Delphi 7 möglich, aber ich habe keine Ahnung wie das bei mir jetzt aussehen müsste. |
Wie gesagt: Für Polymorphie sehe ich hier wenig Chancen. Wenn du trotzdem in der Lage sein willst, zwei TKomplexeZahl-Instanzen zu addieren, ohne ihre genaue Form zu kennen, wirst du in der Basisklasse solche Methoden erstellen müssen:
Delphi-Quelltext
1:
| class function TComplex.Add(z1 : TComplex; z2 : TComplex) : TComplex; |
In der Implementierung überprüfst du dann per is, um welche Formen es sich handelt, und führst die entsprechende Rechnung durch. Damit hättest du effektiv Algebraic Data Types und Pattern Matching aus der funktionalen Programmierung nachgebaut.
Die "Winkelkorrigierung" kann ruhig im Konstruktor bleiben, dort gehört sie hin. Was du allerdings unbedingt ändern solltest: Wozu braucht die kartesische Form denn ein "phi"? Deklariere die Klassenfelder erst in der Klasse, in der du sie brauchst. Also a und b in der kartesischen, r und phi in der polaren.
Wenn du auf diese Abstraktion verzichten kannst, stellst du lieber konkrete Methoden wie
Delphi-Quelltext
1:
2:
3:
| class function TComplexCartesian.Add(z1 : TComplexCartesian; z2 : TComplexCartesian) : TComplexCartesian;
...
class function TComplexPolar.Add(z1 : TComplexPolar; z2 : TComplexPolar) : TComplexPolar; |
und Methoden zum Umwandeln bereit. Dann gibt es auch keinen wirklichen Grund mehr, überhaupt noch Klassen statt Records zu benutzen. _________________ >λ=
|
|
baphumet
Beiträge: 44
Windows XP
Delphi 7
|
Verfasst: Do 01.10.09 00:18
Hi, Kha deine Antwort klingt logisch und ich ist für mich nachvollziehbar. Versuche diese gerade anzuwenden und zu programmieren, wie ich richtig sehe können die Konstruktoren in den abgeleiten Klassen unverändert bleiben, benötigen also keine class.
Außerdem möchte ich mich hiermit bei allen in aller Form für mein Benehmen entschuldigen, ist nicht meine Art, aber wenn man paar Tage an einem Problem hängt und verzweifelt nach einer ordentlichen Lösung sucht, dann liest man nicht mehr richtig und ist schon mit den Nerven am Ende. Nochmals Entschuldigung.
Mein Code sieht so aus, das mit dem is Operator muß in jeder Methode getan werden, es muss also georüft werden was für Objekte z1 und z2 sind, also von welcher Klasse.
1:
2:
3:
4:
5:
6:
7:
8:
9:
10:
11:
12:
13:
14:
15:
16:
17:
18:
19:
20:
21:
22:
23:
24:
25:
26:
27:
28:
29:
30:
31:
32:
33:
34:
35:
36:
37:
38:
39:
40:
41:
42:
43:
44:
45:
46:
47:
48:
49:
50:
51:
52:
53:
54:
55:
56:
57:
58:
59:
60:
61:
62:
63:
64:
65:
66:
67:
68:
69:
70:
71:
72:
73:
74:
75:
76:
| TKomplexeZahl=class
private
public
class function addieren(z1,z2: TKomplexeZahl):TKomplexeZahl; virtual;abstract;
class function subtrahieren(z1,z2: TKomplexeZahl):TKomplexeZahl; virtual;abstract;
class function multiplizieren(z1,z2: TKomplexeZahl):TKomplexeZahl; virtual;abstract;
class function dividieren(z1,z2: TKomplexeZahl):TKomplexeZahl; virtual;abstract;
class function konjugieren(z1: TKomplexeZahl):TKomplexeZahl;virtual;abstract;
class function potenzieren(z1: TKomplexeZahl;n: SmallInt):TKomplexeZahl; virtual;abstract;
class function radizieren(z1: TKomplexeZahl;k,n: SmallInt):TKomplexeZahl; virtual;abstract;
class function logarithmieren(z1: TKomplexeZahl):TKomplexeZahl; virtual;abstract;
class function Umwandlung1(z1: TKomplexeZahl):TKomplexeZahl; virtual;abstract;
class function Umwandlung2(z1: TKomplexeZahl):TKomplexeZahl; virtual;abstract;
function Ausgabe1():String;
function Ausgabe2():String;
function Ausgabe3():String;
end;
TKartesischeForm=class(TKomplexeZahl)
private
a,b
public
constructor Create(a1,b1: EXTENDED);
class function addieren(z1,z2: TKomplexeZahl):TKomplexeZahl; override;
class function subtrahieren(z1,z2: TKomplexeZahl):TKomplexeZahl; override;
class function multiplizieren(z1,z2: TKomplexeZahl):TKomplexeZahl; override;
class function dividieren(z1,z2: TKomplexeZahl):TKomplexeZahl; override;
class function konjugieren(z1: TKomplexeZahl):TKomplexeZahl; override;
class function potenzieren(z1: TKomplexeZahl;n: SmallInt):TKomplexeZahl; override;
class function radizieren(z1: TKomplexeZahl;k,n: SmallInt):TKomplexeZahl; override;
class function Umwandlung1(z1: TKomplexeZahl):TKomplexeZahl; override;
class function Umwandlung2(z1: TKomplexeZahl):TKomplexeZahl; override;
end;
TPolarform=class(TKomplexeZahl)
private
r,alpha: EXTENDED;
public
constructor Create(r1,alpha1: EXTENDED);
class function Winkelkorrektur(alpha1: EXTENDED):EXTENDED;
class function addieren(z1,z2: TKomplexeZahl):TKomplexeZahl; override;
class function subtrahieren(z1,z2: TKomplexeZahl):TKomplexeZahl; override;
class function multiplizieren(z1,z2: TKomplexeZahl):TKomplexeZahl; override;
class function dividieren(z1,z2: TKomplexeZahl):TKomplexeZahl; override;
class function konjugieren(z1: TKomplexeZahl):TKomplexeZahl; override;
class function potenzieren(z1: TKomplexeZahl;n: SmallInt):TKomplexeZahl; override;
class function radizieren(z1: TKomplexeZahl;k,n: SmallInt):TKomplexeZahl; override;
class function logarithmieren(z1: TKomplexeZahl):TKomplexeZahl; override;
class function Umwandlung1(z1: TKomplexeZahl):TKomplexeZahl; override;
class function Umwandlung2(z1: TKomplexeZahl):TKomplexeZahl; override;
end;
TExponentialform=class(TKomplexeZahl)
private
r,phi: EXTENDED;
public
constructor Create(r1,phi1: EXTENDED);
class function Winkelkorrektur(phi1: EXTENDED):EXTENDED;
class function addieren(z1,z2: TKomplexeZahl):TKomplexeZahl; override;
class function subtrahieren(z1,z2: TKomplexeZahl):TKomplexeZahl; override;
class function multiplizieren(z1,z2: TKomplexeZahl):TKomplexeZahl; override;
class function dividieren(z1,z2: TKomplexeZahl):TKomplexeZahl; override;
class function konjugieren(z1: TKomplexeZahl):TKomplexeZahl; override;
class function potenzieren(z1: TKomplexeZahl;n: SmallInt):TKomplexeZahl; override;
class function radizieren(z1: TKomplexeZahl;k,n: SmallInt):TKomplexeZahl; override;
class function logarithmieren(z1: TKomplexeZahl):TKomplexeZahl; override;
class function Umwandlung1(z1: TKomplexeZahl):TKomplexeZahl; override;
class function Umwandlung2(z1: TKomplexeZahl):TKomplexeZahl; override;
end;
implementation
class TPolarform.function addieren(z1,z2: TKomplexeZahl):TKomplexeZahl;
begin
if z1 is TPolarform and z2 is TPolarform then result:=TPolarform(Rechnung);
end; |
Meine Frage ist das mit dem is jetzt richtig und wie ich das Ergebnis zurückgebe oder hab ich etwas falsch gemacht nach deiner Ansicht?
|
|
|
