INFORMATICA - BASIC: PROCEDURE E FUNZIONI

L'ISTRUZIONE GOSUB

Nelle prime versioni del Basic l'unica istruzione disponibile per il richiamo di un sottoprograma era l'istruzione GOSUB.

GOSUB numeroRiga

numeroRiga è la prima riga del sottoprogramma; il sottoprogramma può essere definito in qualsiasi punto e deve contenere una o più istruzioni RETURN.
L'istruzione RETURN indica il rientro dal sottoprogramma; l'esecuzione cioè deve essere ripresa dall'istruzione successiva alla GOSUB che è servita per il richiamo del sottoprogramma.
L'istruzione GOSUB è ancora disponibile insieme alla ON... GOSUB che permette di richiamare un diverso sottoprogramma in base al valore di una variabile (analogamente a quanto visto per la ON ... GOTO); è comunque preferibile non usare queste istruzioni e servirsi invece della SUB per la definizione del sottoprogramma e della CALL per il richiamo.

L'ISTRUZIONE SUB PER LA DEFINIZIONE DI SOTTOPROGRAMMI

Il modo migliore per definire un sottoprogramma è usare l'istruzione SUB.

SUB nome [(elencoargomenti)] [STATIC]
[bloccoistruzioni]
END SUB

Nome è il nome del sottoprogramma e non deve avere suffissi; elencoargomenti è un elenco di variabili che rappresentano i parametri formali del sottoprogramma; ogni variabile può essere definita come

variabile [()] [AS tipo]

le parentesi vanno indicate quando la variabile è di tipo vettoriale; il tipo può essere utilizzato invece dei suffissi; ANY indica che si tratta di un tipo qualsiasi di dati.
La parola STATIC serve per richiedere che i valori delle variabili locali vengano salvati tra una chiamata e l'altra del sottoprogramma.

IL RICHIAMO DEL SOTTOPROGRAMMA

Il sottoprogramma può essere richiamato nei punti in cui è necessario con l'istruzione CALL.

[CALL] nome [([elencoargomenti])]

Elencoargomenti è una lista di variabili o costanti separate da virgole che rappresenta la lista dei parametri attuali da fornire al sottoprogramma; il valore degli argomenti viene sostituito ordinatamente nelle variabili indicate nella SUB come parametri formali.
Il passaggio dei parametri è per indirizzo, cioè ogni modifica ad un parametro formale ha effetto anche sul corrispondente parametro attuale; se si vuole che una variabile indicata nell'elenco dei parametri non venga modificata dal sottoprogramma bisogna racchiuderla tra parentesi.
La parola CALL può essere omessa; se è presente i parametri vanno indicati tra parentesi, altrimenti no.

LA DICHIARAZIONE DEI SOTTOPROGRAMMI

I sottoprogrammi vanno dichiarati all'inizio del programma con l'istruzione DECLARE.

DECLARE SUB nome [([elencoargomenti])]

LA SCRITTURA DI UN PROGRAMMA CON SUBROUTINE

Le subroutine vanno dichiarate all'inizio del programma con l'istruzione DECLARE. Poi si scrive il programma principale.
Usando il QBasic, per scrivere una subroutine si sceglie la voce "Nuova sub" dal menu "Modifica". Sullo schermo viene presentata una nuova finestra di editor, dove è possibile scrivere la definizione della subroutine.
Per tornare a visualizzare e modificare il programma principale o una qualsiasi delle subroutine basta scegliere la voce "SUBs" dal menu "Visualizza"; compare l'elenco di tutti i moduli disponibili tra cui scegliere quello desiderato.

RICHIAMO DI SOTTOPROGRAMMI IN LINGUAGGIO MACCHINA

E' possibile anche richiamare sottoprogrammi scritti in linguaggio macchina. L'istruzione CALL ABSOLUTE trasferisce il controllo ad un sottoprogramma in linguaggio macchina.

PROGRAMMA 10 - CALCOLATRICE TASCABILE
Questo programma, come il 5, esegue le quattro operazioni aritmetiche a richiesta; permette però di eseguire più operazioni, finché l'utente decide di terminare il programma, ed esegue alcuni controlli che garantiscono il corretto funzionamento anche in caso di errore da parte dell'utente.
Il programma è realizzato con il metodo dell'analisi top-down e la codifica è realizzata facendo uso di subroutine.

