386 γραμμές
23 KiB
Markdown
386 γραμμές
23 KiB
Markdown
+++
|
||
title = 'Xbasic'
|
||
date = '2001-09-01T00:00:00Z'
|
||
description = ''
|
||
author = 'Κώστας Τσακάλογλου(mailto:tsakf@hellug.gr)'
|
||
issue = ['Magaz 30']
|
||
issue_weight = 2
|
||
+++
|
||
|
||
----------------------------------------------------------------------------------------------------------------------------------------------------------------
|
||
|
||
*Εντολές ανακύκλωσης*
|
||
|
||
----------------------------------------------------------------------------------------------------------------------------------------------------------------
|
||
|
||
**1. Εντολές ανακύκλωσης**
|
||
---------------------------------------------------
|
||
|
||
**2. Η εντολή FOR \... NEXT**
|
||
------------------------------------------------------
|
||
|
||
- [2.1 Παράδειγμα](#ss2.1)
|
||
|
||
**3. FOR \... NEXT μέσα σε άλλο FOR..NEXT**
|
||
--------------------------------------------------------------------
|
||
|
||
- [3.1 Παράδειγμα πολλαπλών FOR\...NEXT.](#ss3.1)
|
||
|
||
**4. Η εντολή EXIT FOR**
|
||
-------------------------------------------------
|
||
|
||
|
||
### [1. Εντολές ανακύκλωσης]{#s1}
|
||
|
||
Ο τρόπος που εκτελείται ένα πρόγραμμα XBASIC είναι ο συνηθισμένος, όπου οι εντολές εκτελούνται από επάνω προς τα κάτω.\
|
||
Η εκτέλεση των εντολών ξεκινά από την συνάρτηση `ENTRY()` και εκτελούνται μία-μία οι εντολές, από επάνω προς τα κάτω μέχρι να φτάσουμε στην εντολή
|
||
`END FUNCTION` όπου εκεί τελειώνει η εκτέλεση του προγράμματος.
|
||
|
||
Στην πραγματικότητα όμως, σπάνια βρίσκουμε προγράμματα που να εκτελούνται έτσι απλά όπως περιγράψαμε πριν. Σε πάρα πολλές περιπτώσεις χρειαζόμαστε
|
||
επαναλαμβανόμενες διαδικασίες και πολύπλοκους ελέγχους για να κατασκευάσουμε ένα πρόγραμμα που θα εκτελεί κάποια ζητούμενη, σύνθετη εργασία.\
|
||
Η XBASIC μας δίνει κάποιες εντολές για να μπορούμε να έχουμε επαναλαμβανόμενες διαδικασίες μέσα στο πρόγραμμά μας. Αυτές είναι οι εντολές `FOR ... NEXT` και η
|
||
εντολές `DO ... LOOP`
|
||
|
||
Παρακάτω θα αναλύσουμε και τις δύο για να δούμε την χρήση τους και πως μπορούμε να τις εφαρμόσουμε.
|
||
|
||
|
||
### [2. Η εντολή FOR \... NEXT]{#s2}
|
||
|
||
Αυτή την εντολή την χρησιμοποιούμε για να έχουμε την εκτέλεση μιας ή μιας ομάδας εντολών για προκαθορισμένο αριθμό επαναλήψεων. Η μορφή της είναι:
|
||
|
||
----------------------------------------------------------------------------------------------------------------------------------------------------------------
|
||
|
||
FOR [μεταβλητή] = [αρχική τιμή] ΤΟ [τελική τιμή] STEP [βήμα]
|
||
..
|
||
[εντολές που θα εκτελεστούν επαναλαμβανόμενα]
|
||
..
|
||
NEXT [μεταβλητή]
|
||
|
||
----------------------------------------------------------------------------------------------------------------------------------------------------------------
|
||
|
||
### [2.1 Παράδειγμα]{#ss2.1}
|
||
|
||
Θα δούμε ένα παράδειγμα χρήσης της FOR \... NEXT
|
||
|
||
----------------------------------------------------------------------------------------------------------------------------------------------------------------
|
||
|
||
1. '
|
||
2. '
|
||
3. ' ####################
|
||
4. ' ##### PROLOG #####
|
||
5. ' ####################
|
||
6. '
|
||
7. PROGRAM "progname" ' 1-8 char program/file name without .x or any .extent
|
||
8. VERSION "0.0000" ' version number - increment before saving altered program
|
||
9. '
|
||
10. ' You can stop the PDE from inserting the following PROLOG comment lines
|
||
11. ' by removing them from the prolog.xxx file in your \xb\xxx directory.
|
||
12. '
|
||
13. ' Programs contain: 1: PROLOG - no executable code - see below
|
||
14. ' 2: Entry function - start execution at 1st declared func
|
||
15. ' * = optional 3: Other functions - everything else - all other functions
|
||
16. '
|
||
17. ' The PROLOG contains (in this order):
|
||
18. ' * 1. Program name statement PROGRAM "progname"
|
||
19. ' * 2. Version number statement VERSION "0.0000"
|
||
20. ' * 3. Import library statements IMPORT "libName"
|
||
21. ' * 4. Composite type definitions TYPE <typename> ... END TYPE
|
||
22. ' 5. Internal function declarations DECLARE/INTERNAL FUNCTION Func (args)
|
||
23. ' * 6. External function declarations EXTERNAL FUNCTION FuncName (args)
|
||
24. ' * 7. Shared constant definitions $$ConstantName = literal or constant
|
||
25. ' * 8. Shared variable declarations SHARED variable
|
||
26. '
|
||
27. ' ****** Comment libraries in/out as needed *****
|
||
28. '
|
||
29. ' IMPORT "xma" ' Math library : SIN/ASIN/SINH/ASINH/LOG/EXP/SQRT...
|
||
30. ' IMPORT "xcm" ' Complex library : complex number library (trig, etc)
|
||
31. ' IMPORT "xst" ' Standard library : required by most programs
|
||
32. ' IMPORT "xgr" ' GraphicsDesigner : required by GuiDesigner programs
|
||
33. ' IMPORT "xui" ' GuiDesigner : required by GuiDesigner programs
|
||
34. '
|
||
35. DECLARE FUNCTION Entry ()
|
||
36. '
|
||
37. '
|
||
38. ' ######################
|
||
39. ' ##### Entry () #####
|
||
40. ' ######################
|
||
41. '
|
||
42. ' Programs contain:
|
||
43. ' 1. A PROLOG with type/function/constant declarations.
|
||
44. ' 2. This Entry() function where execution begins.
|
||
45. ' 3. Zero or more additional functions.
|
||
46. '
|
||
47. FUNCTION Entry ()
|
||
48. SSHORT i
|
||
49. FOR i=1 TO 20
|
||
50. PRINT i
|
||
51. NEXT i
|
||
52. END FUNCTION
|
||
53. END PROGRAM
|
||
|
||
----------------------------------------------------------------------------------------------------------------------------------------------------------------
|
||
|
||
#### Γραμμές 1..35 Ορισμοί
|
||
|
||
Οι γνωστές πια σε όλους γραμμές ορισμού του προγράμματος των βιλιοθηκών και των συναρτήσεων του προράμματος.
|
||
|
||
#### Γραμμές 47..52 Η συνάρτηση ENTRY()
|
||
|
||
Εδώ έχουμε την συνάρτηση `ENTRY()` όπου και θα αναλύσουμε για να δούμε τον τρόπο λειτουργίας της `FOR ... NEXT`
|
||
|
||
Η εκτέλεση του προγράμματος ξεκινά από την γραμμή 49 όπου υπάρχει και η εντολή `FOR`. Έχοντας ορίσει ακριβώς παραπάνω το είδος της μεταβλητής `i` μπορούμε να
|
||
την χρησιμοποιήσουμε. Αναφέρω ξανά τα παραπάνω προασμοσμένα στο παράδειγμά μας.
|
||
|
||
----------------------------------------------------------------------------------------------------------------------------------------------------------------
|
||
|
||
FOR [μεταβλητή] = [αρχική τιμή] ΤΟ [τελική τιμή] STEP [βήμα]
|
||
..
|
||
[εντολές που θα εκτελεστούν επαναλαμβανόμενα]
|
||
..
|
||
NEXT [μεταβλητή]
|
||
|
||
----------------------------------------------------------------------------------------------------------------------------------------------------------------
|
||
|
||
Όπου έχουμε :\
|
||
|
||
----------------------------------------------------------------------------------------------------------------------------------------------------------------
|
||
|
||
[μεταβλητή] = i
|
||
[αρχική τιμή] = 1
|
||
[τελική τιμή] =20
|
||
|
||
----------------------------------------------------------------------------------------------------------------------------------------------------------------
|
||
|
||
Το `STEP` έχει παραλειφθεί γιατί θεωρείται ότι η απουσία της STEP δηλώνει αύξηση κατά 1
|
||
|
||
----------------------------------------------------------------------------------------------------------------------------------------------------------------
|
||
|
||
[εντολές που θα εκτελεστούν επαναλαμβανόμενα]= PRINT i
|
||
|
||
----------------------------------------------------------------------------------------------------------------------------------------------------------------
|
||
|
||
Θα ξεκινήσουμε παρακολουθώντας βήμα-βήμα την εκτέλεση του προγράμματος για να δούμε τι γίνεται.
|
||
|
||
Η εκτέλεση ξεκινά από την γραμμή 49 όπου η μεταβλητή `i` παίρνει την τιμή `1` και γίνεται έλεγχος άν αυτή η τιμή είναι μεγαλύτερη από την τελική τιμή της. Εφ\'
|
||
όσον η τιμή της μεταβλητής είναι μικρότερη από την τελική τιμή, τότε συνεχίζεται η εκτέλεση της γραμμής 50.\
|
||
Στην γραμμή 50 γίνεται εμφάνιση της τιμής της `i` στο παράθυρο κοσόλας της **XBASIC**. Στην γραμμή 51 γίνεται αύξηση της τιμής της `i` κατά το βήμα που έχει
|
||
ορισθεί (1) και εκτελείται ξανά η εντολή 49. Τώρα πάλι γίνεται έλεγχος άν η τιμή της `i` που είναι πια 2 είναι μικρότερη από την μέγιστη (20). Είναι, οπότε
|
||
έχουμε πάλι την εκτέλεση της γραμμής 50 και εμφανίζεται πάλι στο παράθυρο κονσόλας η τιμή της i. Συνεχίζουμε ξανά με την ΝΕΧΤ όπου η τιμή της i γίνεται 3. Πάλι
|
||
εκτέλεση της 49, έλεγχος και επανάληψη όλων των παραπάνω μέχρι η τιμή της `i` να γίνει 20.\
|
||
Μόλις η τιμή γίνει 20 τότε ο έλεγχος στην γραμμή 49 δίνει ότι έχουμε φτάσει στην τελική τιμή της μεταβλητής. Τότε παταλείπονται όλες οι εντολές μέχρι την εντολή
|
||
`NEXT` και η εκτέλεση του προγράμματος συνεχίζεται μετά από αυτήν. Στο παράδειγμά μας, δεν έχουμε τίποτε άλλο έτσι η εκτέλεση του προγράμματος τελειώνει.
|
||
|
||
Με την βοήθεια ορισμού του βήματος μπορούμε να έχουμε διάφορες περιπτώσεις που η μεταβλητή `i` δεν αυξάνει κατά 1 αλλά με διαφορετικό βήμα. Π.χ.
|
||
|
||
----------------------------------------------------------------------------------------------------------------------------------------------------------------
|
||
|
||
FOR i= 1 to 16 STEP 3
|
||
|
||
----------------------------------------------------------------------------------------------------------------------------------------------------------------
|
||
|
||
Σε αυτή την περίπτωση το βήμα για κάθε ανακύκλωση αυξάνει κατά 3 και οι διαδοχικές τιμές που μπορεί λαμβάνει η `i` είναι 1,4,7,10,13,16. Επίσης μπορούμε να
|
||
έχουμε αντί για αύξηση της τιμής της `i` μείωση με την παρακάτω σύνταξη.
|
||
|
||
----------------------------------------------------------------------------------------------------------------------------------------------------------------
|
||
|
||
FOR i = 16 to 1 STEP -1
|
||
|
||
----------------------------------------------------------------------------------------------------------------------------------------------------------------
|
||
|
||
Σε αυτή την περίπτωση η διαδοχικές τιμές της `i` θα είναι 16,15,14,\...3,2,1.
|
||
|
||
Συνοψίζοντας βλέπουμε ότι με την εντολή `FOR ... NEXT` μπορούμε να έχουμε επαναλαμβανόμενη εκτέλεση κώδικα όσες φορές επιθυμούμε
|
||
και με οποιοδήποτε βήμα.
|
||
|
||
|
||
### [3. FOR \... NEXT μέσα σε άλλο FOR..NEXT]{#s3}
|
||
|
||
Υπάρχει η δυνατότητα να έχουμε πολλαπλά `FOR ... ΝΕΧΤ` το ένα μέσα στο άλλο.\
|
||
Απαραίτητη προυπόθεση είναι αυτά να έχουν διαφορετικές μεταβλητές μέτρησης. Αν χρησιμοποιηθεί η ίδια μεταβλητή μέτρησης τότε το ένα `NEXT` θα επηρεάζει το άλλο
|
||
με απρόβλεπτα αποτελέσματα στην εκτέλεση του κώδικα.\
|
||
Έτσι είναι λάθος να γράψουμε:
|
||
|
||
----------------------------------------------------------------------------------------------------------------------------------------------------------------
|
||
|
||
FOR i=1 TO 10
|
||
FOR i=2 TO 7
|
||
.
|
||
.
|
||
.
|
||
NEXT i
|
||
NEXT i
|
||
|
||
----------------------------------------------------------------------------------------------------------------------------------------------------------------
|
||
|
||
Θα παρατηρήσουμε ότι στο παραπάνω παράδειγμα έχει τοποθετηθεί το δεύτερο `FOR` δεξιότερα από το πρώτο.\
|
||
Αυτό μας βοηθάει πάρα πολύ κατά την ανάγνωση το προγράμματός μας να βλέπουμε που τελειώνει η κάθε ανακύκλωση χωριστά. Ένα άλλο λάθος που γίνεται μερικές φορές
|
||
είναι η λάθος αντιστοίχηση των `FOR` με τα αντίστοιχα `NEXT`. Κάποιος που θα γράψει:
|
||
|
||
----------------------------------------------------------------------------------------------------------------------------------------------------------------
|
||
|
||
FOR i= 1 TO 10
|
||
FOR k= 1 TO 5
|
||
.
|
||
.
|
||
.
|
||
NEXT i
|
||
NEXT k
|
||
|
||
----------------------------------------------------------------------------------------------------------------------------------------------------------------
|
||
|
||
θα λάβει μήνυμα λάθους `NESTING ERROR`. Αυτό συμβαίνει γιατί κατά την ανάγνωση του κώδικα ο υπολογιστής έχει καταχωρίσει ότι η τελευταία μεταβλητή μέτρησης
|
||
είναι η `k` και όχι η `i`.
|
||
|
||
Ένα άλλο λάθος που μπορεί να γίνει είναι ο λάθος υπολογισμός της τελικής τιμής άν έχουμε βήμα διαφορετικό από το 1 όπως στο προηγούμενο παράδειγμα και έτσι ενώ
|
||
έχουμε γράψει
|
||
|
||
----------------------------------------------------------------------------------------------------------------------------------------------------------------
|
||
|
||
FOR i = 1 TO 10 STEP 3
|
||
.
|
||
.
|
||
|
||
ΝΕΧΤ i
|
||
|
||
----------------------------------------------------------------------------------------------------------------------------------------------------------------
|
||
|
||
Ετσι η τελική τιμή της μεταβλητής i είναι διαφορετική από αυτήν που περιμένουμε να έχει η i κατά την τελευταία ανακύκλωση.
|
||
|
||
### [3.1 Παράδειγμα πολλαπλών FOR\...NEXT.]{#ss3.1}
|
||
|
||
Θα γράψουμε ένα μικρό πρόγραμμα που θα δημιουργεί μια επιφάνεια από Χ ανάλογα με τις διαστάσεις που εισάγουμε.
|
||
|
||
----------------------------------------------------------------------------------------------------------------------------------------------------------------
|
||
|
||
1. '
|
||
2. '
|
||
3. ' ####################
|
||
4. ' ##### PROLOG #####
|
||
5. ' ####################
|
||
6. '
|
||
7. PROGRAM "progname" ' 1-8 char program/file name without .x or any .extent
|
||
8. VERSION "0.0000" ' version number - increment before saving altered program
|
||
9. '
|
||
10. ' You can stop the PDE from inserting the following PROLOG comment lines
|
||
11. ' by removing them from the prolog.xxx file in your \xb\xxx directory.
|
||
12. '
|
||
13. ' Programs contain: 1: PROLOG - no executable code - see below
|
||
14. ' 2: Entry function - start execution at 1st declared func
|
||
15. ' * = optional 3: Other functions - everything else - all other functions
|
||
16. '
|
||
17. ' The PROLOG contains (in this order):
|
||
18. ' * 1. Program name statement PROGRAM "progname"
|
||
19. ' * 2. Version number statement VERSION "0.0000"
|
||
20. ' * 3. Import library statements IMPORT "libName"
|
||
21. ' * 4. Composite type definitions TYPE <typename> ... END TYPE
|
||
22. ' 5. Internal function declarations DECLARE/INTERNAL FUNCTION Func (args)
|
||
23. ' * 6. External function declarations EXTERNAL FUNCTION FuncName (args)
|
||
24. ' * 7. Shared constant definitions $$ConstantName = literal or constant
|
||
25. ' * 8. Shared variable declarations SHARED variable
|
||
26. '
|
||
27. ' ****** Comment libraries in/out as needed *****
|
||
28. '
|
||
29. ' IMPORT "xma" ' Math library : SIN/ASIN/SINH/ASINH/LOG/EXP/SQRT...
|
||
30. ' IMPORT "xcm" ' Complex library : complex number library (trig, etc)
|
||
31. ' IMPORT "xst" ' Standard library : required by most programs
|
||
32. ' IMPORT "xgr" ' GraphicsDesigner : required by GuiDesigner programs
|
||
33. ' IMPORT "xui" ' GuiDesigner : required by GuiDesigner programs
|
||
34. '
|
||
35. DECLARE FUNCTION Entry ()
|
||
36. '
|
||
37. '
|
||
38. ' ######################
|
||
39. ' ##### Entry () #####
|
||
40. ' ######################
|
||
41. '
|
||
42. ' Programs contain:
|
||
43. ' 1. A PROLOG with type/function/constant declarations.
|
||
44. ' 2. This Entry() function where execution begins.
|
||
45. ' 3. Zero or more additional functions.
|
||
46. '
|
||
47. FUNCTION Entry ()
|
||
48. USHORT i1,i2
|
||
49. USHORT side1,side2
|
||
50. STRING sside1,sside2
|
||
51. sside1=INLINE$("side 1 ")
|
||
52. sside2=INLINE$("side 2 ")
|
||
53. side1=USHORT(sside1)
|
||
54. side2=USHORT(sside2)
|
||
55. FOR i1 = 1 TO side1
|
||
56. FOR i2 = 1 TO side2
|
||
57. PRINT "X";
|
||
58. NEXT i2
|
||
59. PRINT ""
|
||
60. NEXT i1
|
||
61.
|
||
62.
|
||
63.
|
||
64. END FUNCTION
|
||
65. END PROGRAM
|
||
|
||
----------------------------------------------------------------------------------------------------------------------------------------------------------------
|
||
|
||
#### Γραμμές 1..46
|
||
|
||
Οι ορισμοί του προγράμματος και των βιβλιοθηκών που χρειάζονται
|
||
|
||
#### Γραμμές 47..64
|
||
|
||
Η συνάρτηση `ENTRY()` που περιέχει και τον εκτελέσιμο κώδικα του προγράμματός μας.
|
||
|
||
Θα αναλύσουμε την `ENTRY()` για να δούμε την διαδοχική χρήση των εντολών `FOR ... NEXT`
|
||
|
||
#### Γραμμή 48
|
||
|
||
Σε αυτές τις γραμμές ορίζουμε τις μεταβλητές που θα χρησιμοποιήσουμε παρακάτω στις εντολές `FOR ... NEXT`
|
||
|
||
#### Γραμμή 49
|
||
|
||
Ορίζονται οι μεταβλητές που θα περιεχουν τις διαστάσεις της τετράγωνης επιφάνειας.
|
||
|
||
#### Γραμμή 50
|
||
|
||
Εδώ ορίζουμε βοηθητικές μεταβλητές τύπου STRING για να πάρουμε την πληκτρολόγηση του χρήστη.
|
||
|
||
#### Γραμμές 51 και 52
|
||
|
||
Με την γνωστή πια εντολή `INLINE$` δίνουμε μήνυμα στον χρήστη να εισάγει διαδοχική τις επιθυμιτές διαστάσεις του τετραγώνου.
|
||
|
||
#### Γραμμές 53 και 54
|
||
|
||
Μετατροπή των μεταβλητών STRING σε αριθμητικές για να τις χρησιμοποιήσουμε παρακάτω και τις εντολές ανακύκλωσης `FOR ... NEXT`
|
||
|
||
#### Γραμμή 55
|
||
|
||
Αρχή της πρώτης ανακύκλωσης. Εδώ ο μετρητής `i1` θα λάβει τιμές από 1 έως την τιμή της μεταβλητής `side1` που είναι η κάθετη διάσταση του τετραγώνου
|
||
|
||
#### Γραμμή 56
|
||
|
||
Αρχή της δεύτερης ανακύκλωσης. Εδώ ο `i2` θα λάβει τιμές από 1 έως την τιμή της `side2` που είναι η οριζόντια διάσταση του τετραγώνου.
|
||
|
||
#### Γραμμή 57
|
||
|
||
Εμφάνιση στο παράθυρο κονσόλας του χαρακτήρα `X`
|
||
|
||
#### Γραμμή 58
|
||
|
||
Κλείσιμο της δεύτερης ανακύκλωσης και έτσι η εκτύπωση των `X` θα γίνει τόσες φορές όσες έχει επιλέξει ο χρήστης που έχουν αποθηκευθεί στην μεταβλητή `side2`
|
||
|
||
#### Γραμμή 59
|
||
|
||
Αλλαγή γραμμής στο παράθυρο κονσόλας.
|
||
|
||
#### Γραμμή 60
|
||
|
||
Κλείσιμο της πρώτης ανακύκλωσης. Εδώ τών αυξάνει κατά 1 ο μετρητής της κάθετης διάστασης του τετραγώνου. Ετσι ολόκληρη η διαδικασία \[επαναλαμβανόμενη εμφάνισης
|
||
των `X` (δεύτερη ανακύκλωση) και η αλλαγή γραμμής\] θα γίνει τόσες φορές όσες έχει ζητήσει ο χρήστης όταν όριζε την πρώτη (κάθετη) διάσταση του τετραγώνου. Αυτή
|
||
η τιμή είναι αποθηκευμένη στην μεταβλητή `side1`.
|
||
|
||
|
||
### [4. Η εντολή EXIT FOR]{#s4}
|
||
|
||
Συνήθως χρησιμοποιούμε τις ανακυλώσεις για να εκτελέσουμε συγκεκριμένο αριθμό επαναλήψεων ενός κομματιού κώδικα.\
|
||
Υπάρχουν όμως περιπτώσεις που θέλουμε να διακόψουμε την ανακύκλωση στην μέση γιατί μετά από κάποιο έλεγχο που κάνουμε, θέλουμε να συνεχίσει το πρόγραμμα με τον
|
||
κώδικα που υπάρχει μετά το `NEXT`. Τότε μαζί με τον έλεγχό μας χρησιμοποιούμε και την εντολή `EXIT FOR` έτσι το `FOR ... NEXT`
|
||
διακόπτεται και η εκτέλεση συνεχίζεται μετά το `NEXT` σαν να είχε τελειώσει κανονικά η ανακύκλωση.
|
||
|