| Autor |
Beitrag |
perry5
      
Beiträge: 102
|
Verfasst: Sa 26.08.06 13:39
Also, hier kommt dann noch eine Frage von mir:
Wenn man in Delphi ein Objekt erzeugt, muss man dann IMMER den Konstruktor manuell aufrufen?
In C++ ist es ja so, das der beim anlegen der Variable automatisch aufgerufen wird, aber da man bei Delphi keine Variablen mitten in der Pocedure erzeugen kann, sondern immer nur am Anfang, daher könnte man dem Konstruktor keine erst zu berechneten Werte übergeben.
Wenn man den Konstrktor also immer manuell aufrufen muss, was hat man dann wenn man ihn noch nciht aufgerufen hat? Ein nicht existierendes Objekt ist ja komisch, also hat man dann ein Zeiger auf ein nicht existierendes Objekt?
So, wenn dann alle Objekte in wirklichkeit versteckte Zeiger auf Objekte sind, was passeirt bei einer Zuweisung?
Hat man dann zwei Zeiger auf dasselbe Objekt (daher wenn man eins verändert, verändert man damit beide) oder wird das Objekt kopiert?
Und wenn es kopiert wird, wie wird es dann kopiert? Manchmal könnte man, wenn das Objekt selber Zeiger beinhaltet falche oder Tiefe Kopien wünschen. Wenn man in Delphi keine Operatoren überladen kann, dann kann man das nicht selber entscheidne oder?
Ich bin total verwirrt. In C++ weiß ich halt relativ genau, wie alles funktioniert, aber in delphi hab ich davon irgendwie noch keine Ahnung.
|
|
Allesquarks
      
Beiträge: 510
Win XP Prof
Delphi 7 E
|
Verfasst: Sa 26.08.06 14:36
Grundsätzlich stimmt eigentlich alles was du vermutest ist aber nicht so die Einschränkung wie du denkst.
1. Du kannst den Konstructor an beliebiger Stelle in Delphi aufrufen also nicht unbedingt zu prozedurbeginn, aber einmal muss er aufgerufen werden, um den Speicher zu bekommen aber das ist damit äquivalent zu C++. Also muss er vor benutzung einmal aufgerufen werden danach nicht mehr. Also immer ein create aber das ist auch nicht soviel arbeit. Bei dem Aufruf in delphi kannst du natürlich auch Werte übergeben ist ja einfach nur eine function bzw prozedur die mit constructor deklariert ist und nen bischen Speicher reserviert.
2. Ja bei Zuweisungen mit := werden nur referenzen sprich Zeiger kopiert. Sollte man anderes benötigen steht manchmal ein assign zur Verfügung. Oder man muss das rekursiv runterkochen bis zu den Basistypen, denn die werden wirklich kopiert bis auf die Strings, aber bei denen gibt es automatisch eine Referenzzählung.
3. Ohne Operator overloading ist wenn man das zu Beginn nicht gewusst hat schwierig (mir gehts genauso). Wenn man das aber weiß dann kann man auch jedesmal eine Zuweisungsprozedur (assign) aufrufen oder eine Referenzzählungsprozedur.
P.S: Delphi 2006 unterstützt Operator overloading und nebenbei auch Lazarus
|
|
perry5 
      
Beiträge: 102
|
Verfasst: Sa 26.08.06 14:41
Ok, das heißt wenn ich einer Klase mal ein VectorObjket übergeben möchte, muss ich dann in der Funktion die die Aufruft das VectorObjket erstellen mit dem Konstruktor und dann dem anderen Objekt übergeben.
Dann darf ich in der Funktion in der ich es erstellt habe nicht den Destruktor des Objektes aufrufen, oder? Wird der den wenigstens automatisch aufgerufen, oder muss man das immer selber machen?
Daher müsste ich dann mit Objekten wie mit dynamsichen Speicher unter C++ umgehen, also immer daraufachten die einmal zu erstellen und auch genau nur ein einziges mal an der richtigen Stelle und zum richtigen zeitpunkt wieder löschen. Oder?
Und um das Objket wirklich zu kopieren, muss ich eine spezielle Funktion schreiben die weider den Konstruktor aufruft, und dann die einzelnen Variablen in das neue Objekt rüberkopiert, ne?
|
|
Allesquarks
      
