delete

[NicTheQuick]

Unabhängig von dieser Antwort würde mich trotzdem interessieren, ob es für jemanden mit meinem Kenntnisstand frei verfügbare Lektüre gibt, die einem das Thema näher bringen. Lektüre, deren Wissen ich auch in SimpleOOP anwenden kann und die nicht nur andere mainstream OOP-Dialekte voraussetzen.

Das hier könnte dich interessieren: Design Patterns

[Danilo]

Das hier könnte dich interessieren: Design Patterns

Vielleicht besser erst einmal mit Objektorientierte Programmierung anfangen.
Da kann er sich erst einmal einige Grundlagen über Klassen, Methoden, Datenkapselung und Vererbung anlesen.

Bei Galileo Computing – <openbook> gibt es auch noch Objektorientierte Programmierung - Das umfassende Handbuch zum online lesen und runterladen.

Beispiele sind zwar in C++, C#, Java, Javascript, Ruby und Python - aber es sollte doch meist lesbar sein:

Code: Alles auswählen

class PdfDatei extends AusgabeMedium {
    void ausgeben(Grafik grafik) {
        grafik.ausgebenAlsPdfDatei(this);
    }
}

class Bildschirm extends AusgabeMedium {
    void ausgeben(Grafik grafik) {
        grafik.ausgebenAufBildschirm(this);
    }
}

Vielleicht kannst Du dann gleich das Gelernte nach PureBasic und SimpleOOP übersetzen.

[Kurzer]

Hallo ihr beiden,

vielen Dank für Eure Tipps.
Besonders das Buch von Open Galileo ist sehr interessant. Damit komme ich auf jeden Fall weiter.

Eine interessante Thematik ist es allemal.

@Sirhc.ITI:
Deine mitgelieferten Beispiele sind prima, jedoch wäre es für jemanden der in OOP einsteigt besser, wenn diese nach Schweirigkeitsgrad chronologisch durchnummeriert wäre. Damit könnte man sich von den einfachen Beispielen zu den komplexen durcharbeiten. Momentan sind die Beispiele gar nicht sortiert (bzw. nach Namen, je nach Sortiereinstellung des Dateiexplorers).

[Kurzer]

Sorry für's mehrfach posten.

Beim studieren der empfohlenen Lektüre und testen der mitgelieferten SimpleOOP Beispiele ist folgende Frage aufgekeimt.

Im Beispielcode "Init.pb" wird eine Klasse Test deklariert und unter anderem die Methoden Init() und Release() - siehe unten.

Diese beiden Methoden sind ja insofern etwas spezielles, als dass sie automatisch beim Erstellen eines Objekts/Exemplars (Init) und beim Freigeben eines Objekt/Exemplars (Release) ausgeführt werden.

Ich frage mich warum diese Methoden dann im Beispiel Public sind. Durch die automatische Ausführung muss man sie nicht mehr zwingend manuell "von außen" aufrufen.

Daher habe ich in dem Beispiel aus der Public Method Release() eine Protect Method Release() gemacht und den Code ausgeführt.

Zu meiner Überraschung wurde Release() darauf hin gar nicht mehr ausgeführt.
Die Methode sollte doch eigentlich aus Sicht der Klasse noch immer sichtbar und aufrufbar sein, oder nicht?

Weder der automatische Aufruf, noch ein manueller Aufruf durch *Object\Release() führt zur Ausführung. Der manuelle Aufruf wird richtigerweise schon zur Kompilierungszeit als Fehler abgewiesen.

Habe ich hier was falsch verstanden?

Code: Alles auswählen

Class Test
	
	Public Method Init() ; Wird automatisch bei NewObject aufgerufen
		Debug "Init() (NewObject called (This = "+Str(This)+")"
	EndMethod
	
	Public Method Starten()
		Debug "Starten()"
	EndMethod
	
	Public Method Release()
		Debug "Release()"
	EndMethod
	
EndClass

*Object.Test = NewObject.Test ; ruft Automatisch Init auf sofern vorhanden

*Object\Starten()
Debug "*Object = "+Str(*Object)

*Object = FreeObject
Debug "*Object = "+Str(*Object)

[Danilo]

Ich frage mich warum diese Methoden dann im Beispiel Public sind. Durch die automatische Ausführung muss man sie nicht mehr zwingend manuell "von außen" aufrufen.

Ein neues ObjeKt wird aber "von außen" erstellt. D.h. eine Funktion (new in C++) von außen ruft das Init auf,
wenn eine neue Instanz erstellt wird. Ist Init aber nicht Public, kann das Objekt von außen nicht erstellt werden.
Beim Pattern Singleton machst Du das z.B. so. Init wird öffentlich gesperrt und das Objekt kannst Du dann nur
über eine statische Methode von innen selbst erzeugen.

Anders gesagt: Wo stehen 'NewObject' und 'FreeObject' in Deinem Code? Sie stehen außerhalb Class/EndClass,
also haben sie auch nur den entsprechenden Zugriff von außen. Nur alles was innerhalb Class/EndClass steht
hat immer vollen Zugriff auf das Innere.

