Das deutsche QBasic- und FreeBASIC-Forum

[Revilo]

Hallo Leute, ich habe große Probleme mit o.g. Thema.
Ich bekomme regelmäßig die Fehlermeldung "Falscher Parameter".
'Vorbemerkung:
Sämtliche Variablen, egal ob sie als direkte Variable oder als Parameter einer SUB auftauchen, sind bei mir als DIM shared as integer definiert.
Integer reicht als Genauigkeit aus, shared für den allumfassenden Zugriff
(also nicht nur im Hauptprogramm , sondern auch in den einzelnen SUB's).

Im Hauptprogramm läuft eine 3-stufige For - Next-Schleife.
For x=1 to 10
For y=1 to 10
For r=1 to 10
'Hier wird jeweils die SUB Kreiszeigen mit den Parametern
'(kmx,kmy,kr) aufgerufen. 'Sie soll den Kreis mit
'Circle (kmx,kmy),kr, in gegebener Farbe grafisch darstellen.
'kmx und kmy sind die Koordinaten des jeweiligen Mittelpunktes
'kr steht für den Radius dieses Kreises.

'Für z.b. x=2, y=5, r=7 rufe sie also mit Kreiszeigen 2,5,7 auf.
'Damit übergebe ich also quasi die Originalwerte 2,5,7 an die
'Parameter kmx,kmy und kr der Sub Kreiszeigen.

'Wenn der Kreis gezeichnet wurde, frage ich nach, ob es korrekt
'erfolgte. Z.B. mit:
print using"Vorher: #:#:# Nachher: #:#:#" ;x;y;r;kmx;kmy;kr.

Da alle Variablen (x,y,r,kmx,kmy,kr) zuvor als shared definiert wurden,
müßte nach meinem Verständnis also:
Vorher: 2:5:7 Nacher:2:5:7 ausgegeben werden.

Tatsächlich wird aber ausgegeben: Vorher: 2:5:7 Nachher: 0:0:0
Warum? Wenn die Parameter kmx mit der Variablen x, kmy mit der
Variablen y und kr mit der Variablen r belegt wurden, dürfte es
die angezeigten "Nullen" doch gar nicht geben.

Wenn man jetzt, mit einer weiteren SUB die Fläche des soeben
bei kmx, kmy, kr gezeichneten Kreises berechnen und ausgeben
möchte, etwa mit der SUB Flaeche kmx, kmy, kr
bekommt man die Fehlermeldung "Falscher Parameter". Warum?
kmx, kmy und kr haben sich "unterwegs" doch nicht geändert.
Die Original-Werte x,y und r wurden doch nur "unter anderem Namen"
an die nachfolgenden SUB's "weitergereicht".
next r
next y
next x

Unterliege ich hier etwa einem Denkfehler?
Anders gefragt:
Sind Parameter an eine nachfolgende Sub "vererbbar" oder muß man
stets bei jeder Sub auf die ursprünglichen Originalwerte zurückgreifen?

Mit netten Grüßen Revilo

[nemored]

So ganz ohne konkretes Programm kann ich mir nicht vollständig vorstellen, wie genau du den Zugriff meinst. Was ich deiner Schilderung zu entnehmen glaube, ist folgendes: Durch die Übergabe der Parameter "überschreibst" du innerhalb der Prozedur die global definierte Variable durch eine lokale Variable. Das wird in der Referenz im Abschnitt "SHARED" beschrieben.

Ganz einfach gesagt: Es ergibt keinen Sinn, eine Variable als SHARED-Variable zu planen und gleichzeitig als Parameter zu übergeben. Der Sinn der Parameterübergabe ist ja gerade, dass die Prozedur mit einer lokalen Kopie der Variablen arbeiten kann (diese Formulierung ist nicht wirklich immer korrekt, ich lasse sie aber der Einfachheit halber mal so stehen) und eben gar keine SHARED-Variable nötig ist. Prinzipiell ist es besser, mit Parametern zu arbeiten und auf SHARED zu verzichten; wenn man sich aber für eine SHARED-Variable entscheidet, ist diese ja bereits in der Prozedur sichtbar und braucht nicht als Parameter übergeben werden (bzw. wenn man es trotzdem tut, ist diese Variable innerhalb der Prozedur nicht mehr global, selbst wenn sie genauso heißt wie eine globale Variable).

[grindstone]

Hallo Revilo,

um genaueres sagen zu können, bräuchte ich den Code deiner Sub (bitte in 'Code' Tags einschließen, das erhöht die Lesbarkeit enorm ). Ich nehme aber an, daß du in der Parameterliste einen falschen Datentyp deklariert hast.

Aber ganz allgemein: Mit dem SCOPE von Variablen ist das nicht ganz so einfach. Wenn du in der Parameterliste eine Variable deklarierst, erzeugst du damit einen Scope-Block, der innerhalb der Prozedur (SUB oder FUNCTION) gilt. Variablen gleichen Namens von außerhalb des Scope-Blocks werden dann ignoriert. Wenn du innerhalb einer Prozedur auf SHARED-Variablen zugreifen möchtest, dürfen diese nicht in der Parameterliste auftauchen.

Außerdem solltest du dir einmal BYVAL und BYREF anschauen.

[Revilo]

Hallo nemored,
vielen Dank für deine schnelle Antwort.
Ohne konkreten Syntax sind Fernurteile immer schwierig.
Aber ich wußte einfach nicht, wie ich Programmzeilen aus meinen Q-Basic
Programmen hierher übertragen kann, ohne sie alle erneut tippen zu müssen. Ich habe schon monatelang daran 'rumprobiert, stets ohne Erfolg. Aber jetzt weiß ich es. Mein Weg mag nicht der eleganteste sein,
aber er funktioniert, hoffe ich zumindest.
Hier also die gewünschten Programmzeilen:

DIM SHARED x, y, r AS INTEGER 'Originalwerte im Hauptprogramm
DIM SHARED kmx, kmy, kr AS INTEGER 'Parameter zum Zeichnen des Kreises
DIM SHARED pi AS DOUBLE 'Kreiszahl Pi
DIM SHARED f AS DOUBLE 'Masszahl der Flaeche

DECLARE SUB Kreiszeichnen (kmx, kmy, kr) 'Zeichnet den Kreis
DECLARE SUB Flaeche (kr) 'Bestimmt die Flaeche

'Hauptprogramm
'--------------
SCREEN 12

'Bestimme Pi als Vorarbeit fuer Flaechenberechnung
pi = 4 * ATN(1)


'SUB's sollen ja das Hauptprogramm ueberschaubar halten.
'Sie strukturieren es und leisten die eigentliche "Arbeit".

'Ohne Aufruf der SUB's, funktioniert es ! 'Allerdings muss dann auch das Hauptprogramm die ganze "Arbeit " leisten.
FOR x = 1 TO 10
FOR y = 1 TO 10
FOR r = 1 TO 10
CIRCLE (x * 50, y * 50), r * 10, 14 'wie in Sub
f = pi * r ^ 2 'wie im Unter-Sub

LOCATE 20, 60: PRINT USING " F = ####.##########"; f
NEXT r
NEXT y
NEXT x

'Mit Aufruf der SUB's aber nicht! Hier erscheint die Fehlermeldung
'bereits fuer die Sub Kreiszeichnen.
'Bis zur Berechnung der Flaeche als Unter-SUB von Kreiszeichnen
'komme ich gar nicht erst, und das verstehe ich nicht.
'SUB und Unter-SUB enthalten doch dieselben Befehle, wie oben in der
'funktionierenden Variante.

FOR x = 1 TO 10
FOR y = 1 TO 10
FOR r = 1 TO 10
Kreiszeichnen x, y, r 'Hier kommt bereits die Fehlermeldung

LOCATE 20, 60: PRINT USING " F = ####.##########"; f
NEXT r
NEXT y
NEXT x


SUB Flaeche (kr)
f = pi * kr ^ 2
END SUB

SUB Kreiszeichnen (kmx, kmy, kr)
CIRCLE (kmx * 50, kmy * 50), kr * 10, 14
Flaeche kr
END SUB

Leider beherrsche ich nur die DIM-Shared-Variante.
Den Unterschied zu deiner, wahrscheinlich besseren Variante, ohne dim shared habe ich leider nicht verstanden.

Vielleicht kannst du mir jetzt zu einem Aha-Effekt verhelfen.
Würde mich freuen.
Gruß Revilo

[nemored]

Für die Variante ohne DIM SHARED lässt du einfach die zweite Zeile weg. In den anderen DIM-Zeilen kannst du dann auch noch das Schlüsselwort SHARED weglassen.

Das Problem mit der Fehlermeldung ist aber ein anderes. Einige Variablen werden ohne explizite Angabe des Datentyps deklariert und sind daher ... ich weiß es wieder nicht - SINGLE oder DOUBLE. An anderer Stelle deklarierst du explizit als INTEGER, übergibst dann aber an eine Stelle, an der (implizit) ein DOUBLE-Wert verlangt wird. Warum da nicht automatisch konvertiert wird, weiß ich nicht, aber mit konsequenter Deklaration funktioniert es.
Und noch etwas - das hatten wir schon mal:

[nemored]

Hier noch die "Profi-Version" ganz ohne SHARED. PI ist eine mathematische Konstante, die entsprechend mit CONST deklariert werden kann, und um den Wert zurückzugeben, der innerhalb eines Programmes berechnet wird, nutze ich Funktionen.

[Revilo]

Hallo nemored,
dass, DIM SHARED x, y, r AS INTEGER , nicht alle Variablen sondern nur r als integer deklariert, war mir entfallen, sorry. Danke für den Hinweis. Ich hoffe, es nervt dich nicht allzu sehr, wenn ich noch einige kleine Nachfragen habe.

Kann man "implizit" mit "automatisch also computergeneriert" und "explizit" wie "ausdrücklich menschengewünscht" übersetzen ?

grindstone verwendete den Syntax
Dim Shared As Integer a, b, e, f bzw. mit meinen Variablen : Dim Shared As Integer x, y, r
Macht das fachlich hinsichtlich '"implizit" und "explizit" einen Unterschied ?

In deiner Antwort vom 13.06. verwendest du den Syntax:
DIM SHARED AS INTEGER x = 1
Was hat es mit diesem "x = 1" auf sich?
Ist das eine Art Startwert, ab dem x in einer For-Next-Schleife gezählt wird?

Zum Unterschied locale und globale Variablen:
Wenn ich das richtig verstanden habe, gelten globale Variablen sowohl im Hauptprogramm als auch in allen SUB's, richtig?
Locale Variablen gelten hingegen ausschließlich in der jeweiligen SUB, in der sie benutzt werden, also nicht sub-übergreifend, richtig?

Besagte Fehlermeldung geschieht ja nur, weil irgend etwas zwischen den Variablen und Parametern nicht richtig zusammenpassen will.

In meinem kleinen Kreisprogramm gibt es nur 7 Variablen:
x, y, r, kmx, kmy, kr und f.

Wenn ich sie wie folgt definieren würde:
dim shared x as single
dim shared y as single
dim shared r as single
dim shared kmx as single
dim shared kmy as single
dim shared kr as single
dim shared f as single
(8 Stellen Genauigkeit dürften wohl mehr als ausreichen)

würden sie alle sowohl dem Hauptprogramm also auch allen SUB's zur Verfügung stehen, (egal, ob als Zähler in einer Schleife oder als Parameter in einer SUB).

Dann sind eben alle Variablen als global definiert.
Eine Unterscheidung zwischen localen und globalen Variablen wäre dann doch gar nicht nötig.

Oder liegt eben genau hier mein Denkfehler?
Passiert bei der Übergabe einer Variablen an einen Parmeter einer SUB intern irgend etwas, was man als Laie nicht weiß?

Gruß Revilo

[grindstone]

[Berkeley]

[Berkeley]

[Revilo]

Hallo Berkeley,
vielen Dank für deine Antwort, aber offenbar setzt du bei mir mehr Sachkenntnis voraus, als ich tatsächlich habe.

Ich bin zwar 60 Jahre alt aber dennoch Anfänger und schreibe meine Programme nur in QBasic weil ich gar keine andere Programmiersprache kenne. Ich mache es einfach als Hobby, um nicht geistig "einzurosten".
Ich bin hier quasi gerade dabei, das "Zählen" zu erlernen.
Daß du mir gleich mit den Feinheiten der "Integralrechnung" kommst, ist zwar nett gemeint, aber hoffnungslos.

Auf rein mathematischem Gebiet könnte ich dir bis zur Integralrechnung folgen. Aber hier geht es eben nicht um Mathematik sondern um das Programmieren. Das ist ein völlig anderes "Schlachtfeld" auf dem ich (noch) ein ganz kleines Licht bin.

Auf gut' Deutsch: Von deinem Beitrag habe ich nicht ein Wort verstanden.
Dennoch danke ich dir für deine Bemühungen.

Gruß Revilo

[nemored]

[Berkeley]

[Revilo]

Hallo Berkeley,
vielen Dank für deine Rückantwort.
Wahrscheinlich frage ich nicht treffend genug oder einfach zu umständlich.
Mein kleines Kreisprogramm sollte eigentlich als Beispiel zur besseren Veranschaulichung dienen, war aber wohl doch keine so glückliche Wahl.

Deshalb versuche ich es mal mit anderen Worten.
Ich habe ein Hauptprogramm. Das ist also praktisch das Projekt, an dem ich gerade knobele.
Um hier nicht den Überblick zu verlieren, lasse ich verschiedene Teilaufgaben durch SUB's bearbeiten.

Ich habe eine ganze Reihe verschiedener SUB's -- Für jede Teilaufgabe eine.
Diese SUB's müssen alle sowohl mit dem Hauptprogramm
als auch untereinander kommunizieren können.

Im Hauptporgramm werden irgend welche Werte ermittlt.
Diese liegen in bestimmten Variablen vor z.B. a, b und c

a ,b und c sind die Ausgangsdaten zur Bearbeitung einer Teilaufgabe, müssen also der jeweiligen SUB irgendwie "übergeben, mitgeteilt" werden, damit sie die Teilaufgabe überhaupt bearbeiten kann.

Zu diesem Zweck habe ich jede SUB mit ihren ganz individuellen Parametern declariert. Es gibt also keine 2 SUB's mit gleichen Parametern, bzw. Parametern gleichen Namens.

Die 1. SUB habe z.B. die Parameter p1a, p1b, p1c
Ich rufe sie mit den Werten a,b,c aus dem Hauptprogramm auf.
Die Werte a,b, c liegen jetzt quasi als Kopie in den Parametern p1a,p1b und p1c vor, mit denen diese SUB arbeitet. Sie liefert als Ergebnis den Wert d.

d soll der Ausgangswert für die 2. SUB sein, die wiederum eine, diesmal andere, Teilaufgabe zu bearbeiten hat. Sie habe dazu den Parameter p2d
d liegt nach Aufruf der 2. SUB also als Kopie im Parameter p2d vor.
Sie liefert als Ergebnis die Werte e und f, die an eine 3. SUB
mit den Parametern p3e, p3f übergeben werden sollen.

Diese 3. SUB liefert den Wert g.
Dieser soll als Endergebnis im Hauptprogramm ausgegeben werden.
Z.B. mit dem Befehl:
print using "Ergebnis: a: ## b:## c:## ergeben: g:## ";a;b;c;g

Ergänzung:
Wenn ich z.B. i als Zähler in einer For-Next-Schleife benutze, dann grundsätzlich nur in dieser konkreten Schleife.

Andere Schleifen haben entsprechend andere Zähler z.B. u statt i.
Ich weiß, daß jede Variable Speicherplatz benötigt. Aber wie soll ich mir anders behelfen, um Verwechslungen zu vermeiden? Das ist nun mal das Schicksal eines Laien. Unkenntnis kostet Speicherplatz.


Zusammenfassung dessen, was ich bisher davon verstanden habe:
1) Ein Parameter einer SUB muß vom gleichen Datentyp sein, wie der Wert, der an ihn übergeben wird, also z.B. single.