Descrizione delle variabili
La descrizione delle variabili deve essere fatta separatamente per ogni modulo (programma principale e ciascuna subroutine.

Programma principale


+----------------------------------------------------------------+
¦   NOME    ¦    TIPO     ¦      I/O         ¦    SIGNIFICATO    ¦
+-----------+-------------+------------------+-------------------¦
¦ RISPOSTA  ¦alfanumerico ¦     input        ¦ risposta alla     ¦
¦           ¦             ¦                  ¦ domanda di        ¦
¦           ¦             ¦                  ¦ continuazione     ¦
+----------------------------------------------------------------+

Esecuzione operazione
Funzione della subroutine: esegue una operazione; richiesta dati, calcolo, emissione risultato.


+----------------------------------------------------------------+
¦   NOME    ¦    TIPO     ¦      I/O         ¦    SIGNIFICATO    ¦
+-----------+-------------+------------------+-------------------¦
¦     A     ¦numero reale ¦  input/output    ¦primo operando     ¦
¦     B     ¦numero reale ¦  input/output    ¦secondo operando   ¦
¦     C     ¦numero reale ¦     output       ¦risultato          ¦
¦           ¦             ¦                  ¦dell'operazione    ¦
¦ OPERATORE ¦alfanumerico ¦  input/output    ¦simbolo dell'opera-¦
¦           ¦             ¦                  ¦zione richiesta    ¦
¦  ERRORE   ¦  booleano   ¦  interno         ¦segnale che indica ¦
¦           ¦             ¦                  ¦se si è verificato ¦
¦           ¦             ¦                  ¦un errore          ¦
+----------------------------------------------------------------+

Divisione
Funzione della subroutine: esegue la divisione tra due numeri, restituendo il risultato della divisione o un segnale di errore se si tenta di eseguire la divisione per zero.



+----------------------------------------------------------------+
¦   NOME    ¦    TIPO     ¦      I/O         ¦    SIGNIFICATO    ¦
+-----------+-------------+------------------+-------------------¦
¦     X     ¦ numero reale¦     interno      ¦parametro di input;¦
¦           ¦             ¦                  ¦dividendo          ¦
¦     Y     ¦ numero reale¦     interno      ¦parametro di input ¦
¦           ¦             ¦                  ¦divisore           ¦
¦     Z     ¦ numero reale¦     interno      ¦parametro di output¦
¦           ¦             ¦                  ¦risultato della    ¦
¦           ¦             ¦                  ¦divisione se Y è   ¦
¦           ¦             ¦                  ¦diverso da 0       ¦
¦  ERRORE   ¦  booleano   ¦     interno      ¦parametro di output¦
¦           ¦             ¦                  ¦segnale che indica ¦
¦           ¦             ¦                  ¦il tentativo di    ¦
¦           ¦             ¦                  ¦dividere per 0     ¦
+----------------------------------------------------------------+

Flow chart Programma 10 (prima parte)

Flow chart Programma 10 (seconda parte)

Flow chart Programma 10 (terza parte)

Flow chart Programma 10 (quarta parte)


Pseudocodifica (vedi Figure)


  1   inizio
  2        ripeti
  3             esecuzione operazione
  4             emissione richiesta di continuazione
  5             lettura RISPOSTA
  6        finché RISPOSTA = "N"
  7   fine
  8   Esecuzione operazione
  9        ERRORE = falso
 10        emissione richiesta primo operando
 11        lettura A
 12        emissione richiesta secondo operando
 13        lettura B
 14        ripeti
 15             emissione richiesta operatore
 16             lettura OPERATORE
 17          finché OPERATORE = "+" o "-" o "*" o  "/"
 18        se OPERATORE = "+" allora
 19             C = A + B
 20        fine se
 21        se OPERATORE = "-" allora
 22             C = A - B
 23        fine se
 24        se OPERATORE = "*" allora
 25             C = A * B
 26        fine se
 27        se OPERATORE = "/" allora
 28             divisione(A, B, C, ERRORE)
 29        fine se
 30        se ERRORE = falso allora
 31             emissione A OPERATORE B "=" C
 32        altrimenti
 33             emissione messaggio di errore
 34        fine se
 35   fine procedura
 36   Divisione(X, Y, Z, ERRORE)
 37        se Y > 0 allora
 38             Z = X / Y
 39        altrimenti
 40             ERRORE = vero
 41        fine se
 42   fine procedura

da 1 a 7 Questo è il programma principale; è costituito da un ciclo until che ripete l'esecuzione di una operazione finché l'utente risponde con il carattere N alla richiesta di continuazione. Soltanto il carattere N fa uscire dal programma; qualsiasi altro carattere, anche n minuscolo, fa eseguire un'altra operazione.
3 Chiamata della procedura che svolge in dettaglio l'esecuzione di un'operazione; non viene passata nessuna variabile alla procedura e non si aspetta nessuna variabile di ritorno; la procedura non ha parametri.
da 8 a 35 Procedura che svolge l'esecuzione di un'operazione.
9 La variabile ERRORE è una variabile booleana, cioè può assumere soltanto i valori vero o falso; inizialmente viene posta uguale a falso e il suo valore verrà modificato in vero soltanto se si verifica un errore.
da 10 a 13 Inserimento degli operandi; si tratta di numeri reali.
da 14 a 17 Inserimento del simbolo di operazione; i simboli ammessi sono + - * e /. Il ciclo serve a controllare che si inserisca un valore corretto; se si inserisce un carattere diverso dai simboli ammessi, non viene considerato e si ripete la richiesta del simbolo di operazione.
17 La condizione di uscita dal ciclo until è una condizione composta con degli operatori OR; la condizione composta è falsa se tutte le condizioni semplici sono false ed è vera se almeno una delle condizioni semplici è vera.
Se si fosse usato un ciclo while per invertire la condizione si sarebbe dovuto scrivere:

OPERATORE = " "
mentre OPERATORE diverso da "+" e diverso da "-" e diverso da "*" e diverso da "/"
emissione richiesta operatore
lettura OPERATORE
fine mentre

quindi usando l'operatore and invece dell'operatore or; infatti la condizione composta deve essere vera quando tutte le condizioni semplici sono vere e deve diventare falsa appena una delle condizioni semplici diventa vera.
da 18 a 29 Esecuzione di una delle operazioni in base al simbolo immesso.
28 Se l'operazione richiesta è una divisione, invece di eseguire direttamente l'operazione come negli altri casi viene richiamata ua procedura che controlla anche se si verifica un errore a causa di un tentativo di dividere per zero.
Alla procedura vengono fornite le variabili A e B (dividendo e divisore) e ci si attende di ricevere la variabile C, risultato dell'operazione e la variabile ERRORE che, se ha valore "vero" segnala che il divisore era zero e che non è stato possibile eseguire l'operazione richiesta.
30 Viene esaminato il valore della variabile ERRORE restituita dalla procedura Divisione. Se il valore è falso vuol dire che non si sono verificati errori e ha senso stampare il risultato (riga 31); in caso contrario viene stampato il messaggio di errore (riga 33).
35 Fine della procedura di esecuzione dell'operazione; l'esecuzione del programma prosegue dalla riga 4 del programma principale.
da 36 a 42 Procedura che controlla se il divisore è zero e se possibile esegue la divisione.
La procedura ha come parametri:
X, a cui il modulo chiamante passa il dividendo;
Y, a cui il modulo chiamante passa il divisore;
Z, in cui la procedura memorizza il risultato, se possibile, e lo restituisce al modulo chiamante;
ERRORE (che anche se ha lo stesso nome di una variabile della procedura Esecuzione operazione è in realtà una variabile diversa), a cui il modulo chiamante fornisce il valore falso, e in cui viene posto il valore vero se il divisore è zero. Il valore contenuto in ERRORE viene poi restituito al modulo chiamante.
42 Fine della procedura di divisione. L'esecuzione prosegue dalla riga 29 della procedura Esecuzione operazione.

Programma in Basic


   10   REM Calcolatrice tascabile

   20   DECLARE SUB OPERAZIONE ()
   30      DECLARE SUB DIVISIONE (X, Y, Z, ERRORE%)

   40   REM Programma principale
   50        DO
   60             OPERAZIONE
   70             PRINT "Ancora operazioni?"
   80             INPUT RISPOSTA$
   90        LOOP UNTIL RISPOSTA$ = "N"
  100   END

  110   SUB DIVISIONE (X, Y, Z, ERRORE%)
  120        IF Y > 0 THEN
  130              Z = X / Y
  140        ELSE
  150             ERRORE% = 1
  160        END IF
  170   END SUB

  180   SUB OPERAZIONE
  190        ERRORE% = 0
  200        PRINT "Inserire il primo operando"
  210        INPUT A

  220        PRINT "Inserire il secondo operando"
  230        INPUT B
  240        DO
  250               PRINT "Inserire il simbolo di operazione"
  260             INPUT OPERATORE$
  270        LOOP UNTIL OPERATORE$ = "+" OR OPERATORE$  = "-" OR
             OPERATORE$ = "*" OR OPERATORE$ = "/"
  280        IF OPERATORE$ = "+" THEN
  290             C = A + B
  300        END IF
  310        IF OPERATORE$ = "-" THEN
  320             C = A - B
  330        END IF
  340        IF OPERATORE$ = "*" THEN
  350             C = A * B
  360        END IF
  370        IF OPERATORE$ = "/" THEN
  380             DIVISIONE (A), (B), C, ERRORE%
  390        END IF
  400        IF ERRORE% = 0 THEN
  410             PRINT A; " "; OPERATORE$; " "; B; =  "; C
  420        ELSE
  430             PRINT "Impossibile dividere per 0"
  440        END IF
  450   END SUB

20 Dichiarazione relativa alla subroutine OPERAZIONE; il nome è seguito dalle parentesi tonde aperta e chiusa perché la subroutine non ha parametri.
30 Dichiarazione relativa alla subroutine DIVISIONE; il nome della procedura è seguito dai parametri tra parentesi.
da 40 a 100 Codifica del programma principale. Nel programma principale è possibile richiamare le procedure, anche se non sono ancora state definite, perché comunque sono state dichiarate nelle righe precedenti.
60 Richiamo della subroutine OPERAZIONE; per richiamare la subroutine basta indicare il nome.
da 110 a 170 Definizione della subroutine DIVISIONE.
110 La subroutine è definita con la parola SUB, il nome, con cui può essere richiamata, e l'elenco dei parametri tra parentesi.
170 Ogni subroutine termina con l'istruzione END SUB.
da 180 a 450 Definizione della procedura OPERAZIONE.
180 Nella definizione della subroutine dopo SUB viene scritto solo il nome poiché la procedura non ha parametri; non vanno messe neanche le parentesi come nella dichiarazione.
190 La variabile ERRORE che logicamente è una variabile booleana viene codificata come numero intero poiché in Basic non esiste una definizione per le variabuli booleane. Basta stabilire che alla variabile possano essere assegnati due soli valori: per esempio 0 per falso e 1 per vero. Infatti viene posta inizialmente a 0 e diventa uguale a 1 soltanto se si tenta di eseguire la divisione per 0 (riga 150 della subroutine DIVISIONE).
380 Richiamo della subroutine Divisione; dopo il nome vengono indicati i parametri; i parametri A e B sono tra parentesi perché vengono passati come input alla subroutine ma non devono essere modificati e restituiti dalla subroutine stessa.
C ed ERRORE invece non vanno tra parentesi essendo parametri di output; se per errore fossero posti tra parentesi non si otterrebbero valori di ritorno dalla subroutine.


+----------------------------------------------------------------+
¦ Esempi di esecuzione                                           ¦
¦                                                                ¦
¦ Inserire il primo operando                                     ¦
¦ ? 153                                                          ¦
¦ Inserire il secondo operando                                   ¦
¦ ? 86                                                           ¦
¦ Inserire il simbolo di operazione                              ¦
¦ ? -                                                            ¦
¦  153  -  86  =  67                                             ¦
¦ Ancora operazioni?                                             ¦
¦ ? S                                                            ¦
¦ Inserire il primo operando                                     ¦
¦ ? 98                                                           ¦
¦ Inserire il secondo operando                                   ¦
¦ ? 3                                                            ¦
¦ Inserire il simbolo di operazione                              ¦
¦ ? *                                                            ¦
¦  98  *  3  =  294                                              ¦
¦ Ancora operazioni?                                             ¦
¦ ? S                                                            ¦
¦ Inserire il primo operando                                     ¦
¦ ? 155                                                          ¦
¦ Inserire il secondo operando                                   ¦
¦ ? 5                                                            ¦
¦ Inserire il simbolo di operazione                              ¦
¦ ? /                                                            ¦
¦  155  /  5  =  31                                              ¦
¦ Ancora operazioni?                                             ¦
¦ ? N                                                            ¦
+----------------------------------------------------------------+

Commenti
E' facile aggiungere alla calcolatrice altre operazioni. Si può provare per esempio ad aggiungere l'elevamento a potenza, fornendo la base e l'esponente.
Si potrà allora realizzare una procedura per il calcolo della potenza che restituisca il valore calcolato o una variabile ERRORE in caso di richiesta di operazioni non eseguibili.

LE FUNZIONI

Quando il sottoprogramma deve restituire un unico valore è possibile definire una funzione che permetta di calcolare tale valore.
Non è però mai indispensabile usare una funzione; è sempre possibile usare un sottoprogramma in ogni caso.
La definizione di una funzione può essere fatta con l'istruzione DEF FN.

nome DEF FN [(elencoparametri)] = espressione

nome DEF FN [(elencoparametri)]
[bloccoistruzioni]
nomeFN=espressione
[bloccoistruzioni]
END DEF

Il nome deve essere un nome di variabile valido; rappresenta il valore che verrà restituito dalla funzione e deve essere definito del tipo desiderato tramite il suffisso o gli altri metodi di specificazione delle variabili.
L'elencoparametri rappresenta la lista delle variabili da utilizzare come parametri formali che al momento del richiamo della funzione riceveranno i valori forniti con i parametri attuali.
Il richiamo della funzione viene fatto attraverso il nome della funzione seguito dall'elenco dei parametri attuali.
Il primo formato dell'istruzione DEF FN viene utilizzato quando la definizione della funzione può essere descritta con una semplice istruzione; il secondo formato quando la definizione è più complessa; deve comunque essere presente un'istruzione che assegni il valore risultato della funzione alla variabile che rappresenta il nome della funzione stessa.
Per definire una funzione è possibile usare anche l'istruzione FUNCTION.

FUNCTION nome [(elencoparamteri)] [STATIC]
[bloccoistruzioni]
nome=espressione
[bloccoistruzioni]
END FUNCTION

anche qui il nome deve essere un nome di variabile valido, con la specificazione del tipo di dato.
Se viene specificata la parola STATIC i valori delle variabili locali vengono salvati tra una chiamata e l'altra della funzione.
Le funzioni definite con l'istruzione FUNCTION vanno dichiarate all'inizio del programma con l'istruzione DECLARE.

DECLARE FUNCTION nome [([elencoargomenti])]

PROGRAMMA 11 - IL MASSIMO TRA DUE NUMERI
Questo programma non fa un lavoro molto significativo: calcola soltanto il massimo tra due numeri; lo scopo è quello di dimostrare come sia possibile definire una funzione che compia un lavoro stabilito dall'utente.

Descrizione delle variabili
Programma principale


+----------------------------------------------------------------+
¦   NOME    ¦    TIPO     ¦      I/O         ¦    SIGNIFICATO    ¦
+-----------+-------------+------------------+-------------------¦
¦    A      ¦numero reale ¦      input       ¦ primo numero da   ¦
¦           ¦             ¦                  ¦ confrontare       ¦
¦    B      ¦numero reale ¦      input       ¦ secondo numero da ¦
¦           ¦             ¦                  ¦ confrontare       ¦
+----------------------------------------------------------------+

Funzione MASSIMO
Scopo della funzione: calcola il massimo tra due numeri.


+----------------------------------------------------------------+
¦   NOME    ¦    TIPO     ¦  I/O  ¦   PARAMETRI    ¦ SIGNIFICATO ¦
+-----------+-------------+-------+----------------+-------------¦
¦    X      ¦numero reale ¦ inter.¦  parametro     ¦ primo       ¦
¦           ¦             ¦       ¦  di input      ¦ numero da   ¦
¦           ¦             ¦       ¦                ¦ confrontare ¦
¦    Y      ¦numero reale ¦ inter.¦  parametro     ¦ secondo     ¦
¦           ¦             ¦       ¦  di input      ¦ numero da   ¦
¦           ¦             ¦       ¦                ¦ confrontare ¦
¦ MASSIMO   ¦numero reale ¦ inter.¦   valore       ¦ valore      ¦
¦           ¦             ¦       ¦  in output     ¦ massimo     ¦
+----------------------------------------------------------------+

Flow chart Programma 11 (prima parte)

Flow chart Programma 11 (seconda parte)


Pseudocodifica (vedi Figure)


  1   inizio
  2        emissione richiesta primo valore
  3        lettura A
  4        emissione richiesta secondo valore
  5        lettura B
  6        emissione massimo(A, B)
  7   fine

  8   massimo(X, Y)
  9        se X > Y allora
 10             massimo = X
 11        altrimenti
 12             massimo = Y
 13        fine se
 14   fine funzione

da 1 a 7 Programma principale che richiede due valori e richiama la funzione per la determinazione del massimo.
da 2 a 5 Immissione dei due valori da confrontare.
6 Richiamo della funzione; vengono passati come parametri i due valori da confrontare, A e B; il risultato della funzione viene sostituito al richiamo stesso della funzione; il valore maggiore tra A e B compare cioè al posto di massimo(A, B).
da 8 a 14 Definizione della funzione per la determinazione del massimo tra due valori.
8 Al nome della funzione seguono i parametri su cui la funzione lavora, che vengono sostituiti dai valori A e B al momento del richiamo della funzione stessa.
da 9 a 13 Struttura condizionale per il confronto tra A e B e la determinazione del maggiore dei due.
10 e 12 Il nome della funzione è una variabile dove viene memorizzato il risultato della funzione.

Programma in Basic


  10   REM Calcolo del massimo di due numeri

  20   DEF FNMASSIMO (X, Y)
  30        IF X > Y THEN
  40             FNMASSIMO = X
  50        ELSE
  60             FNMASSIMO = Y
  70        END IF
  80   END DEF

  90   REM Programma principale
 100        PRINT "Inserire il primo valore"
 110        INPUT A
 120        PRINT "Inserire il secondo valore"
 130        INPUT B
 140        PRINT "Il valore maggiore è ";
       FNMASSIMO(A, B)
 150   END

da 20 a 80 Definizione della funzione; la definizione precede il programma che la richiama altrimenti a riga 140 si cercherebbe di richiamare qualcosa che non è definito, causando quindi un errore. T possibile definire la funzione anche con l'istruzione FUNCTION e in questo caso è possibile codificare prima il programma principale e poi la funzione, facendo però precedere il programma principale dalla dichiarazione della funzione con l'istruzione DECLARE, come visto per le subroutine nel programma precedente.
20 Il nome della funzione è preceduto da DEF FN e seguito dalla lista dei parametri, tra parentesi.
40 Il risultato viene memorizzato nella variabile identificata dal nome della funzione preceduto da FN.
80 Le funzioni terminano con l'istruzione END DEF.
da 90 a 150 Programma principale.
140 Richiamo della funzione; la funzione viene richiamata con il nome preceduto da FN e seguito dalla lista dei parametri tra parentesi.


+----------------------------------------------------------------+
¦ Esempi di esecuzione                                           ¦
¦                                                                ¦
¦ Inserire il primo valore                                       ¦
¦ ? 450                                                          ¦
¦ Inserire il secondo valore                                     ¦
¦ ? 1237                                                         ¦
¦ Il valore maggiore è  1237                                     ¦
+----------------------------------------------------------------+

Commenti
Una funzione non è mai indispensabile, può sempre essere sostituita da una subroutine; per esempio in questo caso è possibile sostituire la funzione MASSIMO con la subroutine


max(X, Y, MASSIMO)
     se X > Y allora
          massimo = X
     altrimenti
          massimo = Y
    fine se
fine procedura

dove X e Y sono parametri di input e MASSIMO è il parametro di output.

IL TRASFERIMENTO DEL CONTROLLO

Altre istruzioni per il trasferimento del controllo sono RUN e CHAIN.
L'istruzione RUN permette di avviare l'esecuzione di un programma, specificando eventualmente il punto del programma da cui partire.

RUN [{numeroriga|file$]

numeroriga è la riga da cui partire del programma corrente; file$ invece è il nome di un file contenente un programma sorgente in Basic da eseguire; prima di avviare l'esecuzione questa istruzione chiude i file che al momento si trovano aperti e libera la memoria.
L'istruzione CHAIN invece permette di trasferire il controllo ad un altro programma ma senza chiudere i file aperti.

CHAIN file$

File$ contiene il nome del programma da eseguire.

L'ISTRUZIONE COMMON E LE VARIABILI GLOBALI

Le variabili definite in un modulo (sottoprogramma o funzione) sono locali a quel modulo, cioè sono definite soltanto all'interno del modulo stesso e non sono utilizzabili all'esterno.
L'istruzione COMMON permette di definire variabili globali, cioè comuni a tutto il programma.
Chiudi

Outlet Offerte Sconti Promozioni Risparmiare sugli Acquisti di prodotti e Servizi in Internet

Gigacenter Store-Vente privee-Show room prive-La ruota della fortuna-Outlet Più Style-Offerte Outlet Store-Sconti Outlet Offerte-Spartoo Shoes-Private Outlet-Saldi Privati-Sold Outlet-Offerte del GiornoBuoni sconto-Saldi Sconti-Offerte Viaggio-Acquisti + Guadagni

 

eXTReMe Tracker

Shiny Stat

free counters