[Kurzer]

Vielen Dank fürs aufklären, Danilo.
Jetzt hab ich's richtig verstanden.

[Kurzer]

Nun habe ich doch noch eine Frage zur Singleton Klasse.
Warum kann ein erzeugtes Singleton Objekt nie wieder freigegeben werden? Welchen Sinn hat das?

Ich vermute der Speicher für eine solche Klasse wird letztendlich beim Programmende freigegeben.

[Kurzer]

Sorry für den tripple-Post, aber ich hoffe in diesem Thread einen der SimpleOOP Anwender anzutreffen - wenn nicht gar Sirhc.ITI selbst.

Ich bekomme in einem neu aufgesetzten Projekt, welches ich erstmals mit Unterstützung von SimpleOOP realisieren möchte, einen SimpleOOP spezifischen Fehler, den ich mir nicht erklären kann.

Wenn man von dem Verwaltungscode absieht und der Tatsache, dass der Code über mehrere Includedateien verteilt ist, dann läßt sich der OOP-spezifische Teil mit den folgenden Zeilen nachbilden (ja, mehr als das Programmgerüst steht noch nicht):

Code: Alles auswählen

Structure Settings
	x.i
	y.i
	Width.i
	Height.i
EndStructure

Class Sudoku
	; +-----------------------------------------------------------------
	; |Description  : Beschreibung der Klasse
	; |Init-Args    : arg1    : -
	; |             : arg2    : -
	; |Results      : -
	; |Remarks      : -
	; +-----------------------------------------------------------------
	
	BeginPrivate
		SudokuSettings.Settings
	EndPrivate
	
	Public Method Init()
		Debug "Init()"
	EndMethod
	
	Public Method Release()
		Debug "Release()"
	EndMethod
	
EndClass

Global *MySudoku.Sudoku

*MySudoku = NewObject.Sudoku()

*MySudoku = FreeObject

Nur tritt bei dieser Rekonstruktion der Fehler nicht auf.
Ich vermute, dass das Problem an der Aufteilung des Codes auf mehrere Dateien liegt. Oder es ist wirklich ein ganz einfacher, offensichtlicher Anwendungsfehler und ich sehe ihn einfach nicht.

Problem:
Zur Compilierungszeit wird mir folgende Meldung angezeigt:



Die Datei, in der der Fehler angezeigt wird, ist eine von SimpleOOP erstellte Datei, in der der nach PureBasic übersetzte OOP Code steht.

Da es zu aufwändig wäre die Einzeldateien und die Projektdateien hier einzeln zu posten, habe ich das gesamte Projekt geZIPt und hochgeladen. Zur Rekonstruktion braucht ihr nur den Inhalt des ZIPs in einen Ordner entpacken und dann die Projektdatei "Sudoku.pbp" im Editor öffnen. Dann einafch F5 drücken und BÄMM.

Das ZIP Archiv könnt ihr hier runterladen:

http://www.fastshare.org/download/Sudoku___OOP.zip

Ich würde mich über Hinweise zur Lösung des Problems freuen.
Vielleicht ist es ja auch noch ein internes Problem von SimpleOOP?

Edit: Das Problem tritt auch beim Aufruf aller weiteren Methoden auf, wenn diese der Klasse zugefügt wurden.
Einzig das Init() wird ohne Murren ausgeführt. Fügt man der Klasse noch eine weitere Methode zu (die z.B. nur eine Debugausgabe macht) und ruft diese aus einer anderen Includedatei aus auf (z.B. Main.pbi), dann kracht es mit der selben Meldung.

Edit 2: @Sirhc.ITI
Ich habe mir den Quellcode von SimpleOOP jetzt mal vorgenommen. Leider konnte ich den Fehler bisher nicht beheben (Zeitgründe), aber zumindest weiter einkreisen:

In der Datei SimpleOOP.pb ist speziell in meinem Fall die Liste Objects() leer.
Gut zu erkennen, wenn man sich einen Breakpoint auf die Zeile 1491 legt und das ganze prüft.

FindObjectProcedureCalls(), ab Zeile 1489:

Code: Alles auswählen

					Else
						CallObjectClass$ = ""
						If LastElement(Objects()) ; Klasse zu Object in NewObjects() suchen
							Repeat
								
								If Objects()\IsMainFile = IsMainFile ; Object in Liste ist in der selben datei
									
									If Objects()\Line < ListIndex(Quelldatei()) Or (Objects()\Line = ListIndex(Quelldatei()) And Objects()\Row < ListIndex(TokenLine()))
usw...

Aus irgend einem Grund wird das Objekt nicht in diese Liste eingetragen was dazu führt, dass SimpleOOP im bearbeiteten Quelltext einen ...\SOOP_FreeObject() Aufruf OHNE Parameter erzeugt.

Leider kann ich jetzt nicht weiter forschen wegen Weihnachtsfeierlichkeiten, Familie usw.