2) a,b und c sind offenbar globale Variablen, weil sie im Hauptprogrammm verwendet werden.

3) p1a, p1b, p1c, d, p2d, e, f, p3e, p3f und g sind offenbar lokale Variablen, weil sie nur lokal in einer der 3 SUB 's verwendet werden.

4) d, e, f und g können nach meinem Verständnis aber nicht lokal sein,
denn:
4.1) d, e und f müssen schließlich an andere SUB's übergebbar sein,
damit diese ihren Job, ihre Teilaufgabe machen können.

4.2) g muß schließlich im Hauptprogramm ausgebbar sein,
damit im Hauptprogramm ein Ergebnis erscheinen kann.

Aus diesem Widerspruch ergeben sich wahrscheinlich auch meine Schwierigkeiten mit diesem Thema.

Daher meine Frage:
Wie müßte ich die Befehle DIM.....; bzw. DIM SHARED.....
fachlich korrekt auf diese einzelnen Variablen a, b, c, d, e, f, g, p1a, p1b, p1c, p2d, p3e und p3f anwenden ?
Das habe ich wahrscheinlich schon 100 mal falsch gemacht.
Gibt es dafür eine Art "Faustregel"?

(PS: hinsichtlich der Genauigkeit würde "integer" völlig ausreichen, weil ich nur mit natürlichen Werten zu tun habe.)

