+++
title = 'Xbasic'
date = '2000-12-01T00:00:00Z'
description = ''
author = 'Κώστας Τσακάλογλου(mailto:tsakf@hellug.gr)'
issue = ['Magaz 29']
issue_weight = 4
+++

----------------------------------------------------------------------------------------------------------------------------------------------------------------

*Συναρτήσεις στην XBASIC.*

----------------------------------------------------------------------------------------------------------------------------------------------------------------

**1. Οι συναρτήσεις**
----------------------------------------------

**2. Παράδειγμα συνάρτησης.**
------------------------------------------------------

-   [2.1 Επεξήγηση του προγράμματος](#ss2.1)

**3. Πως λειτουργούν οι συναρτήσεις**
--------------------------------------------------------------

-   [3.1 Συναρτήσεις και δομημένος προγραμματισμός](#ss3.1)
-   [3.2 Γιατί το να γράφουμε δομημένα με συναρτήσεις είναι σημαντικό;](#ss3.2)
-   [3.3 Σχεδιάζοντας ένα δομημένο πρόγραμμα.](#ss3.3)
-   [3.4 Γράφοντας μια συνάρτηση](#ss3.4)
-   [3.5 Το εσωτερικό της συνάρτησης](#ss3.5)
-   [3.6 Ο κώδικας των συναρτήσεων.](#ss3.6)


### [1. Οι συναρτήσεις]{#s1}

Οι συναρτήσεις είναι βασικό δομικό στοιχείο των προγραμμάτων στην Xbasic. Οι συναρτήσεις είναι ανεξάρτητα κομμάτια κώδικα που εκτελούν μια συγκεκριμένη εργασία
και μπορεί να επιστρέφουν κάποια τιμή στον κώδικα που τις καλεί.

Οι ιδιότητες των συναρτήσεων:

-   **Έχουν μοναδικό όνομα.**\
    Κάθε συνάρτηση έχει ένα μοναδικό όνομα. Η χρήση του ονόματος σε ένα άλλο μέρος του προγράμματος, επιτρέπει την εκτέλεση των εντολών που περιέχονται σε αυτή.
    Αυτό ονομάζεται και κλήση της συνάρτησης. Μια συνάρτηση μπορεί να καλείται και μέσα από μια άλλη συνάρτηση.
-   **Ο κώδικας που περιέχουν είναι ανεξάρτητος από το υπόλοιπο πρόγραμμα.**\
    Όλες οι μεταβλητές που χρησιμοποιούνται δεν έχουν σχέση με τις μεταβλητές που μπορεί να έχουν το ίδιο όνομα και να υπάρχουν αλλού στο πρόγραμμα. Εξαίρεση
    είναι οι μεταβλητές που εμείς ορίζουμε ότι θα έχουν σχέση με το υπόλοιπο πρόγραμμα όπως θα δούμε παρακάτω.
-   **Μια συνάρτηση εκτελεί μια συγκεκριμένη εργασία.**\
    Οι συναρτήσεις συνήθως χρησιμοποιούνται για να εκτελέσουμε συγκεκριμένες εργασίες που μπορεί να χρειαστεί να εκτελεστούν πολλές φορές μέσα σε ένα πρόγραμμα,
    με διαφορετικά δεδομένα κάθε φορά.
-   **Μια συνάρτηση μπορεί να επιστρέφει μια τιμή στον κώδικα που την καλεί.**\
    Όταν το πρόγραμμά μας καλεί μια συνάρτηση, εκτελείται ο κώδικας της συνάρτησης και μπορούμε να έχουμε κάποια τιμή που επιστρέφει από την συνάρτηση σαν
    αποτέλεσμα της εκτέλεσης του κώδικα.


### [2. Παράδειγμα συνάρτησης.]{#s2}

Παρακάτω ακολουθεί ένα παράδειγμα συνάρτησης στην XBASIC.

----------------------------------------------------------------------------------------------------------------------------------------------------------------

     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.DECLARE FUNCTION  SLONG cube (SLONG x)
     37.'
     38.'
     39.' ######################
     40.' #####  Entry ()  #####
     41.' ######################
     42.'
     43.' Programs contain:
     44.'   1. A PROLOG with type/function/constant declarations.
     45.'   2. This Entry() function where execution begins.
     46.'   3. Zero or more additional functions.
     47.'
     48.FUNCTION  Entry ()
     49.    SLONG inpu, answer
     50.    STRING inpus
     51.
     52. inpus=INLINE$("Enter number :")
     53. inpu=SLONG(inpus)
     54. answer = cube(inpu)
     55. PRINT answer
     56.
     57.
     58.
     59.END FUNCTION
     60.'
     61.'
     62.' #####################
     63.' #####  cube ()  #####
     64.' #####################
     65.'
     66.FUNCTION SLONG cube (SLONG x)
     67.
     68.  x_cube = x * x * x
     69.
     70.END FUNCTION(x_cube)
     71.END PROGRAM

----------------------------------------------------------------------------------------------------------------------------------------------------------------

### [2.1 Επεξήγηση του προγράμματος]{#ss2.1}

Ας προσπαθήσουμε όμως να κάνουμε μια ανάλυση του παραπάνω προγράμματος. Έχουμε λοιπόν.

**Γραμμές 1..34**\
Εδώ έχουμε τους αρχικούς ορισμούς και το κομμάτι PROLOG όπως έχουμε αναλύσει και στα προηγούμενα τεύχη.

**Γραμμή 35**\
Εδώ έχουμε το ορισμό της συνάρτησης Entry() όπου αναλύοντας τον βλέπουμε ότι αυτή η συνάρτηση δεν έχει παράμετρο.

**Γραμμή 36**\
Σε αυτή την γραμμή ορίζεται η συνάρτηση cube και από τον ορισμό της βλέπουμε ότι αυτή η συνάρτηση είναι τύπου SLONG που σημαίνει ότι θα μας επιστρέψει κάποια
τιμή SLONG. Στην λίστα παραμέτρων (αυτή που υπάρχει ανάμεσα στις παρενθέσεις) βλέπουμε ότι η cube δέχεται σαν παράμετρο μια SLONG μεταβλητή για να κάνει τον
υπολογισμό. Στο παράδειγμά μας έχουμε ορίσει και την cube και την παράμετρό της ίδιου τύπου. Αυτό δεν είναι δεσμευτικό, μπορούμε να έχουμε μία ή και πολλές
παραμέτρους διαφορετικού τύπου από τον τύπο της οριζόμενης συνάρτησης.

**Γραμμές 48..55**\
Στην γραμμές 49 και 50 ορίζουμε τις μεταβλητές που θα χρησιμοποιηθούν μέσα στην Entry. Στην γραμμή 52 παίρνουμε την πληκτρολόγηση του χρήστη στην μεταβλητή
τύπου string inpus. Στην γραμμή 53 την μετατρέπουμε σε SLONG για να μπορεί να χρησιμοποιηθεί από την cube. Στην γραμμή 54 καλείται η συνάρτηση cube να κάνει τον
υπολογισμό και να επιστρέψει το αποτέλεσμα στην μεταβλητή answer.\
Στην γραμμή 55 εμφανίζουμε το αποτέλεσμα στο console window της Xbasic.

**Γραμμές 66..71**\
Εδώ βρίσκεται ο κώδικας της συνάρτησης cube. Στην γραμμή 66 υπάρχει ο ορισμός των παραμέτρων και στην συνέχεια έχουμε τον κώδικα υπολογισμού. Σε αυτή την
συνάρτηση έχουμε απλά το υπολογισμό του κύβου (ύψωση στην τρίτη δύναμη) της παραμέτρου x, που βρίσκεται στην γραμμή 68. Στην γραμμή 70, η τοποθέτηση του
αποτελέσματος σε παρένθεση κάνει την Xbasic να δώσει την τιμή αυτή σαν αποτέλεσμα υπολογισμού στην συνάρτηση cube και να το επιστρέψει στην μεταβλητή που
χρησιμοποιήσαμε για την κλήση της, την answer.

Με αυτό το απλό παράδειγμα φαίνεται πόσο χρήσιμο είναι να χρησιμοποιούμε συναρτήσεις, εφόσον αν ξαναχρειαστούμε μέσα στο πρόγραμμα να υπολογίσουμε τον κύβο ενός
αριθμού δεν έχουμε παρά να καλέσουμε την συνάρτηση.

Π.χ.

----------------------------------------------------------------------------------------------------------------------------------------------------------------

    SLONG x1,x2

    x1 = 10
    x2 = cube(x1)

----------------------------------------------------------------------------------------------------------------------------------------------------------------


### [3. Πως λειτουργούν οι συναρτήσεις]{#s3}

Ένα πρόγραμμα Xbasic δεν εκτελεί τις εντολές που βρίσκονται σε μια συνάρτηση μέχρι η συνάρτηση να κληθεί από ένα άλλο μέρος του προγράμματος. Όταν η συνάρτηση
κληθεί, τότε το πρόγραμμα στέλνει τις παραμέτρους (αν υπάρχουν) στην συνάρτηση. Η παράμετρος είναι κάποια μεταβλητή που περιέχει πληροφορία που είναι απαραίτητη
για την εκτέλεση του κώδικα της συνάρτησης. Στην συνέχεια εκτελούνται οι εντολές που περιέχονται στην συνάρτηση εκτελώντας την επιθυμητή εργασία. Όταν τελειώσει
η εκτέλεση του κώδικα της συνάρτησης η εκτέλεση συνεχίζεται στην αμέσως επόμενη εντολή μετά την κλήση της συνάρτησης. Οι συναρτήσεις μπορεί να επιστρέφουν
κάποια τιμή στο πρόγραμμα που τις κάλεσε.

### [3.1 Συναρτήσεις και δομημένος προγραμματισμός]{#ss3.1}

Χρησιμοποιώντας τις συναρτήσεις δημιουργούμε ένα πρόγραμμα που είναι πολύ πιο εύκολο να αναπτυχθεί και να διορθωθεί εκ των υστέρων. Αυτός ο τρόπος συγγραφής
προγράμματος ονομάζεται δομημένος προγραμματισμός.

### [3.2 Γιατί το να γράφουμε δομημένα με συναρτήσεις είναι σημαντικό;]{#ss3.2}

Είναι πολύ ευκολότερο να προγραμματίζουμε δομημένα γιατί αυτός ο τρόπος προγραμματισμού μας επιτρέπει να αντιμετωπίσουμε το περίπλοκα προβλήματα διαιρώντας τα
σε πολλά απλά μικρά. Κάθε μικρό πρόβλημα αντιμετωπίζεται με την δική του συνάρτηση όπου οι μεταβλητές είναι απομονωμένες από το υπόλοιπα πρόγραμμα εκτός από τις
παραμέτρους και την τιμή επιστροφής. Έτσι η επίλυση μικρών προβλημάτων ένα κάθε φορά μας επιτρέπει να αναπτύξουμε με μεγαλύτερη ευκολία την εφαρμογή μας.

Είναι πολύ ευκολότερο να βρίσκουμε τα λάθη σε ένα δομημένο πρόγραμμα. Αν υπάρχει κάποιο λάθος, αυτό μπορεί να περιοριστεί στην αντίστοιχη συνάρτηση και να
επιλυθεί. Δεν μπορούμε να το συγκρίνουμε με το πόσο επίπονο θα είναι να ψάχνουμε σε ένα κατεβατό από πολλές γραμμές κώδικα για να εντοπίσουμε το λάθος.

Ένα πραγματικό πλεονέκτημα των συναρτήσεων είναι ότι αφού γράψουμε μια συνάρτηση για να λύσουμε ένα επιμέρους πρόβλημα τότε αυτή η συνάρτηση είναι διαθέσιμη να
χρησιμοποιηθεί ξανά, είτε στο τρέχον πρόγραμμα που γράφουμε, είτε σε κάποιο άλλο μεταγενέστερο. Ακόμα και αν οι ανάγκες του επόμενου προγράμματος είναι λίγο
διαφορετικές, είναι πιο απλό να αλλάξουμε λίγο τις εντολές μιας συνάρτησης, παρά να την ξαναγράψουμε από την αρχή.

### [3.3 Σχεδιάζοντας ένα δομημένο πρόγραμμα.]{#ss3.3}

Αν θέλετε να σχεδιάσετε ένα δομημένο πρόγραμμα πρέπει πρώτα να κάνετε ένα σχέδιο των λειτουργιών του προγράμματος. Αυτό πρέπει να γίνει πριν ακόμη αρχίζουμε να
γράφουμε κάποια γραμμή κώδικα. Είναι ανάγκη να ορισθούν οι λειτουργίες του προγράμματος. Παρακάτω θα δούμε ένα παράδειγμα στησίματος ενός δομημένου
προγράμματος. Ας πούμε λοιπό ότι ένα πρόγραμμα θα εκτελεί τις εργασίες:

-   Εισαγωγή νέων ονομάτων και διευθύνσεων
-   Διόρθωση των στοιχείων που ήδη υπάρχουν
-   Ταξινόμηση στοιχείων κατά όνομα
-   Εκτύπωση ετικετών

Με αυτόν τον κατάλογο εργασιών μπορούμε τώρα να αναλύσουμε κάθε εργασία στις επιμέρους για να ξεκινήσουμε να γράφουμε τον κώδικα. Ας ξεκινήσουμε με το
\"Εισαγωγή νέων ονομάτων και διευθύνσεων\"

-   Ανάγνωση των διαθεσίμων ονομάτων από το αρχείο
-   'νοιγμα πεδίων στην οθόνη για την καταχώρηση νέων στοιχείων
-   Προσθήκη νέων στοιχείων στον κατάλογο των ονομάτων
-   Φύλαξη όλου του καταλόγου

Το \"Διόρθωση των στοιχείων που ήδη υπάρχουν\" αναλύεται σε:

-   Ανάγνωση των διαθεσίμων ονομάτων από το αρχείο
-   'νοιγμα πεδίων στην οθόνη για την διόρθωση των στοιχείων
-   Φύλαξη όλου του καταλόγου

Θα παρατηρήσατε ότι και στις δύο περιπτώσεις υπάρχουν δύο κοινές λειτουργίες, η \"Ανάγνωση των διαθεσίμων ονομάτων από το αρχείο\" και η \"Φύλαξη όλου του
καταλόγου\". Εδώ φαίνεται καθαρά η οικονομία χρόνου που μπορεί να έχουμε με την χρήση των συναρτήσεων. Θα γράψουμε δύο συναρτήσεις για αυτές τις δύο λειτουργίες
και θα τις χρησιμοποιήσουμε την κάθε μια, δύο φορές μέσα στο πρόγραμμά μας. Αυτή η μέθοδος δίνει ιεραρχική δομή στον κώδικα του προγράμματός μας.

Αν ακολουθήσουμε την μέθοδο της αντιμετώπισης ενός προβλήματος διαιρώντας το σε περισσότερα μικρότερα δημιουργούμε ευανάγνωστα και εύκολα στην διόρθωση
προγράμματα. Έτσι θα δείτε πολλά προγράμματα Xbasic να έχουν ένα πολύ μικρό κομμάτι εκτελέσιμου κώδικα στην Entry(), και όλες οι λειτουργίες να γίνονται με
συναρτήσεις. Αποφεύγετε να γράφετε μεγάλες συναρτήσεις γιατί χάνονται τα πλεονεκτήματα της χρήσης τους. Επίσης σε ομάδες προγραμματιστών που ο κάθε ένας έχει
αναλάβει να γράψει κώδικα για διαφορετικό κομμάτι της εφαρμογής οι συναρτήσεις επιτρέπουν να μην γράφεται πολλές φορές (κάθε φορά από διαφορετικό
προγραμματιστή) κώδικας, που εκτελεί την ίδια λειτουργία. Συνήθως η συνάρτηση γράφεται από έναν και είναι διαθέσιμη σε όλους.

### [3.4 Γράφοντας μια συνάρτηση]{#ss3.4}

Εδώ θα δούμε λίγο πιο αναλυτικά αυτά που είδαμε παραπάνω στο παράδειγμά μας.

Το πρώτο βήμα για να γράψουμε μια συνάρτηση είναι να έχουμε αποφασίσει τι θα κάνει. Όταν ξέρουμε τι θέλουμε να κάνει η συνάρτηση, είναι σχετικά εύκολο να την
γράψουμε. Στην πρώτη γραμμή της συνάρτησης, ορίζονται:

-   Το όνομά της
-   Ο τύπος της συνάρτησης
-   Η λίστα παραμέτρων (αν χρειάζεται)

Στο παράδειγμά μας, στην γραμμή 66 έχουμε: `FUNCTION                               SLONG cube (SLONG x)`

Αναλύοντας αυτή την γραμμή έχουμε:

-   Την εντολή `FUNCTION` που δηλώνει ότι ξεκινά από εδώ και πέρα κώδικας που ανήκει σε συνάρτηση και οι μεταβλητές που θα βρεθούν δεν έχουν σχέση με τυχόν
    ίδιου ονόματος σε άλλα σημεία του προγράμματος.

-   Τον τύπο `SLONG` που σημαίνει ότι αυτή η συνάρτηση θα επιστρέψει τιμή τύπου `SLONG`. Ο τύπος της συνάρτησης μπορεί να είναι οποιοσδήποτε από τους τύπους
    μεταβλητών της Xbasic που έχουμε αναφέρει σε προηγούμενα άρθρα.\
    Ετσι οι ορισμοί:

    ----------------------------------------------------------------------------------------------------------------------------------------------------------------

        FUNCTION STRING retstr  ..
        FUNCTION SSHORT test  .

    ----------------------------------------------------------------------------------------------------------------------------------------------------------------

    ορίζουν συναρτήσεις τύπου `STRING` και `SSHORT` αντίστοιχα.

-   Το όνομα της συνάρτησης που είναι το `cube`. Τα ονόματα των συναρτήσεων ακολουθούν του ίδιους κανόνες με τα ονόματα των μεταβλητών που έχουμε αναφέρει.

-   Τις παραμέτρους της συνάρτησης.

Πολλές συναρτήσεις χρησιμοποιούν παραμέτρους που οι τιμές τους είναι απαραίτητα στοιχεία για εκτελέσουν κάποιο υπολογισμό. Για κάθε παράμετρο που μεταφέρει
κάποια τιμή στην συνάρτηση η λίστα παραμέτρων πρέπει να έχει έναν ορισμό. Αυτός ο ορισμός δηλώνει τον τύπο της μεταβλητής που φέρνει τα δεδομένα και ένα όνομα
που με αυτό αντιστοιχείται η τιμή αυτή μέσα στην συνάρτηση.

Στην cube έχουμε την λίστα παραμέτρων (`SLONG                               x`). Με αυτόν τον τρόπο δηλώνουμε ότι, όταν κληθεί αυτή η συνάρτηση, θα μας έρθει
μια τιμή από το πρόγραμμα που την καλεί και από δώ και πέρα μέσα στην συνάρτηση αναφέρεται με το όνομα x. Στο παράδειγμά μας με την κλήση της συνάρτησης cube η
τιμή της μεταβλητής inpu περνάει στην συνάρτηση, και από δω και πέρα η τιμή αυτή εκπροσωπείται από την μεταβλητή x.

Για να δούμε ξεκάθαρα την ευκολία που μας παρέχει η χρήση των συναρτήσεων θα κάνουμε διαδοχική κλήση της ίδιας συνάρτησης με άλλες παραμέτρους κάθε φορά.

----------------------------------------------------------------------------------------------------------------------------------------------------------------

    FUNCTION Entry()
    SLONG num1
    SLONG num2
    SLONG z
    num1 = 8
    num2 = 10
    z = cube(num1)
    PRINT z
    z = cube(num2)
    PRINT z
    END FUNCTION

----------------------------------------------------------------------------------------------------------------------------------------------------------------

Αν αντικαταστήσουμε την Entry() στο παράδειγμά μας με τις παραπάνω γραμμές, τότε το αποτέλεσμα του προγράμματος στην κονσόλα θα δείξει:

`512`\
`1000`

Έτσι γράφοντας μια φορά την cube μπορούμε να έχουμε τον υπολογισμό του κύβου αριθμού με διαφορετικά δεδομένα κάθε φορά, και το αντίστοιχο αποτέλεσμα.

### [3.5 Το εσωτερικό της συνάρτησης]{#ss3.5}

Μπορούν να ορισθούν μεταβλητές στο εσωτερικό μιας συνάρτησης. Οι μεταβλητές αυτές ονομάζονται τοπικές. Ο όρος τοπικές σημαίνει ότι οι μεταβλητές αυτές ανήκουν
στην συνάρτηση και δεν έχουν καμμία σχέση με μεταβλητές ίδιου ονόματος σε άλλα σημεία του προγράμματος. Εννοείται ότι ακολουθούνται οι κανόνες ονοματολογίας των
μεταβλητών στην Xbasic. Συνοψίζοντας την χρήση των μεταβλητών στις συναρτήσεις της Xbasic έχουμε:

-   Τοπικές μεταβλητές\
    Ορίζονται στην συνάρτηση και δεν έχουν καμμία σχέση με άλλες μεταβλητές αλλού στο πρόγραμμα.
-   Παράμετροι\
    Αυτές οι μεταβλητές μεταφέρουν δεδομένα από το πρόγραμμα που τις καλεί, για να χρησιμοποιηθούν σε υπολογισμούς.
-   Επιστρεφόμενη τιμή\
    Για να μπορεί το πρόγραμμα που καλεί την συνάρτηση να πάρει ένα αποτέλεσμα του υπολογισμού της, πρέπει να ορισθεί μια τιμή επιστροφής. Αυτή ορίζεται είτε με
    την τοποθέτηση της μεταβλητής που περιέχει την επιστρεφόμενη τιμή δίπλα στην εντολή END FUNCTION μέσα σε παρένθεση, είτε με τοποθέτηση μέσα στην συνάρτηση
    μιας από τις δύο εντολές (RETURN ή EXIT FUNCTION) και δίπλα, σε παρένθεση, την μεταβλητή με την τιμή επιστροφής.

### [3.6 Ο κώδικας των συναρτήσεων.]{#ss3.6}

Συνήθως ο κώδικας των συναρτήσεων ακολουθεί τον κώδικα της συνάρτησης ENTRY () μέσα στο ίδιο αρχείο που περιέχεται όλο το πρόγραμμα. Σε πολύπλοκα προγράμματα
όμως, όπου αρκετοί προγραμματιστές ασχολούνται με το ίδιο θέμα, είναι καλύτερα οι συναρτήσεις να μπαίνουν σε ξεχωριστό αρχείο ή και σε πολλά αρχεία ανάλογα με
τις ανάγκες της εφαρμογής. Έτσι μπορεί να έχουμε σε ένα αρχείο όλες τις συναρτήσεις που έχουν σχέση με την αποθήκευση στον δίσκο, σε άλλο τα γραφικά, σε άλλο οι
μαθηματικοί υπολογισμοί κλπ. Έτσι δημιουργούνται οι βιβλιοθήκες συναρτήσεων, όπου ο κάθε προγραμματιστής μπορεί να τις συντηρεί (διορθώνει, βελτιώνει) και αυτές
να είναι διαθέσιμες σε όλους τους άλλους.

Κλείνοντας το κεφάλαιο των συναρτήσεων θέλω να τονίσω ότι η διαφορά στον τρόπο προγραμματισμού με συναρτήσεις και χωρίς αυτές, είναι τόσο μεγάλη που πια σήμερα
κανείς δεν γράφει προγράμματα που να μην έχουν συναρτήσεις. Όταν εγώ ξεκίνησα να γράφω, οι γλώσσες που χρησιμοποιούσα τότε, δεν είχαν την δυνατότητα δημιουργίας
συναρτήσεων και πάρα πολλά λάθη είχαν εμφανισθεί λόγω της χρήσης ίδιων ονομάτων μεταβλητών σε διαφορετικά σημεία του προγράμματος. Η δε απομόνωση του σημείου
του κώδικα που περιείχε το λάθος ήταν εξαιρετικά επίπονη. Με την χρήση συναρτήσεων ο χρόνος εντοπισμού των σφαλμάτων περιορίστηκε σε κάτω από τον μισό. Στην
συνέχεια θα δούμε τις εντολές ελέγχου της ροής του προγράμματος στην Xbasic.