Beiträge: 510
Win XP Prof
Delphi 7 E
|
Verfasst: Sa 26.08.06 15:48
OK Also ein paar Sachen scheinen da noch etwas vage zu sein:
1. Klassen werden dynamisch erzeugt und zerstört => dynamischer Speicher (nebenbei das ist in C++ meines Wissens genauso).
2. C++ ruft den Destructor selber auf ??????? Wann tut es denn das am Ende des Programms??? Das kann Delphi auch!!! Ist aber nicht der gute Ton und in einem Modularisierten Programm mit Bedingten stellen (das sind if's) kann das der Compiler nicht voraussehen. Sprich ich glaube da nicht dran.
3. Bei einem eigenen assign musst du das auf die Grundtypen runterkochen, das haißt, wenn ein komplexer Datentyp Bestandteil der Instanz deiner Klasse ist soll der ja auch "assigned" werden soll. Das heißt du brauchst Speicher => Konstructor und dann die Variablen in dieser Klasse assignen.
4. Ein Konstruktor ist primär zur Erstellung der Instanz einer Klasse da und erst sekundär zur Initialisierung des Objektes da, was durch die heutigen Programmierumgehungen leider kaum noch auffällt.
Was du mit deinem Vektor Objekt meinst hab ich keinen blassen Schimmer.
|
|
perry5 
      
Beiträge: 102
|
Verfasst: Sa 26.08.06 17:33
Ja, C++ ruft den Destruktor selber auf. Man kann in C++ Variablen grundsätzlich auf 2 Speicherberecihen anlegen. Einmal dynmaisch, dann kann man nur durch Zeiger darauf zugreifen und muss den Speicher selber wieder freigeben und dann nocht als ganz normale Variable die zerstört wird, sobald der Teil in dem sie erstellt wurde verlassen wird. Das gilt sowohl für Objekte als auch für Standardtypen.
Hat man also in einer Funktion ein Objekt als lokale Variable, wird sowohl der Destruktor als auch der Konstruktor automatisch aufgerufen, es sei den, man erstellt sie dynamisch per new.
Mit dem Vektor Objekt meine ich ganz einfach einen mathematischen Vektor, der für verschiedene Rechenopertaionen gebraucht wird.
|
|
mkinzler
      
Beiträge: 4106
Erhaltene Danke: 13
Delphi 2010 Pro; Delphi.Prism 2011 pro
|
Verfasst: Sa 26.08.06 19:44
Delphi arbeitet wie auch Java und c# mit referenzen. D.h. es gibt nicht wie noch in Turbopascal und wie es scheint auch in c++ die Trennung zwischen Objekt und Zeiger auf Objekt. Referenzen sind eigentlich Zeiger auf die man wie auf ein Objekt zugreifen kann.
Bsp Turbo Pascal (geht auch noch in Delphi)
Delphi-Quelltext 1: 2: 3: 4: 5: 6: 7: 8: 9: 10: 11: 12: 13: 14: 15: 16: 17: 18: 19:
| Var PMyClass = ^TMyClass; TMyClass = object Text: string; end; ... type a: TmyClass; b: PmyClass;
... a.Text := 'Hallo';
b := new ( PMyClass); b^.text := 'Welt'; ... dipose(b); |
Bsp Delphi
Delphi-Quelltext 1: 2: 3: 4: 5: 6: 7: 8: 9: 10: 11: 12:
| type TMyClass = class Text: string; end; ... var a: TMyClass; ... a := TmyClass.Create; a.Text := 'hallo'; ... a.Free; |
_________________ Markus Kinzler.
|
|
perry5 
      
Beiträge: 102
|
Verfasst: Sa 26.08.06 22:33
Ok, wenn ich jetzt eine Funktion schreibe die ein Objekt zurückgeben soll, muss ich dann erst result:=Klase.Construktor; schreiben, bevor ich dme result was zuweisen kann? Und dann in der Funktion/Procedure die diese erste Funktion aufgerufen hat erst wieder den Destruktor? (wir hatten das halt in Info nicht so ausführlich)
|
|
JayEff
      
Beiträge: 2971
Windows Vista Ultimate
D7 Enterprise
|
Verfasst: Sa 26.08.06 23:07
Also so wie ich das verstehe, musst du den Constructor aufrufen, um Speicher für Result zu reservieren. Da du irgentwann xyz:=funktion; machen wirst, wird der Speicher bei xyz.free; wieder freigegeben.
_________________ >+++[>+++[>++++++++<-]<-]<++++[>++++[>>>+++++++<<<-]<-]<<++
[>++[>++[>>++++<<-]<-]<-]>>>>>++++++++++++++++++.+++++++.>++.-.<<.>>--.<+++++..<+.
|
|
mkinzler
      
Beiträge: 4106
Erhaltene Danke: 13
Delphi 2010 Pro; Delphi.Prism 2011 pro
|
Verfasst: So 27.08.06 08:06
perry5 hat folgendes geschrieben: | | Ok, wenn ich jetzt eine Funktion schreibe die ein Objekt zurückgeben soll, muss ich dann erst result:=Klase.Construktor; schreiben, bevor ich dme result was zuweisen kann? |
Es kommt darauf an, was du zuweisen willst, wenn du ein neues Objekt zurückliefern willst, brauchts du ne lokale Refrenzvaribsle die du instantieerst, die Werte setzt und dann result zuweist.[/quote]
Und dann in der Funktion/Procedure die diese erste Funktion aufgerufen hat erst wieder den Destruktor? (wir hatten das halt in Info nicht so ausführlich)[/quote]In diesem Fall darf der Destruktor erst nach Verwendung des Objekts aufgerufen werden.
_________________ Markus Kinzler.
|
|
perry5 
      
Beiträge: 102
|
Verfasst: So 27.08.06 16:42
Wenn ich jetzt eine einfache Vector Klasse habe, die eignetilhc nur 3 reals speichert. Wäre es dann nicht sinnvoller, statt ner Klasse ein Record zu machen? Dann würde ich mir doch eigentlich die ganzen Konstruktoren sparen können.
Denn wenn quasi das gesamte Programm auf Vektorrechnung beruht, kann man leicht durcheinander kommen, wann man was erstellen oder wieder zerstören muss.
|
|
JayEff
      
Beiträge: 2971
Windows Vista Ultimate
D7 Enterprise
|
Verfasst: So 27.08.06 16:44
Ähm ja. Ich hab letztens auch Vektorrechnungen angestellt und klar bieten sich am ehesten Records an.
_________________ >+++[>+++[>++++++++<-]<-]<++++[>++++[>>>+++++++<<<-]<-]<<++
[>++[>++[>>++++<<-]<-]<-]>>>>>++++++++++++++++++.+++++++.>++.-.<<.>>--.<+++++..<+.
|
|
mkinzler
      
Beiträge: 4106
Erhaltene Danke: 13
Delphi 2010 Pro; Delphi.Prism 2011 pro
|
Verfasst: So 27.08.06 16:45
@perry: Welche Version von Delphi? Ab D10 kann man für Record class operatoren setzen!
_________________ Markus Kinzler.
|
|
perry5 
      
Beiträge: 102
|
Verfasst: So 27.08.06 16:50
sry, ganz vergessen. Diese kostenlos Delphi 6 Version hab ich von meinem Infolehrer.
|
|
mkinzler
      
Beiträge: 4106
Erhaltene Danke: 13
Delphi 2010 Pro; Delphi.Prism 2011 pro
|
Verfasst: So 27.08.06 16:52
Dann würde ich mir Turbo Delphi Explorer Version holen, die auf BDS2006 basiert und ab ca. 5.Sep. umsonst bezogen werden kann.
_________________ Markus Kinzler.
|
|
catweasel
      
Beiträge: 487
Erhaltene Danke: 1
Win 7 64bit
Delphi 7 Second Sedition V7.2
|
Verfasst: Mo 04.09.06 13:44
Hi,
| Zitat: | | Bei einem eigenen assign musst du das auf die Grundtypen runterkochen, das haißt, wenn ein komplexer Datentyp Bestandteil der Instanz deiner Klasse ist soll der ja auch "assigned" werden soll |
Hier hab ich mal ne kleine Frage dazu.....
Kann man das nicht mit einem CustomVariant loesen ?
Das Delphi Typsystem bietet da ganz nette Schnittstellen fuer das erstellen eigener Variants...
catweasel
_________________ Pommes werden schneller fertig wenn man sie vor dem Frittieren einige Minuten in siedendes Fett legt.
|
|