+++
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` σαν να είχε τελειώσει κανονικά η ανακύκλωση.