Das mit den Kreisen war nur ein schlecht gewähltes Beispiel.

Gruß Revilo

[dreael]

Artikel aus meiner Sammlung

https://www.dreael.ch/Deutsch/BASIC-Knowhow-Ecke/SUB-Unterprogramme.html

Hinweis: Ist noch dort voll QBasic-bezogen, d.h. FreeBasic bietet diverse Konzepte aus modernen Sprachen zusätzlich, die es in QB unter DOS alle noch nicht gab.
_________________
Teste die PC-Sicherheit mit www.sec-check.net

[nemored]

[Revilo]

Hallo nemored,
deine letzten Ausführungen waren sehr aufschlussreich. Vielen Dank dafür.
Sie zeigen mir, daß ich bei der Deklarierung meiner Variablen eine ganze Menge fachliche "Böcke" geschossen habe.

Du legst mir die Nutzung von Functionen nahe.
Diesen Begriff verbinde ich eher mit der Mathematik, also mit dem berechnen einer Ergebniszahl aus vorgegebenen Zahlen.
Ich sah das immer als Möglichkeit, sich individuelle mathematische Formeln
"zusammenstricken" zu können.
Aber offenbar können Funktionen auch Befehle enthalten, die gar nichts mit mathemat. Symbolen wie sin, cos, log usw. zu tun haben.
Das legt die Vermutung nahe, daß eine Funktion genauso z.B. 100 Programmzeilen enthalten kann, wie eine SUB.
Was wäre denn dann der Unterschied zwischen SUB und Funktion?
Warum sind Funktionen empfehlenswerter, als SUB's?