[Andreas21]

Den fehler hatte ich aber auch schon.

Nach vielen hin und her hats bei mir geholfen ein Space oder Tab vor z.b. *MySudoku = NewObject.Sudoku() in einer Class zu setzen wenn ich sie da nutzen wolte aber wegen dem fehler nicht gehen wolte.

[Kurzer]

Danke für den Tipp, Andreas.
Leider hilft er in meinem Fall nicht. Die Liste "Objekt()" wird dennoch nicht gefüllt.

Edit:
So, habe jetzt einen Workaround gefunden.
Entgegen der SimpleOOP-Beispiele, die alle so kodiert sind:

Code: Alles auswählen

*Object.Test = NewObject.Test 
*Object = FreeObject

Muss ich beim FreeObject in meinem Fall immer den Objekttypen mit angeben, damit SimpleOOP fehlerfrei compiliert.

Code: Alles auswählen

*MySudoku.Sudoku = NewObject.Sudoku
*MySudoku.Sudoku = FreeObject

Ob SimpleOOP damit intern nun korrekt arbeitet oder ob ich mir dadurch ein Speicherleck gezaubert habe, kann wohl nur Sirhc.ITI beantworten.
Ich hoffe ja mal, dass er hier noch einmal reinguckt und was dazu sagen kann. SimpleOOP werde ich wohl erstmal nur für kleine, eigen Programme verwenden, um mich mit der Thematik zu befassen. Für größere Projekte ist mir das nach dieser Geschichte zu heikel.

PS:
Wer den Quellcode von SimpleOOP mit PureBasic 5.00 kompilieren möchte, der muss in der Include-Datei "Lexer.pb" folgende Änderungen durchführen:

Alle Stellen mit "assert(*this\File ..."
gegen "assert(Len(*this\File) ..." tauschen.

Edit 2:
Also entweder mach ich noch immer was falsch oder aber das ganze ist noch nicht so recht ausgreift.
In der folgenden Klasse kann ich die Schleifenvariable i nicht nutzen, weil mir PureBasic sagt für FOR/NEXT sind keine strukturierten Variablen erlaubt.

Siehe unten in Methode Draw()
"For This\i = 1 To 9"

Code: Alles auswählen

Structure Settings
	iGadgetNr.i
	iGadgetInitalized.i
	x.i
	y.i
	iWidth.i
	iHeight.i
EndStructure

Class Sudoku
	
	BeginPrivate
		SudokuSettings.Settings
		iLinestep.i
		i.i
	EndPrivate
	
	Public Method Init()
		Debug "Init()"
		; Standardwerte setzen
		This\SudokuSettings\x = 1
		This\SudokuSettings\y = 1
		This\SudokuSettings\iWidth = 100
		This\SudokuSettings\iHeight = 100
	EndMethod
	
	Public Method Release()
		Debug "Release()"
		If This\SudokuSettings\iGadgetInitalized = 1
			FreeGadget(This\SudokuSettings\iGadgetNr)
			This\SudokuSettings\iGadgetInitalized = 0
		EndIf
	EndMethod
	
	Public Method SudokuGadget(iGadgetNr, x.i=1, y.i=1, iWidth.i=100, iHeight.i=100)
		Debug "SudokuGadget()"
		This\SudokuSettings\iGadgetNr = iGadgetNr
		This\SudokuSettings\x = x
		This\SudokuSettings\y = y
		This\SudokuSettings\iWidth = iWidth
		This\SudokuSettings\iHeight = iHeight
		
		CanvasGadget(iGadgetNr, x, y, iWidth, iHeight, #PB_Canvas_Border)
		This\SudokuSettings\iGadgetInitalized = 1
		This\Draw()
	EndMethod
	
	Private Method Draw()
		Debug "Draw()"
		
		If This\SudokuSettings\iGadgetInitalized = 1
			This\iLinestep = This\SudokuSettings\iWidth / 9
			If StartDrawing(CanvasOutput(This\SudokuSettings\iGadgetNr))
				For This\i = 1 To 9
					Line(This\iLinestep * This\i, 0, This\iLinestep, This\SudokuSettings\iHeight, 0)
				Next i
				; Der Kreis ist nur nen Test
				Circle(This\SudokuSettings\iWidth / 2, This\SudokuSettings\iHeight / 2, This\SudokuSettings\iHeight / 3, RGB(Random(255), Random(255), Random(255)))
				StopDrawing()
			EndIf
		EndIf
	EndMethod
EndClass

Vielleicht sollte ich mir OO-Programmierung doch nicht mittels einem AddOn für PureBasic aneigenen?
Bin erstmal ein wenig ernüchtert von der Umsetzung bzw. den Problemen die dabei auftreten.

Auch funktioniert die Autovervollständigung innerhalb der Klassen nicht, wenn es um Strukturen geht: "This\SudokuSettings\iGadgetNr". Den dritten Teil muss man hübsch selbst eintippen. :-/