Besagte Fehlermeldung "Falscher Parameter" hat also eher mit einer falschen Deklarierung meiner Variablen (lokal statt global oder umgekehrt) zu tun. Richtig?

Ich hatte immer vermutet, es wäre ein falscher Wert übergeben worden,
der noch irgend wo im Speicher "schlummerte" und von dort "ausgegraben" wurde.
Z.B. soll eine 177 an einen Parameter übergeben werden, der nur Werte
1 und 25 akzeptiert. Klar, daß mein "Robby" da meckert.

Um solche "versteckten" Fehler möglichst zu umgehen, gestalte ich z.B.
For - Next - Schleifen immer wie folgt:
i=0
for i=1 to 10
.
. Befehle, SUB's in dieser Schleife
.
next
if i>10 then i=10
So vermeide ich hoffentlich, daß i zufällich durch irgend welche "Schaltfehler" des Computers auf eine unerwartete, unmögliche
11 springen kann. Ist diese Vorsichtsmaßnahme sinnvoll oder unnötig?

Was bedeutet übrigens #lang "qb"? Ist mir in QBasic noch nie begegnet.

Nur um mich zur vergewissern, ob ich es richtig verstanden habe:
Dein:
DECLARE SUB p1(p1a AS INTEGER, p1b AS INTEGER, p1c AS INTEGER)
DECLARE SUB p2(p2d AS INTEGER)
DECLARE SUB p3(p3e AS INTEGER, p3f AS INTEGER)

müßte, wenn die SUB's Fritz, Franz und Sophie hießen, also wie folgt aussehen:
DECLARE SUB Fritz(Fritza AS INTEGER, Fritzb AS INTEGER, Fritzc AS INTEGER)
DECLARE SUB Franz(Franzd AS INTEGER)
DECLARE SUB Sophie(Sophiee AS INTEGER, Sophief AS INTEGER)
Richtig?

a = 1, b = 2, c = 3 sind die Werte aus dem Hauptprogramm
Mit diesen Werten würde ich also die SUB Fritz a,b,c aufrufen.
Wie wäre dieser Aufruf sytaktisch korrekt?
1) Fritz a, b, c oder
2) Fritz(a, b, c) oder
3) Fritz a as integer, b as integer, c as integer oder
4) Fritz (a as integer, b as integer, c as integer)
Analog würde es wohl auch für Franz und Sophie gelten.

Ich habe es nicht so mit Worten. Für mich ist mathematisches eher nachvollziehbar. Können wir daher bitte den ganzen Ablauf mal an den konkreten Zahlen a,b,c mit den jeweiligen Zwischen-Ergebnissen durchspielen? Das mag dir auf den ersten Blick nervig erscheinen,
ist letztlich aber zeitsparend bei der Beantwortung dann noch übrig gebliebener Nachfragen meinerseits. Einverstanden?

Oft ist eine bildliche Anschauung hilfreicher, als 1000 Worte es je sein können.
Deshalb nenne ich das Hauptprogramm einfach mal "Chef".
Die SUB's sind quasi die "Angestellten" Fritz, Franz und Spohie.

Der "Chef" gibt die Werte a=1, b=2, c=3 vor und sagt zu den Angestellten: Macht was draus!

Fritz bekommt diese Werte zuerst, wird also vom "Chef" zuerst
angesprochen / aufgerufen, mit der Auflage, sich darum zu kümmern.

Diese Werte liegen Fritz jetzt also als Kopie in den Parametern Fritza, Fritzb, Fritzc vor, richtig?
Fritz erschafft sich eine eigene Variable d mit DIM d as integer


Fritz bestimmt jetzt dieses d aus den ihm übergebenen Parametern:
d = Fritza(mit Wert von a) + Fritzb(mit Wert von b) + Fritzc (mit Wert von c) jetzt müßte also d = 1 + 2 + 3 = 6 gelten, richtig?

Fritz übergibt dieses d = 6 an Franz, der damit weiterrechnen soll.
Er spricht also Franz d an.
d liegt Franz jetzt also als Kopie im Parameter Franzd vor, richtig?

Franz erschafft sich ebenso seine eigenen Variablen e und f,
so wie Fritz es zuvor mit d tat.
DIM e AS INTEGER, f AS INTEGER ' lokal nur in p2

Franz berechnet e und f:
e = 2 * Franz d = 2*6 = 12
f = Franz d - 1 = 6 -1 = 5

Franz gibt e =12 und f =5 an Sophie weiter.
Der entsprechende Aufruf lautet also Sophie e, f
e und f liegen jetzt also als Kopie in Sophie's Parametern mit
Sophie e = 12 und Sophie f = 5 vor.

Sophie erschafft, wie ihre "Kollegen" zuvor, wiederum ihre eigene,
private Variable g mit DIM g as integer

Sophie bestimmt das Endergebnis g:
g = Sophie e - Sophie f in Zahlen also g = 12 - 5 = 7

Jetzt ist es Sophie's Aufgabe, dem "Chef" das Ergebnis g dieser Teamarbeit so zu präsentieren, daß er es bei seiner Steuererklärung verwenden/angeben kann.

Dabei gibt es aber das Problem, daß g per Definition immer noch
Sophie's "Privatsache" ist. So kann der "Chef" nie etwas davon erfahren.
Sophie muß g also quasi "öffentlich " also auch für den "Chef" zugänglich machen, damit ihn ihr Ergebnis g überhaupt erreicht.

Es macht keinen Sinn, etwas für sich behalten zu wollen, wenn man es letztlich doch preisgeben muß, weil der "Chef" nun mal ein Ergebnis erwartet.
Da Sophie das Ergebnis g letztlich sowieso an den "Chef" übergeben muß,
ist ihr privater (locater) Anspruch auf g von Anfang an hinfällig.

Bedeutet:
Statt: DIM g as integer könnte Sophie auch gleich
DIM shared g as integer festlegen.

Soweit erst mal zu meinem Verständnis der Sache.
Ist es so ok.? Oder habe ich dabei trotzdem noch etwas übersehen?

Mal ganz nebenbei:
Deine Geduld mit mir ist bewundernswert.
Du schreibst mir z.B. daß DIM x,y,z as integer nicht korrekt ist, es statt dessen DIM x as integer, y as integer , z as integer heißen müßte. Und ich Dussel habe nichts anderes zu tun, als es im nächsten Moment schon wieder zu vergessen.
Deine Ausführungen und Beiträge sind für mich sehr wertvoll. Sie haben es nicht verdient, derart ignorant behandelt (vergessen) zu werdern, wie ich es tat. Sorry. Ich kann dafür nur Abbitte leisten.
Ich empfinde es als sehr angenehm, von dir zu lernen.

Gruß Revilo

[nemored]

[Revilo]

Hallo nemored,
wie immer vielen Dank.
Bitte laß mich deine letzte Antwort mal auf den Kern zusammenfassen,
soweit ich ihn jetzt verstanden habe :

1) Schleifen:
i=0 ist zu Beginn einer Schleife unnötig
if i>10 then i=10 nach einer Schleife aber sinnvoll, um zu vermeiden, daß mit einer ungewollten 11 weiterechnet wird. Der Rechner kann nun mal kein Feld(11) bearbeiten, wenn es nur
von 1 bis 10 dimensioniert ist. Richtig?

2) Fehlermeldung "Falscher Parameter"
Originalwert und Parameter einer SUB, an den der Originalwert
übergeben wird, müssen denselben Datentyp haben.
Eine SUB die in ihrem Parameter eine kg - Angabe erwartet, kann
natürlich mit einer °C - Angabe nichts anfangen. 100 °C und 100 kg
haben zwar denselben Zahlenwert (hier eben 100), sind aber trotzdem
zwei ganz verschiedene Dinge.
So ist also eine (integer) - 7 etwas anderes, als eine (single) -7.
Integer = ganze Zahl ohne Kommastelle
Single, Double, Long = reelle Zahl mit Kommastelle, je nach
gewünschter Genauigkeit/Stellenanzahl.
Richtig?

3) DIM shared... ist grundsätzlich "Chef-Sache". Richtig?

4) BYVAL (by value) und BYREF (by reference):
Ist das auch wieder ein FreeBasic-Syntax? In QBasic kenne ich es nicht.
Bitte laß mich mal vermuten:
Es ist, bildlich gesprochen, wie beim Duden. Man sucht die Schreibweise eines einzigen Wortes, bzw. dien Inhalt eioner bestimmten Variable a.

Möglichkeit 1) also BYVAL (by value):
Ich kaufe mir einen kompletten Duden (also quasi eine Kopie des "Original-Dudens" bzw. der Variablen a), blätterte darin, bis ich weiß, wie besagtes Wort zu schreiben ist.
Das kostet aber Geld, respektive Speicherplatz und Zeit.

Möglichkeit 2) also BYREF (by reference):
Hier gibt es offenbar einen Tipp, einen "Zeiger":
Nach dem Motto:
In der örtlichen Bibliothek steht ein Duden.
Das gesuchte Wort steht z.B. auf Seite 162.
Dann lese ich eben dort nach und weiß auch, wie das jeweilige Wort zu schreiben ist, bzw. welchen Inhalt die Variable a hat.
Ich brauche also keine "Duden-Kopie" zu kaufen.
Daß diese Methode QBasic-Standard ist, ist daher nur zu begrüßen.

5) Aufruf einer SUB:
Offenbar ist also Syntax 2)
- Fritz(a, b, c) - korrekt
Mit Klammern kann ich beim Aufruf also sowohl bei SUB' s als auch bei Funktionen nichts verkehrt machen. Richtig?

Bei deinem Zitat:
Das "AS INTEGER" steht nur in der DECLARE-Zeile und im Kopf des Unterprogramms, nicht aber beim Aufruf.
bin ich mir vom Verständnis her noch nicht ganz sicher.

Könntest du mir das am Beispiel der SUB Fritz nochmal kurz
darlegen?
Vielen Dank, Revilo

[nemored]

Zu 1)
Es hängt davon ab, was du mit i nach der Schleife noch anfangen willst. Da es sich um die Laufvariable der FOR-Schleife handelt, will man mit ihr außerhalb der Schleife meist nichts mehr anstellen. Dann ist ein Heruntersetzen auf i=10 nicht mehr nötig. Umgekehrt kann man die Eigenart nutzen, um zu prüfen, ob die Schleife komplett durchlaufen wurde oder zuvor abgebrochen wurde.