Main Introduzione alla programmazione in Visual Basic for applications. Una guida per imparare a programmare

Introduzione alla programmazione in Visual Basic for applications. Una guida per imparare a programmare

Questo testo vuole essere una guida per chi affronta per la prima volta
lo studio di un linguaggio di programmazione. Saper programmare non vuol
dire solo conoscere la sintassi di un linguaggio: è necessario, infatti, sapere
come funziona la macchina che si utilizza, avere nozioni di logica e di
matematica, conoscere gli algoritmi fondamentali per la soluzione delle
principali classi di problemi. Soprattutto, è indispensabile avere creatività e
inventiva, necessarie per affrontare con metodo problematiche complesse di
qualsiasi natura. L’apprendimento di un linguaggio di programmazione è
comunque un primo passo fondamentale ed essenziale.
Si è scelto di utilizzare il linguaggio Visual Basic for Applications,
evoluzione del BASIC, in quanto risulta essere più semplice di altri linguaggi
più potenti e versatili quali il linguaggio C o Java e inoltre gli strumenti di
sviluppo di cui necessita sono di facile reperibilità: è infatti presente un
interprete VBA in ogni applicazione della diffusissima suite di Microsoft
Office (Word, Excel ecc.). La versione professionale è oggi uno dei linguaggi
più utilizzati per sviluppare applicazioni commerciali, anche in ambito Internet.
Essendo questo libro rivolto ai principianti della programmazione,
verranno introdotte le sole istruzioni di base (ad esempio non si sono incluse
nella trattazione le istruzioni relative ai file ad accesso casuale, agli oggetti, alle
classi). Ciò non deve apparire come elemento riduttivo: nell’apprendimento
iniziale della programmazione si ritiene più importante rivolgere l’attenzione
alla logica della costruzione e alla correttezza dell’algoritmo impiegato
piuttosto che identificare il metodo migliore e la sua codifica più “elegante” e
veloce. Una volta acquisita la capacità di programmare, imparare gli aspetti più
evoluti del linguaggio (o anche un altro linguaggio) è solo questione di studio e
non presenta particolari difficoltà.
Year:
2007
Edition:
2 rev.2
Publisher:
CELID
Language:
italian
Pages:
220
ISBN 10:
8876616101
ISBN 13:
9788876616105
Series:
Strumenti per l'ingegneria
File:
PDF, 894 KB
Download (pdf, 894 KB)
 
You can write a book review and share your experiences. Other readers will always be interested in your opinion of the books you've read. Whether you've loved the book or not, if you give your honest and detailed thoughts then people will find new books that are right for them.
CLAUDIO FORNARO

INTRODUZIONE
ALLA PROGRAMMAZIONE
IN VISUAL BASIC
FOR APPLICATIONS
Una guida per imparare a programmare
Seconda edizione
con esercizi svolti
Rev 2

ii

INDICE

iii

INDICE
INDICE ............................................................................................................ iii
Prefazione alla seconda edizione ....................................................................vii
1

Introduzione ............................................................................................... 1
1.1
Linguaggi e traduttori ......................................................................... 1
1.2
L’ambiente di sviluppo ....................................................................... 3
1.3
Costruzione dell’interfaccia grafica ................................................... 5

2

Un primo esperimento............................................................................... 9
2.1
Esercizi ............................................................................................. 15

3

Variabili e tipi numerici .......................................................................... 17
3.1
Variabili numeriche .......................................................................... 18
3.1.1 Espressioni numeriche ...................................................................... 20
3.1.2 Valutazione delle espressioni numeriche ......................................... 20
3.1.3 Principali funzioni di conversione di tipo ........................................ 23
3.1.4 Funzioni intrinseche ......................................................................... 25
3.1.5 Precedenza e associatività degli operatori ........................................ 25
3.1.6 Costanti numeriche ........................................................................... 26
3.2
Esercizi ............................................................................................. 28

4

Input/Output da tastiera e su video ...................................................; .... 29
4.1
L’istruzione MsgBox ........................................................................ 29
4.2
L’istruzione InputBox ...................................................................... 31
4.3
Esercizi ............................................................................................. 32

5

Esecuzione condizionale .......................................................................... 33
5.1
Il costrutto If-Then ........................................................................... 33
5.2
Espressioni relazionali ...................................................................... 38
5.3
Espressioni logiche ........................................................................... 39

iv

INDICE
5.3.1 Operatore Or..................................................................................... 39
5.3.2 Operatore And .................................................................................. 39
5.3.3 Operatore Xor................................................................................... 40
5.3.4 Operatore Not ................................................................................... 40
5.4
Precedenza degli operatori ............................................................... 40
5.5
Il costrutto Select Case ..................................................................... 41
5.6
Esercizi ............................................................................................. 44

6

Le stringhe ............................................................................................... 47
6.1
Variabili stringa ................................................................................ 48
6.2
Operazioni sulle stringhe.................................................................. 49
6.3
Funzioni sulle stringhe ..................................................................... 50
6.3.1 Len.................................................................................................... 50
6.3.2 Left ................................................................................................... 50
6.3.3 Right ................................................................................................. 50
6.3.4 Mid ................................................................................................... 51
6.3.5 Instr .................................................................................................. 51
6.3.6 Altre funzioni sulle stringhe ............................................................. 52
6.4
Confronti tra stringhe ....................................................................... 54
6.5
Esercizi ............................................................................................. 56

7

Salti incondizionati .................................................................................. 57

8

Esecuzione ciclica .................................................................................... 59
8.1
Il ciclo For-Next ............................................................................... 60
8.2
Esercizi ............................................................................................. 64
8.3
Il ciclo Do-Loop ............................................................................... 66
8.4
Esercizi ............................................................................................. 70

9

Vettori e matrici ...................................................................................... 73
9.1
Matrici .............................................................................................. 75
9.2
Vettori e matrici di tipo stringa ........................................................ 76
9.3
Esercizi ............................................................................................. 76

10
I file ...................................................................................................... 79
10.1 Aprire e chiudere un file .................................................................. 80
10.2 Scrivere in un file ............................................................................. 82
10.3 Leggere da un file............................................................................. 83
10.4 Esercizi ............................................................................................. 87

INDICE

v

11
I sottoprogrammi e la programmazione modulare .......................... 89
11.1 Le funzioni........................................................................................ 92
11.2 Le subroutine .................................................................................... 93
11.3 Argomenti e parametri formali ......................................................... 94
11.3.1
Passaggio degli argomenti ........................................................ 95
11.4 Variabili statiche............................................................................... 99
11.5 Variabili non locali ......................................................................... 100
11.6 Inizializzazione delle variabili ........................................................ 101
11.7 La ricorsione ................................................................................... 101
11.8 Esercizi ........................................................................................... 104
12
Tipi di dati composti ......................................................................... 107
12.1 Esercizi ........................................................................................... 109
13
Alcuni altri controlli Visual Basic.................................................... 111
13.1 Le Label .......................................................................................... 111
13.2 Le TextBox ..................................................................................... 111
13.3 Gli OptionButton ............................................................................ 114
13.4 Le CheckBox .................................................................................. 115
13.5 Abilitare e nascondere i controlli ................................................... 116
14
Suggerimenti per una buona programmazione ............................. 117
14.1 Variabili implicite ........................................................................... 117
14.2 Indentazione del codice .................................................................. 117
14.3 I commenti ...................................................................................... 118
15

Debugging .......................................................................................... 119

16

Esercizi riassuntivi ............................................................................ 121

17
Un esempio di Macro VBA per Excel.............................................. 129
17.1 Commento del codice ..................................................................... 132
18
Soluzione degli esercizi ..................................................................... 135
18.1 Capitolo 2 ....................................................................................... 135
18.2 Capitolo 3 ....................................................................................... 136
18.3 Capitolo 4 ....................................................................................... 138
18.4 Capitolo 5 ....................................................................................... 138
18.5 Capitolo 6 ....................................................................................... 143
18.6 Capitolo 8 ....................................................................................... 149

INDICE

vi
18.7
18.8
18.9
18.10
18.11

Capitolo 9 ....................................................................................... 162
Capitolo 10 ..................................................................................... 173
Capitolo 11 ..................................................................................... 184
Capitolo 12 ..................................................................................... 195
Capitolo 16 ..................................................................................... 197

Prefazione alla seconda edizione

vii

Prefazione alla seconda edizione
Questo testo vuole essere una guida per chi affronta per la prima volta
lo studio di un linguaggio di programmazione. Saper programmare non vuol
dire solo conoscere la sintassi di un linguaggio: è necessario, infatti, sapere
come funziona la macchina che si utilizza, avere nozioni di logica e di
matematica, conoscere gli algoritmi fondamentali per la soluzione delle
principali classi di problemi. Soprattutto, è indispensabile avere creatività e
inventiva, necessarie per affrontare con metodo problematiche complesse di
qualsiasi natura. L’apprendimento di un linguaggio di programmazione è
comunque un primo passo fondamentale ed essenziale.
Si è scelto di utilizzare il linguaggio Visual Basic for Applications,
evoluzione del BASIC, in quanto risulta essere più semplice di altri linguaggi
più potenti e versatili quali il linguaggio C o Java e inoltre gli strumenti di
sviluppo di cui necessita sono di facile reperibilità: è infatti presente un
interprete VBA in ogni applicazione della diffusissima suite di Microsoft
Office (Word, Excel ecc.). La versione professionale è oggi uno dei linguaggi
più utilizzati per sviluppare applicazioni commerciali, anche in ambito Internet.
Essendo questo libro rivolto ai principianti della programmazione,
verranno introdotte le sole istruzioni di base (ad esempio non si sono incluse
nella trattazione le istruzioni relative ai file ad accesso casuale, agli oggetti, alle
classi). Ciò non deve apparire come elemento riduttivo: nell’apprendimento
iniziale della programmazione si ritiene più importante rivolgere l’attenzione
alla logica della costruzione e alla correttezza dell’algoritmo impiegato
piuttosto che identificare il metodo migliore e la sua codifica più “elegante” e
veloce. Una volta acquisita la capacità di programmare, imparare gli aspetti più
evoluti del linguaggio (o anche un altro linguaggio) è solo questione di studio e
non presenta particolari difficoltà.
Il testo è pensato come supporto per corsi brevi di introduzione alla
programmazione a livello universitario. Si rivolge anche agli autodidatti, i
quali, non potendo in genere disporre di un’interazione con un docente,
cercano nel testo le risposte alle loro domande. Anche a tal scopo sono
proposti numerosi esercizi corredati da una soluzione.

viii
Rispetto alla precedente, questa nuova edizione vede la rielaborazione
di alcune parti in una forma espositiva più chiara, la correzione di errori, alcuni
esercizi aggiuntivi nei vari capitoli e un nuovo capitolo di esercizi riassuntivi.
Un sentito ringraziamento va al professor Marco Mezzalama del
Politecnico di Torino per la revisione critica del testo.
Torino, gennaio 2004
Claudio Fornaro

Introduzione

1
1.1

1

Introduzione
Linguaggi e traduttori

Lo scopo di scrivere un programma è sostanzialmente quello di “spiegare” ad
un calcolatore quali operazioni debba eseguire per risolvere un problema.
Per indicare ad un calcolatore le operazioni che esso deve svolgere, bisogna
utilizzare un linguaggio che sia conosciuto sia dalla persona (opportunamente
istruita) che impartisce gli ordini sia dal calcolatore che li deve eseguire. Con
un linguaggio noto ad entrambi, la persona comunica alla macchina l’attività
che essa deve svolgere, ossia la programma: da cui il termine linguaggio di
programmazione.
I linguaggi naturali delle due entità, uomo e calcolatore, sono assai diversi tra
loro, l’uno si esprime mediante parole (“somma 2 e 5”), per l’altro esistono
solo sequenze di zeri e uno (la parola uno è indeclinabile!) Più in dettaglio, il
microprocessore (ossia la CPU) conosce un solo linguaggio chiamato
linguaggio macchina (o codice macchina): ogni sequenza di zeri e uno ha un
significato ben preciso per la CPU, ad esempio la sequenza 1011010 potrebbe
significare “calcola la somma”. Se una persona volesse richiedere a quel
calcolatore di fare una somma, dovrebbe impartirgli il comando 1011010, se
volesse un’altra operazione dovrebbe informarsi (su un manuale) su quale sia
la traduzione di questa in linguaggio macchina per poi poterla impartire.
Chiaramente si tratta di soluzione assai complessa e lunga da attuare, per
questo sono stati introdotti linguaggi di programmazione evoluti molto simili al
linguaggio naturale (in particolare all’inglese). Tali linguaggi, dei quali il
Visual Basic è un esempio, sono detti di alto livello.
La traduzione di programmi scritti in linguaggio evoluto nel corrispondente
codice macchina binario è effettuata da speciali programmi detti traduttori. Il
programmatore usa un traduttore per convertire l’istruzione “calcola la
somma”, il traduttore traduce l’istruzione in 1011010 e quando questo codice
macchina 1011010 viene passato al microprocessore esso “capisce” che cosa si
vuole ed esegue la somma. Un programma non è niente altro che una sequenza
di comandi, detti più propriamente istruzioni, espresse in un dato linguaggio di
programmazione. Il file contenente queste istruzioni costituisce il programma
sorgente (o codice sorgente).

2

Capitolo 1

Esistono sostanzialmente due modi di realizzare un traduttore:
 mediante un compilatore;
 mediante un interprete.
Un compilatore traduce in una volta sola tutto il programma sorgente e lo
memorizza in un file detto programma eseguibile (o codice eseguibile); in
ambiente Microsoft si tratta di file con estensione .EXE o .COM. Per eseguire
il programma è sufficiente “lanciare” il file eseguibile (ad esempio con un
doppio click sul suo nome in ambiente Windows), mentre il programma
sorgente non è richiesto per l’esecuzione del programma.
Un interprete invece traduce una per volta ciascuna istruzione del programma
sorgente in linguaggio macchina, non memorizza il risultato della traduzione in
un file, ma lo fa eseguire immediatamente al microprocessore e poi la cancella.
Il ciclo di esecuzione di un programma interpretato è quindi:
1) leggi un’istruzione
2) traducila in linguaggio macchina
3) invia l’istruzione tradotta al microprocessore perché la esegua
immediatamente
4) riparti da 1) per leggere la successiva istruzione dal programma sorgente
Questo significa che se un’istruzione deve essere eseguita più volte, ogni volta
verrà tradotta in linguaggio macchina.
Confrontando i due metodi possiamo fare le seguenti considerazioni:
 attuare la traduzione una volta per tutte permette di avere un programma
molto più veloce in fase di esecuzione;
 mandare in esecuzione un programma compilato è molto semplice (in
genere basta un doppio click sull’icona del programma), mentre in genere
solo un programmatore può attivare un programma interpretato, in quanto
deve conoscerne l’interprete;
 l’utente di un programma compilato (il cosiddetto utente finale) non deve
disporre di costosi strumenti di sviluppo quali sofisticati traduttori per
mandare in esecuzione il programma;
 l’utente di un programma compilato non può modificare il programma
stesso in quanto non dispone del codice sorgente (questo è normalmente
richiesto per questioni di copyright);
 ogni volta che, durante la fase di sviluppo del programma, viene modificato
il codice sorgente, il compilatore deve tradurre di nuovo da capo tutto
quanto o parte del codice sorgente (questo può richiedere una discreta
quantità di tempo), mentre per un interprete non è necessario.
Riassumendo, un interprete può essere più comodo per sviluppare un
programma. La maggior parte dei linguaggi di programmazione è solo
compilata, ossia non è stato per essi sviluppato un interprete; altri, come il

Introduzione

3

Visual Basic, hanno sia interpreti sia compilatori. In particolare, in ciascuno
dei programmi di Microsoft Office è presente un interprete Visual Basic for
Applications (VBA), mentre si può acquistare un compilatore Visual Basic
(non for Applications) sempre della stessa ditta. Esistono differenze tra Visual
Basic e Visual Basic for Applications, ma dal punto di vista della filosofia del
linguaggio cambia poco e il passaggio dall’uno all’altro non è complesso. Nel
seguito, per brevità, quando non indicato diversamente, si utilizzerà il termine
Visual Basic intendendo con questo la versione for Applications.

1.2

L’ambiente di sviluppo

L’ambiente integrato di sviluppo di Visual Basic (detto Integrated
Development Environment, più brevemente IDE) permette essenzialmente al
programmatore di scrivere codice Visual Basic e di eseguirlo, mettendo a
disposizione un elevato numero di strumenti di gestione del programma, di
controllo e verifica del codice. Per attivarlo è necessario avviare uno dei
programmi di Microsoft Office, ad esempio Excel, selezionare dal menu
Strumenti la voce Macro e quindi scegliere Visual Basic Editor (tutto ciò
si ottiene anche premendo la combinazione di tasti Alt-F11). Si presenta una
schermata come quella indicata nella figura seguente. Se vi è una segnalazione
relativa alla sicurezza, selezionare Strumenti/Macro/Protezione dal menu e
impostare il valore su Medio. Chiudere Excel e riattivarlo.
Si notino le due finestre sulla sinistra: una reca informazioni sul progetto a cui
Barra dei
menu
Finestra
progetto

Finestra delle
proprietà

Barra degli
strumenti

4

Capitolo 1

si sta lavorando (finestra Progetto) e, sotto, l’altra mostra un elenco di
proprietà (finestra Proprietà). Se mancano, selezionare il menu Visualizza e
quindi le voci finestra Progetto o finestra Proprietà. Utilizzeremo spesso
queste finestre e ne parleremo diffusamente in seguito. Sotto il titoletto della
finestra vi è la cosiddetta barra dei menu, tramite la quale si accede a tutti i
comandi (della maggior parte ovviamente non sappiamo ancora nulla); tra
questi i più utili sono i seguenti:
o File per aprire, salvare e stampare file;
o Modifica per le operazioni di Copia, Incolla, Annulla (annulla l’ultima
modifica apportata), Cerca, Sostituisci ecc.
o Visualizza per mostrare altre finestre quali quella delle Espressioni di
controllo e la Finestra Immediata per le operazioni di debug e per
ripristinare la finestra Progetto e la finestra Proprietà se le abbiamo chiuse;
o Formato per assistere il programmatore nello sviluppo dell’aspetto grafico
(allineare e rendere uguali i controlli ecc.);
o Debug per assistere nella ricerca degli errori (ne tratteremo adeguatamente
in un capitolo specifico);
o Esegui per eseguire, interrompere e fermare un programma;
o Strumenti per modificare e personalizzare l’ambiente di sviluppo (ad
esempio per aggiungere nuovi controlli e scegliere le opzioni che ci
interessano;
o ? per richiedere l’help on line: un grosso e completo database di
informazioni con utili esempi di programmazione. A riguardo è importante
sottolineare che durante l’installazione del pacchetto Office deve essere
stato indicato il Visual Basic for Applications Help.
Sotto la barra dei menu si trova la barra degli strumenti, contenente i pulsanti
che consentono di eseguire rapidamente operazioni di programmazione
comuni, quali l’aggiunta di un nuovo modulo, il copia e incolla, l’annulla,
l’esegui ecc. Si può accedere agli stessi comandi anche tramite la barra dei
menu, ma in modo molto meno comodo e veloce. Vedremo l’utilizzo di questi
bottoni all’occorrenza.

Introduzione

1.3

5

Costruzione dell’interfaccia grafica

Il Visual Basic produce programmi con interfaccia grafica, ossia ogni
programma avrà almeno una finestra grafica dove inserire i dati e leggerne i
risultati. Anche noi dovremo “aprire una finestra” sullo schermo per i nostri
programmi. Dopo aver attivato l’ambiente VBA (ad esempio quello di Excel)
come indicato precedentemente, facciamo click sul bottone
(in alto a
sinistra nella barra degli strumenti). Otteniamo quello che viene riportato nella
figura seguente.

Form

Si è aperta una finestra bianca contenente un’altra finestra, costituita da un
pannello grigio puntinato detto form. Quest’ultimo sarà la finestra principale
di ogni nostro programma, ossia quella che verrà
visualizzata quando il programma verrà mandato in
esecuzione.
Il form può essere ridimensionato
trascinando i quadratini bianchi che lo circondano.
Dopo questa operazione, nella finestra Progetto
vediamo che, rispetto a prima, è stata aggiunta una
voce denominata UserForm1. Questa identifica il
form che abbiamo aggiunto e tutto il codice di

6

Capitolo 1

programmazione ad esso relativo. Ogni volta che aggiungiamo un form (o un
modulo come vedremo più avanti), questo viene riportato in questa finestra.
Per rimuovere un elemento da questa finestra è sufficiente fare un click su di
esso con il bottone di destra del mouse e selezionare la voce di cancellazione.
Attenzione che sia le impostazioni grafiche sia il codice di programmazione
relativo a quel form vengono perduti.
Il form così generato è completamente vuoto, vi aggiungeremo molti altri
oggetti (in particolare per raccogliere dati e per visualizzarli) detti controlli o
controls: oltre alle due finestre di cui sopra si è aperta anche un’altra piccola
finestra sulla sinistra (copre in parte la finestra Progetto) contenente appunto
gli oggetti che possiamo aggiungere alla nostra interfaccia, detta casella dei
controlli o degli strumenti. Se questa non compare, premere il pulsante
presente sulla destra della barra degli strumenti. Gli oggetti presenti sono solo
una parte di quelli possibili, nella casella
vengono inizialmente elencati solo i
principali. Per conoscere il nome di un
certo controllo riportato nella casella dei
controlli basta posizionare il cursore su di
esso e aspettare un paio di secondi: il
sistema mostrerà il nome del controllo
stesso in un riquadro giallo (nell’esempio si
tratta del controllo Pulsante di Comando).
Si seleziona il controllo voluto facendo click
e lo si colloca sulla finestra nella posizione prescelta disegnando (ossia
trascinando il mouse tenendo premuto il bottone di sinistra) un rettangolo.
Mettiamo ad esempio una scritta sul form. Selezioniamo dunque il controllo
Label (ha come icona una A) facendo click sulla A stessa. Si noti che il
puntatore del mouse non ha più la forma di una freccia, ma assume quella di
una crocetta con accanto una A. Posizioniamo la crocetta nell’angolo in alto a
sinistra del form (un po’ più a destra e un po’ più sotto), facciamo click con il
bottone sinistro del mouse e teniamolo premuto, trasciniamo il puntatore del
mouse per un paio di centimetri verso destra e uno verso il basso, quindi
rilasciamo il bottone. Viene creato un
riquadro contenente la scritta Label1
(vedasi la figura a destra). Abbiamo
appena collocato un’etichetta (in inglese
label ) e il sistema le ha assegnato un
nome generico che deriva dal suo tipo, in
questo caso il nome è Label1.

Introduzione

7

Si noti che il controllo ora posizionato è
incorniciato in modo evidente: questo significa
che è l’elemento attualmente selezionato, ossia
quello su cui si può intervenire per modificarlo.
La dimensione del controllo attualmente
selezionato può essere modificata trascinando
uno di quegli otto quadratini bianchi che fanno
parte del riquadro circostante il controllo stesso:
quelli sui lati permettono di modificare una sola
delle due dimensioni (altezza o larghezza), quelli
agli angoli entrambe contemporaneamente. In
tutti e due i casi si nota che la forma del
puntatore del mouse cambia per assumere la
forma di una freccia a due punte. Si può spostare
il controllo selezionato trascinando uno dei lati
del riquadro (ma non ci si posizioni sui
quadratini altrimenti lo si ridimensiona), la forma
del puntatore del mouse in questo caso cambia in una doppia freccia a crocetta.
Spostiamo la casella dei controlli sulla destra in modo da poter vedere
interamente la finestra Proprietà. Questa elenca le proprietà dell’elemento in
quel momento selezionato, nel nostro caso contiene la scritta Label1.
Per cambiare la scritta Label1 in un’altra, dobbiamo identificare tra le proprietà
del controllo Label1 quella di nome Caption (in italiano “didascalia”), questa
si trova nella colonna di sinistra. Trovatala, notiamo che sulla sua destra c’è
appunto la scritta Label1 (la didascalia è inizialmente uguale al nome
dell’oggetto per poter agevolmente identificare quest’ultimo sul form).
Cambiamo la caption facendo un doppio click su di essa e scrivendo al posto di
Label1 un’altra scritta: Sottrattore; premiamo infine il tasto INVIO.
La procedura per cambiare le altre proprietà è simile a questa. Proviamo ad
esempio a collocare un bottone al centro del form (impareremo a far sì che
premendo questo bottone il programma svolga una certa elaborazione).
Selezioniamo il controllo Pulsante di comando (ha l’aspetto di un rettangolo
in rilievo, si veda la figura dei Controlli alla pagina precedente) e, così come
abbiamo fatto per la Label sopra, ora disegniamo
un bottone e gli assegniamo come Caption la
dicitura Calcola. Al bottone creato il sistema
assegna il nome CommandButton1.
Ora
utilizzando la proprietà Font sia della Label sia del
Bottone cerchiamo di ottenere un form come
quello della figura a destra.

8

Capitolo 1

Per avere più controlli dello stesso tipo è possibile ogni volta ripetere la
procedura vista, ma se i controlli devono essere tutti uguali è possibile, dopo
aver selezionato un controllo, crearne più copie identiche mediante la solita
procedura di Copia e Incolla: si seleziona un oggetto e dal menu Modifica si
seleziona Copia, poi si seleziona Modifica/Incolla tante volte quante è
necessario. Automaticamente il sistema genera controlli identici, con le stesse
proprietà (anche la Caption), ma di nome diverso; così se si copia il controllo
Label1 con Caption XYZ e lo si incolla tre volte si ottengono tre oggetti di
nome Label2, Label3 e Label4, ma tutti con Caption XYZ. I nuovi
oggetti appena generati devono comunque essere posizionati opportunamente
sul form, talvolta vengono copiati uno sopra l’altro e non ci se ne accorge.
Nel caso sia necessario rimuovere un oggetto è sufficiente selezionarlo con il
bottone di destra del mouse e scegliere Rimuovi dal menu che viene mostrato.
Per cambiare la stessa proprietà a più oggetti è possibile selezionarli tutti
facendo click sugli oggetti tenendo premuto sulla tastiera il tasto Control. Può
essere utile talvolta selezionare gli oggetti disegnando intorno ad essi un unico
rettangolo con il mouse, come per mettere un controllo che li riunisca tutti,
questa volta però non si deve selezionare alcun controllo.
Per allineare e formattare più controlli uguali è possibile selezionarli tutti e
utilizzare i comandi del menu Strumenti.
È importante infine ricordare la presenza di un esteso sistema di aiuto (help) in
linea, raggiungibile mediante il menu Help o premendo il tasto F1.
Quest’ultimo fornisce un help diverso a seconda del contesto, ossia se si sta
impostando una proprietà e si preme F1 viene attivata la sezione di help
relativa agli oggetti, se si sta programmando viene attivata la sezione relativa
alle istruzioni Visual Basic e così via. Data la vastità, non è sempre facile
ottenere le informazioni che si cercano, soprattutto le prime volte che se ne fa
uso spesso sono necessari vari tentativi. Da ultimo, l’help non è pensato per
insegnare a programmare, ma per fornire dettagli tecnici completi relativi ad un
argomento, ossia è pensato nell’ottica di chi sa già programmare. Per questo
all’inizio sarà piuttosto ostico e non molto utile, ma acquisendo conoscenze
sarà in seguito di grande aiuto.

Un primo esperimento

2

9

Un primo esperimento

Per cominciare, proveremo con qualcosa di molto semplice: vogliamo un
programma Visual Basic che chieda di introdurre due valori e ne visualizzi la
differenza.
La sequenza delle operazioni da far eseguire al calcolatore sarà:
1)
2)
3)
4)

Chiedi il primo numero
Chiedi il secondo numero
Calcola la differenza tra il primo numero e il secondo numero
Visualizza il risultato

Le operazioni andranno ovviamente eseguite nell’ordine in cui sono state
scritte. Raffiniamo il nostro programma. Innanzitutto, i numeri che vengono
chiesti dove vengono memorizzati? Dobbiamo predisporre alcuni “contenitori”
per numeri, “scatolette” dove possiamo riporre i valori, prelevarli quando ci
serve, sostituirli con altri. Queste “scatolette” si chiamano variabili, a ciascuna
scatoletta assegneremo un nome per poter distinguere le une dalle altre. Nel
nostro esempio chiamiamo X e Y le scatolette rispettivamente del primo e del
secondo valore. Allora il nostro programma diventa:
1)
2)
3)
4)

Chiedi il primo numero e mettilo in X
Chiedi il secondo numero e mettilo in Y
Calcola X - Y
Visualizza il risultato

Anche il risultato della differenza di X e Y deve essere memorizzato in una
variabile, chiamiamola D. Dopo questo passo il programma diventa:
1)
2)
3)
4)

Chiedi il primo numero e mettilo in X
Chiedi il secondo numero e mettilo in Y
Calcola X - Y e metti il valore in D
Visualizza D

Capitolo 2

10

Cerchiamo di esprimere le quattro istruzioni nel modo più schematico
possibile, senza inutili verbosità. Innanzi tutto togliamo i numeri iniziali: è
abbastanza ovvio che le istruzioni verranno eseguite dalla macchina nell’ordine
in cui sono state scritte. Otteniamo:
Chiedi X
Chiedi Y
X - Y  D
Visualizza D
È chiaro che non scriveremo le istruzioni in modo informale e in italiano come
fatto sopra, ma useremo un linguaggio comprensibile sia per l’interprete Visual
Basic sia per noi, schematico, essenziale e di significato univoco (non ci sono
due o più significati diversi per una sequenza di comandi, come invece può
avvenire nel linguaggio umano).
Vediamo la fase di input. In Visual Basic uno dei modi per chiedere un dato
all’utente è quello di aprire un’altra finestrella con una scritta che indica che
cosa si vuole venga introdotto e contenente lo spazio per poterci digitare i
valori, questa finestrella viene creata per mezzo dell’istruzione InputBox
(letteralmente “scatola di input” – “input” significa “introdurre”, “put”
“mettere” e “in” “dentro”). Allora l’istruzione “Chiedi X ” diventerà:
X = InputBox("Dammi il primo valore")
Quando l’interprete eseguirà questa riga di codice, verrà dunque mandata in
esecuzione la funzione InputBox. Questa visualizzerà una finestrella con la
scritta Dammi il primo valore e un bottone con la scritta OK, poi il programma
si metterà in attesa che questo bottone OK venga premuto (figura sotto).
Premuto questo, il valore che l’utente ha scritto nella finestrella viene messo
nella variabile X (è il segno di uguale che fa questo).

Un primo esperimento

11

La stessa cosa sarà fatta per il secondo valore.
Y = InputBox("Dammi il secondo valore")
La terza riga è quella dove il calcolo viene effettuato, un semplice simbolo di
uguale fa sì che il risultato dell’espressione presente a destra del segno di
uguale venga posto (assegnato) nella (alla) variabile D:
D = X - Y
Si noti che la variabile D è a sinistra del segno di uguale e il calcolo da eseguire
sulla destra, questa istruzione si chiama assegnazione. Il simbolo = non sta a
indicare un’uguaglianza, piuttosto lo si può interpretare come “assume il valore
di”, quindi: “D assume il valore del risultato di X – Y”.
Anche per la visualizzazione abbiamo diverse possibilità: una di queste
consiste nell’indicare quello che vogliamo “stampare” (termine del gergo
informatico comunemente usato con il significato di “visualizzare”) in una
nuova finestrella (questa volta di output – “out” significa “fuori” e “put”
“mettere”). In Visual Basic ciò si ottiene per mezzo dell’istruzione MsgBox
(letteralmente “scatola con messaggio”):
MsgBox D
La variabile D è ciò che vogliamo visualizzare (più
precisamente ci interessa il suo contenuto). Questa istruzione
produce una finestrella come quella indicata a lato.
Ricapitolando, le quattro righe del nostro programma sono diventate finalmente
vero e proprio codice Visual Basic che l’interprete è in grado di comprendere.
Eccole riunite (i numeri di riga non servono, l’interprete sa che deve eseguire le
istruzioni nell’ordine in cui sono scritte):
X = InputBox("Dammi il primo valore")
Y = InputBox("Dammi il secondo valore")
D = X - Y
MsgBox D
Dove scriviamo queste righe perché il programma possa leggerle ed eseguirle?
Ci sono moltissime soluzioni, adottiamone una che già abbiamo visto: un form
con un bottone al centro, premendo il quale le istruzioni di cui sopra vengono
eseguite. Allora creiamo il form di cui abbiamo già detto nel capitolo
precedente e che aveva questo aspetto:

12

Capitolo 2

Dobbiamo innanzitutto fare una piccola digressione per introdurre un concetto
importante: quello di evento. Con i linguaggi di programmazione come il
BASIC, il Fortran, il C ecc. di norma il programmatore scrive un programma e
questo viene eseguito immediatamente dal sistema, il programma si mette in
attesa solo quando è previsto che debba ricevere un input dall’utente. Nei
linguaggi come il Visual Basic invece, di norma, il programma esegue
(eventualmente) alcune istruzioni iniziali e poi si mette sempre in attesa di
ricevere eventi. In base all’evento ricevuto si esegue una parte di programma
piuttosto che un’altra. Tutto il sistema è gestito tramite eventi (anche un
sistema operativo come Windows funziona per mezzo di eventi).
Ma che cos’è un evento? Lo si può paragonare ad un segnale che informa che
un qualcosa si è verificato. Questo qualcosa può essere di vario tipo: la
pressione di un tasto della tastiera, un click del mouse, lo spostamento del
mouse ecc. In realtà ogni evento ha un livello di dettaglio molto maggiore, si
consideri ad esempio una finestrella come la seguente:

Un click sul bottone Sì, un click sul bottone No o uno sul bottone Annulla
generano eventi di tipo click, ma deve esserci qualcosa che li differenzi tra loro
per poter sapere dove il click è stato fatto.
In un sistema pilotato dagli eventi, ad ogni evento deve essere associata una
porzione di programma (detta subroutine) che svolge un compito ben preciso,
nell’esempio sopra, azioni diverse devono essere intraprese a seconda di quale
bottone venga premuto.
Torniamo al nostro programma di calcolo. Abbiamo capito che il codice Visual
Basic scritto sopra deve costituire la subroutine che risponde all’evento click
effettuato su CommandButton1. Per associare il codice al bottone facciamo
un doppio click sul bottone stesso: si apre una finestra che ha una riga iniziale
e una finale già scritte, tra queste collochiamo le nostre quattro righe. Il tutto
dovrebbe presentarsi come la figura seguente:

Un primo esperimento

13

La riga iniziale:
Private Sub CommandButton1_Click()
è composta di alcune parti (trascuriamo Private): Sub sta per subroutine e
indica che questa è una subroutine, ossia un insieme isolato di righe di codice;
CommandButton1 indica che si tratta della subroutine associata proprio a
quel bottone, Click() specifica che la subroutine in questione risponde
all’evento Click sul bottone dal mouse.
Prima di far funzionare il nostro programma, è bene salvarlo su disco. Per fare
questo si va nel menu File e si sceglie Salva (o Save). Questo non solo salva
il nostro programma, ma anche la cartella Excel da cui siamo partiti (o il
documento Word se siamo partiti da questo). In particolare, il nostro
programma è una parte del file Excel (o Word) e non ne è separabile. Excel o
Word chiama Macro questo codice, Macro sta per Macroistruzioni: si tratta di
comandi che l’utente crea per sé e che vengono aggiunti alle funzionalità del
programma stesso. Ad esempio si può scrivere una macro di Word (e avere il
relativo bottoncino tra quelli di Word) che trasforma in un colpo solo il testo
selezionato in Arial, corsivo, 12 punti, rosso su sfondo viola, cosa che se fatta
ogni volta a mano richiederebbe parecchie manovre e tempo. Se abbiamo
attivato il Visual Basic da Excel possiamo mandare in esecuzione il nostro
programma, se invece lo abbiamo attivato da Word dobbiamo prima chiudere
Word, riavviarlo e riaprire il documento: ora Word ci chiede se si vogliono
abilitare le Macro e dobbiamo rispondere affermativamente. A questo punto il
nostro programma può essere eseguito anche da Word.
Mandiamo dunque in esecuzione il nostro programma: in alto al centro vi sono
tre icone:
da sinistra a destra il loro significato è: Esegui, Sospendi,
Termina; quindi per eseguire il nostro programma facciamo click sul
triangolino (o premiamo il tasto F5).
Il programma ora è in esecuzione (si dice in gergo che sta “girando”). Ci
presenta la nostra finestra con il bottone Calcola e attende. Che cosa? Eventi!
In realtà l’unico evento che sa intercettare è quello relativo alla pressione del

14

Capitolo 2

bottone (quelli per i quali non c’è una subroutine di gestione vengono
semplicemente ignorati). Premiamo quindi il bottone Calcola ed ecco che la
prima delle InputBox viene eseguita generando una finestrella e chiedendo
di introdurre il primo valore; scriviamo un numero. La finestrella di input non
scompare finché non premiamo il bottone OK. Quando lo facciamo
l’esecuzione riprende dalla riga successiva, infatti appare la finestrella della
seconda InputBox; introdotto il secondo valore e premuto OK il programma
passa alla riga successiva, quella dove si trova la sottrazione e l’assegnazione
del risultato alla variabile D. Questa istruzione non coinvolge l’utente (non è
un’operazione di input/output) e quindi non se ne nota l’esecuzione. Dopo
averla eseguita il programma passa alla successiva dove la MsgBox visualizza
la finestrella con il risultato D. Quando premiamo il tasto OK la finestrella con
il risultato scompare e il programma ritorna ad aspettare eventi. Per terminare
oppure facciamo click sulla
il programma premiamo il bottone Termina
in alto a destra della finestra del nostro programma. Normalmente, però, tutti i
programmi hanno un bottone di uscita, ad esempio con caption End o FINE.
Come esercizio si crei il summenzionato bottone posizionandolo sotto l’altro e
mettendo nella sua subroutine di gestione la sola istruzione End che appunto
termina il programma. Se le cose sono state fatte bene la subroutine dovrebbe
chiamarsi CommandButton2_Click() e la subroutine avere 3 righe (delle
quali il nostro contributo è solo la End. Si ricordi che per modificare un
programma è necessario che questo sia stato precedentemente fermato (se non
si riescono a modificare le istruzioni di un programma, di solito ci si è
semplicemente dimenticati di fermarne l’esecuzione).
Si possono mettere più istruzioni Visual Basic su una stessa riga separandole
con il carattere due punti:
D = X – Y : MsgBox D
ma è meglio evitare a favore di una maggior chiarezza.
Più utile, invece, è poter continuare una riga lunga a capo: basta aggiungere il
carattere “_” preceduto da uno spazio alla fine della riga da continuare a capo e
appunto continuare la riga a capo. Si può andare a capo in ciascun punto dove
si può collocare uno spazio, ma non si può spezzare su più righe una stringa (si
scoprirà più avanti che cos’è una stringa). Ad esempio, invece di scrivere:
X = InputBox("Primo valore", "Valore", "0")
si può scrivere:
X = InputBox("Primo valore", _
"Valore", "0")
ma attenzione che non si può andare a capo dopo Primo perché lo spazio fa
parte di una stringa (è dentro i doppi apici).

Un primo esperimento

2.1

15

Esercizi

1) Scrivere un programma Visual Basic che chieda 3 numeri A, B e C dalla
tastiera e visualizzi in MsgBox diverse: A – B, A – C e A – B – C.
2) Scrivere un programma Visual Basic che chieda 2 numeri A e B dalla
tastiera, scambi il contenuto delle due variabili e li visualizzi. Ad esempio
se ad A viene assegnato il valore 12 e a B il valore 27, il programma deve
far sì che il 12 venga scambiato con il 27 (in altre parole inizialmente A
contiene 12 e B 27, dopo lo scambio A deve contenere 27 e B 12). Non si
risolva questo problema semplicemente visualizzando i valori delle
variabili in ordine inverso: lo scopo non è visualizzare due numeri in ordine
inverso, ma di scambiare il contenuto di due variabili. La struttura del
programma dovrà quindi essere questa:
A = InputBox("Introduci A")
B = InputBox("Introduci B")
qui si scrivono le istruzioni di scambio valori
MsgBox A
MsgBox B

16

Capitolo 2

Variabili e tipi numerici

3

17

Variabili e tipi numerici

Si è detto che le variabili sono “contenitori” di numeri; più correttamente
dovremmo dire che sono contenitori di dati: i numeri sono solo un esempio di
dati. I nomi delle variabili in Visual Basic sono lunghi al massimo 256
caratteri, 1 come minimo; il primo carattere deve essere una lettera, i successivi
possono essere sia lettere sia cifre sia il carattere di sottolineatura. È buona
norma dare alle variabili nomi significativi del contenuto: sarà più semplice
sviluppare e correggere il codice. Non si possono usare nomi che il Visual
Basic già conosce, quali ad esempio InputBox, MsgBox, e molte altre
(vengono chiamate keyword del linguaggio). È preferibile usare nomi che
iniziano con una lettera minuscola. Nomi validi sono ad esempio i seguenti:
A
i
somma
sommaAlQuadrato
somma_2
sommaElevato2
In Visual Basic le lettere maiuscole e quelle minuscole sono considerate
uguali: per questo le variabili SOMMA e soMmA sono la stessa cosa.
Una variabile può essere usata come operando in un’operazione matematica
(ad es. X + Y) o per ricevere un valore per mezzo di un’operazione di
assegnazione (ad es. S = 3 + 5). Si noti che il simbolo di eguaglianza
assume un significato diverso da quello usualmente assunto in matematica:
A=B in matematica è un’equazione che indica che A ha lo stesso valore di B.
In Visual Basic (come nella maggior parte dei linguaggi di programmazione)
A=B indica che dopo l’esecuzione dell’istruzione A=B, A assume il valore che
aveva B (e che continua ad avere, è una copia di valore, non un trasferimento).
Così mentre A=A+1 in matematica è un assurdo, in programmazione significa
che A, dopo l’esecuzione di questa istruzione, viene incrementata di uno.
Le variabili non hanno solo un nome, ma anche un tipo. Ossia ci sono variabili
adatte a contenere numeri interi, variabili adatte a contenere numeri con la

Capitolo 3

18

virgola, variabili adatte a contenere una qualsiasi sequenza di caratteri (sono
dette stringhe e ce ne occuperemo più avanti), variabili adatte a contenere i
valori vero e falso (dette logiche o booleane), variabili speciali adatte a
contenere qualsiasi tipo di dato (dette variant). Ne esistono anche altri tipi, ma
non vengono qui considerati.
A ciascuna delle variabili utilizzate in un programma, l’interprete Visual Basic
deve assegnare un tipo appropriato, questa operazione si ottiene esplicitamente
mediante la dichiarazione (o definizione) delle variabili. Questa operazione
riserva (alloca) memoria per contenerne il valore. In genere le variabili
vengono dichiarate tutte quante all’inizio (subito dopo la Private Sub). Se
una variabile non viene dichiarata esplicitamente, il suo tipo viene stabilito
dall’interprete in modo generico: il tipo Variant. Si sconsiglia vivamente di
utilizzare il modo implicito e il tipo Variant: può avere comportamenti
“strani” (o meglio non previsti, ne vedremo un esempio in seguito) e
soprattutto, salvo poche eccezioni, indica che il programmatore non ha le idee
chiare sull’uso che farà della variabile.
L’istruzione Dim viene utilizzata per dichiarare una variabile:
Dim Nome As Tipo
essendo Nome il nome della variabile e Tipo il tipo da associarle.

3.1

Variabili numeriche

In Visual Basic si dispone di 2 tipi di variabili intere e di 2 tipi di variabili
reali; le variabili intere sono memorizzate in Complemento a 2, quelle reali in
formato floating point IEEE P754 (mantissa ed esponente).
I due tipi interi sono Integer e Long, i due reali sono Single e Double.
Una variabile Integer occupa 2 byte di memoria e può contenere valori
interi compresi tra –32768 e +32767 (circa ±30000).
Una variabile Long (intero lungo) occupa 4 byte di memoria e può contenere
valori interi compresi tra –2147483648 e +2147483647 (circa ±2 miliardi); una
variabile Long può contenere tutti i valori che può contenere una variabile
Integer.
Una variabile Single (singola precisione) occupa 4 byte di memoria e può
contenere valori compresi tra (circa) 1.410–45 e 3.410+38, positivi e negativi,
quindi numeri molto grandi o molto piccoli, con una precisione di circa 7 cifre
(in base 10), ad esempio –123.456710–12. Una variabile Single può
contenere tutti i valori che può contenere una variabile Long.
Una variabile Double (doppia precisione) occupa 8 byte di memoria e può
contenere valori compresi tra (circa) 4.910–324 e 1.710+308, positivi e

Variabili e tipi numerici

19

negativi, quindi numeri molto grandi o molto piccoli, con una precisione di
circa 15 cifre (in base 10), ad esempio –1234567.890123451023. Una variabile
Double può contenere tutti i valori che può contenere una variabile Single.
Una variabile Variant in realtà non è una variabile numerica, è una variabile
che può contenere valori di qualsiasi tipo, tra cui anche quelli numerici e quelli
stringa. Essa utilizza un numero variabile di byte a seconda del tipo di dato che
contiene, inoltre ha comportamenti particolari che devono essere ben noti al
programmatore (si provi ad esempio a modificare l’esercizio del Sottrattore
facendo una somma invece che una sottrazione, il simbolo + non esegue più
una somma, ma affianca i valori! La spiegazione è rimandata a quando si
conosceranno le stringhe, in particolare alla funzione Val descritta nel
paragrafo 6.3.6). È bene evitare questo tipo di variabile quando possibile.
I calcoli con valori floating point sono più lenti di quelli con valori interi,
inoltre più sono i bit da calcolare più il calcolo è lento; anche l’occupazione di
memoria può essere importante: una matrice di un milione di elementi occupa
2 MB se si tratta di valori Integer, 8 MB se si tratta di Double.
Riassumendo: per avere le migliori prestazioni e un minor utilizzo di memoria
è consigliabile utilizzare se possibile il tipo Integer, se non basta si usi un
Long, se non basta o servono valori con la virgola un Single e se proprio si
vogliono 15 cifre di precisione un Double.
Consideriamo ancora il tipo Boolean, una variabile di questo tipo può
contenere solo due valori: True e False, ne parleremo in seguito.
Errore comune è scrivere:
Dim A, B, C As Integer
pensando che le tre variabili siano definite tutte di tipo Integer, in realtà
solo C viene definita di tipo Integer, mentre A e B sono definite di tipo
Variant. Si potrebbe usare la seguente sintassi:
Dim A As Integer, B As Integer, C As Integer
ma non si ottiene un significativo miglioramento rispetto a:
Dim A As Integer 'coeff. a equazione 2o grado
Dim B As Integer 'coeff. b equazione 2o grado
Dim C As Integer 'termine noto eq. 2o grado
Inoltre, quando opportuno, i programmatori accanto ad ogni definizione di
variabile ne indicano l’uso mediante un commento (come nell’esempio
precedente) e la seconda modalità è più adatta per questo scopo.
Attenzione all’input dei numeri frazionari, se il sistema operativo è configurato
con lo standard italiano, si deve usare la virgola (3,1415), se con lo standard
anglosassone, si deve usare il punto decimale (3.1415).

20

Capitolo 3

3.1.1 Espressioni numeriche
I calcoli tra valori vengono chiamati espressioni, un’espressione produce un
valore e questo o viene confrontato con altri o viene stampato o viene
memorizzato in una variabile (assegnazione).
Un’espressione è composta da operatori (+,–,*,/ ecc.), da operandi, da
funzioni (Sin, Cos, Tan ecc.) e da parentesi; gli operandi possono essere
variabili o costanti numeriche.
Nell’esempio sotto, sulla destra del segno di uguale viene calcolata
un’espressione e il risultato viene assegnato alla variabile Delta:
delta = b^2–4*a*c
La tabella seguente elenca gli operatori numerici del Visual Basic.
Operazione
Simbolo
+
somma
–
sottrazione
*
prodotto
/
divisione
\
divisione intera
Mod
Resto
^
Elevamento a potenza
Note:
1) la divisione tra valori interi produce un valore frazionario (3/2 dà 1.5),
diversamente da altri linguaggi di programmazione;
2) la divisione intera e il resto si possono applicare anche a valori frazionari,
ma in questo caso gli operandi vengono prima arrotondati all’intero più
vicino e il risultato viene poi troncato al valore intero precedente (5.4 \ 2.6
viene visto come 5 \ 3 e produce come risultato 1 e non 1.666667);
3) il Mod si usa come fosse un simbolo: X = 17 Mod 5 calcola il resto
della divisione di 17 per 5 e il risultato prodotto (2) viene messo in X;
4) nell’elevamento a potenza, se l’esponente è frazionario la base deve essere
positiva (3 ^ 2.2).
3.1.2 Valutazione delle espressioni numeriche
Quando viene calcolata un’espressione, i valori intermedi vengono
memorizzati temporaneamente in variabili “senza nome” (il programmatore
non ha necessità di utilizzarle direttamente, quindi non è necessario che
vengano identificate in alcun modo). Quando il calcolo è terminato i valori
intermedi (ossia le variabili senza nome) non servono più e vengono cancellati.
Si consideri ad esempio l’istruzione X=A+B*C senza considerare il tipo delle
variabili e facendo riferimento alla figura seguente.

Variabili e tipi numerici

21

Come prima operazione viene calcolato il
X = A + B * C
prodotto B*C e il risultato viene messo in una
variabile senza nome (che per identificare in
questo esempio indichiamo con ), il

contenuto di questa variabile viene sommato
ad A e il risultato messo in una seconda
variabile senza nome (), il contenuto di questa

seconda variabile viene copiato in X e le due
variabili senza nome vengono cancellate.
Di che tipo sono le variabili senza nome che il sistema si gestisce da sé?
Quando un’operazione è relativa a due valori (variabili o costanti) dello stesso
tipo, il risultato dell’operazione (e quindi la variabile senza nome) è dello
stesso tipo dei due operandi. Quindi se le variabili A, B e C dell’esempio
precedente sono tutte Integer, anche  e  lo sono (della variabile X
parleremo più avanti).
Se invece i due valori sono di tipo diverso, il valore del tipo meno “capiente”
viene prima convertito (promozione) automaticamente nel tipo più “capiente”
(indicando con questo termine il fatto che un Long può contenere un
Integer, un Single può contenere un Long o un Integer, un Double
può contenere un Single, un Long o un Integer). La promozione crea
una variabile temporanea senza nome del tipo più capiente dei due e vi copia il
valore della variabile promossa (ad esempio, quando si sommano un Integer
e un Single, dall’Integer in complemento a 2 si calcola il valore
corrispondente in floating point (di tipo Single) e solo dopo si può calcolare
la somma). Attenzione: la variabile promossa continua ad essere del tipo che
era prima della promozione, dimensionata con Dim, è la variabile temporanea
che ha un altro tipo, anche se ha lo stesso valore. Il calcolo viene poi effettuato
utilizzando questa variabile temporanea e non quella originale. Riprendiamo
l’esempio precedente, ora sono indicati anche i
X = AS + BS * CI
tipi delle variabili mediante una lettera in alto
a destra delle variabili stesse: una I indica che
il tipo della variabile è Integer, S che il tipo
S
è Single.
La prima operazione da eseguire è la
moltiplicazione B*C, ma le due variabili sono
S
di tipo diverso: B è Single e C è Integer.
Tra i due tipi il più capiente è il Single per
cui viene creata una variabile temporanea  di
S
questo tipo per contenere il valore di C.

22

Capitolo 3

Viene quindi effettuata la moltiplicazione tra B e  (che contiene il valore di C)
e il risultato ha il tipo di entrambe, ossia Single. La successiva operazione è
la somma di  con A, ma avendo entrambe le variabili lo stesso tipo (Single)
non c’è bisogno di promozione e la variabile intermedia  ha anch’essa il tipo
Single. Alla fine  viene copiata in X (della variabile X parleremo tra poco)
e le variabili intermedie vengono eliminate. Un esempio numerico: A valga
5.2, B valga 2.1 e C valga 3. La promozione calcola un  pari a 3.0, la
moltiplicazione calcola 2.1*3.0 producendo un  pari a 6.3 e la somma produce
un  pari a 11.5 .
La promozione dei valori in un’espressione avviene automaticamente solo nel
momento in cui questa è necessaria; si consideri l’esempio seguente.
o La prima operazione da calcolare è il
X = AS + BI * CI
prodotto B*C; essendo le due variabili di
tipo Integer, il risultato  è un valore
I
temporaneo di tipo Integer.

o Il risultato  deve essere sommato ad A che
è di tipo Single, quindi prima di fare la
somma,  deve essere trasformato in un
S
altro valore temporaneo  di tipo Single.
o Viene quindi fatta la somma di  e A, il
S
risultato  è di tipo Single e viene

copiato in X.
Attenzione al caso seguente:
Dim A As Integer, B As Integer, C As Long
A=30000
B=2
C=A*B
Nonostante C possa contenere il valore 60000 perché di tipo Long, il
programma dà errore di overflow (traboccamento) perché A e B sono di tipo
Integer e il loro prodotto è dello stesso tipo (la variabile temporanea), ma
60000 non è rappresentabile su un Integer. Non importa che C sia un Long
in quanto è il risultato del calcolo che dà overflow, non l’assegnazione a C
(non si arriva neanche all’assegnazione: l’errore avviene prima). Come
risolvere questo problema? Ci sono diversi metodi, tra cui i seguenti.
1) Si definisce almeno una delle due variabili di tipo Long e non Integer,
così grazie alla promozione dell’altra, il tipo di quella temporanea è
anch’esso Long e il risultato non dà overflow.

Variabili e tipi numerici

23

2) Si chiede esplicitamente al traduttore di convertire almeno uno dei valori in
Long. Per far questo dobbiamo usare una funzione di conversione, così
facendo ci si riconduce al caso precedente. Questo secondo metodo
permette al programmatore di non dover cambiare il tipo prescelto per le
variabili (la scelta dei tipi delle variabili è dettata da esigenze che il
programmatore ha valutato in fase di studio del programma) e per questo è
preferibile. Alla fine del paragrafo successivo si trova la soluzione del
problema seguendo questa modalità.
3.1.3 Principali funzioni di conversione di tipo
Creano variabili temporanee del tipo richiesto, aventi come valore quello
indicato tra parentesi.
Int(A) converte il valore di A in Integer (o meglio crea una variabile
temporanea di questo tipo) troncando la parte decimale, restituisce il
valore intero più a sinistra (inteso sulla retta dei numeri reali);
+3.2  +3
+3.6  +3
–3.2  –4
–4 –3.6 –3.2 –3
0
3 3.2 3.6 4
–3.6  –4
Fix(A) converte il valore di A in Integer troncando la parte decimale,
restituisce il valore intero più vicino allo zero;
+3.2  +3
+3.6  +3
–4 –3.6 –3.2 –3
0
3 3.2 3.6 4
–3.2  –3
–3.6  –3
CInt(A)converte il valore di A in Integer approssimandolo al valore
intero più vicino (arrotondamento);
+3.2  +3
+3.6  +4
–3.2  –3
–4 –3.6 –3.2 –3
0
3 3.2 3.6 4
–3.6  –4
Per questioni statistiche, i valori x.5 (positivi e negativi) vengono
approssimati al valore:
- successivo se x è dispari,
- precedente se x è pari
CInt(1.5)
 2
CInt(2.5)
 2
CInt(–1.5)
 –2
CInt(–2.5)
 –2

24

Capitolo 3

CLng(A) converte il valore di A in Long (stesse considerazioni di Cint)
CSng(A) converte il valore di A in Single
CDbl(A) converte il valore di A in Double
Ecco il secondo modo di risolvere il problema dell’overflow indicato nel
paragrafo precedente:
C = A * CLng(B)
oppure
C = CLng(A) * B
oppure
C = CLng(A) * CLng(B)
Ma scrivere:
C = CLng(A*B)
è assolutamente inutile: è il calcolo che produce overflow e non
l’assegnazione; qui il calcolo viene comunque effettuato su variabili Integer
dando errore.
Quando si assegna ad una variabile il risultato di un’espressione, viene attuata
automaticamente una conversione al tipo della variabile stessa (questo avviene
anche nel passaggio dei parametri alle funzioni e subroutine). La funzione di
conversione utilizzata automaticamente è una di queste: CInt, CLng, CSng o
CDbl. Si consideri l’esempio seguente:
Dim A As Single
Dim X As Integer
A = 2.342
X = A
qui l’assegnazione viene eseguita come se fosse scritta:
X = CInt(A)
Si noti che diversamente da altri linguaggi, l’assegnazione di un valore reale ad
una variabile intera non tronca la parte frazionaria, ma la approssima all’intero
più vicino (con il problema dell’approssimazione dei valori x.5 già
considerato). Se si vuole troncare si devono usare le funzioni Int e Fix.
Esistono molte altre funzioni di conversione, ai nostri scopi queste sono
sufficienti.

Variabili e tipi numerici

25

3.1.4 Funzioni intrinseche
Sono funzioni fornite dal linguaggio stesso, ossia programmate dagli
sviluppatori dell’interprete. Le funzioni intrinseche accettano espressioni di
tipo diverso e in generale restituiscono un Double.
Alcune funzioni matematiche che è utile conoscere sono le seguenti:
Funzione
Significato
Sin(A)
seno di A
Cos(A)
coseno di A
Tan(A)
tangente di A
Atn(A)
arcotangente di A
Log(A)
logaritmo naturale di A
Log10(A) logaritmo in base 10 di A
Exp(A)
e elevato ad A
Abs(A)
valore assoluto di A
Sqr(A)
radice quadrata di A
Sgn(A)
segno di A: –1 se negativo, 0 se nullo, +1 se positivo
Note:
1) le funzioni trigonometriche richiedono angoli espressi in radianti
(1  rad = 180°);
2) la funzione Sgn restituisce un Variant e non un Double.
Per maggiori dettagli su queste funzioni si consulti la guida in linea.
Si possono utilizzare per ricavare il valore delle costanti, ad es. =4*Atn(1)
3.1.5 Precedenza e associatività degli operatori
Un’espressione può contenere diversi operatori e il risultato può dipendere
dall’ordine di valutazione degli operatori. Ad esempio A+B*C produce un
certo risultato se viene calcolato prima il prodotto e poi la somma, ma
produrrebbe un risultato diverso se venisse calcolata prima la somma e poi il
prodotto. Viene chiaramente eseguito prima il prodotto e poi la somma (si dice
che il prodotto ha priorità o precedenza maggiore rispetto alla somma) in
quanto il linguaggio è stato progettato in modo Parentesi
da essere conforme alle regole aritmetiche Funzioni
classiche. Nella tabella a fianco sono riportati
Potenza
gli operatori in ordine di priorità decrescente.
Moltiplicazione, divisione
Le parentesi (sempre e solo tonde, mai quadre
Divisione intera
o graffe) possono essere utilizzate per forzare
la valutazione delle espressioni nel modo Resto
voluto, ad esempio se vogliamo che venga Somma e sottrazione

26

Capitolo 3

prima fatta la somma e poi la moltiplicazione possiamo scrivere (A+B)*C.
Nelle espressioni gli stessi operatori possono essere utilizzati più volte e alcuni
operatori hanno lo stesso livello di precedenza (somma e sottrazione,
moltiplicazione e divisione), ecco alcuni esempi:
A–B+C
A*B/C
A*B*C
A–B–C
A^B^C
In questo caso l’ordine di valutazione degli operatori è stabilito dalle regole di
associatività: in Visual Basic è sempre da sinistra a destra per tutte le
operazioni (incluso l’elevamento a potenza, diversamente da altri linguaggi).
Quindi le cinque espressioni sopra vengono valutate come se ci fossero le
parentesi indicate nelle cinque espressioni qui sotto:
(A–B)+C
(A*B)/C
(A*B)*C
(A–B)–C
(A^B)^C
3.1.6 Costanti numeriche
Nelle espressioni si utilizzano non solo variabili, ma spesso anche valori
costanti, ad esempio l’area di un triangolo verrà calcolata con l’espressione
BASE*ALTEZZA/2, il 2 è una costante numerica. Anche le costanti
numeriche hanno un tipo:
 una costante intera è una sequenza di cifre senza virgola né esponente, è di
tipo Integer se il valore è compatibile con tale tipo, altrimenti è un
Long; esempi di costanti Integer sono 1234, –23438; esempi di costanti
Long sono 123456, –234567;
 una costante floating point è una sequenza di cifre con un punto decimale
(non si usa la virgola decimale nel codice Visual Basic) e/o un esponente
(valore intero positivo o negativo), è di tipo Single se il numero di bit è
sufficiente, Double altrimenti; esempi di costanti floating point di tipo
Single sono –1234.625, 23.0, 34E4 (che significa 34104), –23.625E–18
(che significa –23.62510–18); esempi di costanti floating point di tipo
Double sono –12345.6789012121, –12.4 (0.4 in binario è periodico!),
34E204 (che significa 3410204), –23.4E–18 (che significa –23.410–18).

Variabili e tipi numerici

27

È possibile indicare il tipo che si desidera per una costante aggiungendo al
numero stesso un carattere speciale:
 esempio di costante Integer:
12%
 esempio di costante Long:
12&
 esempio di costante Single:
12!
 esempio di costante Double:
12#
Quindi l’espressione A*12! moltiplica A per una costante Single di valore
12 (anche se non c’è l’indicazione di alcun decimale).
Ecco un esempio in cui è utile definire il tipo delle costanti. Si supponga ad
esempio di voler calcolare l’area di un milione di triangoli, note basi e altezze
come valori Single, se la formula usata è B*H/2, la costante 2 è considerata
Integer e ogni volta il traduttore ne deve effettuare la promozione a
Single, un milione di volte! Se invece la formula è B*H/2!, il 2 è già di
tipo Single e quindi non si ha il milione di promozioni. Si poteva anche
utilizzare la scrittura 2.0 (è un valore di tipo Single anche in questo caso).
Talvolta è utile dare un nome ad una costante, ecco come si definiscono una
costante Single di nome PiGreco e una costante Double di nome
hPlank (non possono essere espressioni aritmetiche):
Const PiGreco As Single = 3.1415926
Const hPlank As Double = 6.626176E-34

Capitolo 3

28

3.2

Esercizi

1) Scrivere un programma Visual Basic che chieda all’utente di introdurre 4
valori di tipo intero e ne calcoli la media (risultato di tipo reale).
2) Scrivere un programma Visual Basic che chieda all’utente di introdurre un
valore di temperatura (di tipo intero) in gradi Fahrenheit e calcoli e
“stampi” (cioè visualizzi) i corrispondenti valori in gradi Celsius e Kelvin
(entrambi di tipo reale). [C=5/9*(F–32); K=C+273.15].
3) Un oggetto che si muove ad una velocità v confrontabile con quella della
luce c (2.99793ꞏ108 m/s) si accorcia (nel senso della direzione) e aumenta
di massa di un fattore  (minore di 1). Si scriva un programma che chieda la
lunghezza e la massa di un oggetto fermo e calcoli la
2
v
variazione delle due grandezze a quella velocità (richiesta   1   
c
in input in km/s).
4) Si scriva un programma per calcolare la distanza in linea d’aria tra due
punti della superficie terrestre, note le coordinate geografiche. Il
programma chiede i valori di latitudine (N-S) e di longitudine (E-O) in
gradi dei due punti. Per calcolare la distanza si usi la seguente formula (le
coordinate Nord e Est sono positive, Sud e Ovest negative e si ricordi che
le funzioni trigonometriche utilizzano i radianti):

d  arccos( p1  p2  p3)  r

dove:
r è il raggio medio della Terra: 6372.795 km
p1 = cos(lat1)*cos(lon1)*cos(lat2)*cos(lon2)
p2 = cos(lat1)*sin(lon1)*cos(lat2)*sin(lon2)
p3 = sin(lat1)*sin(lat2)
essendo:
lat1 latitudine in gradi del primo punto
lon1 longitudine in gradi del primo punto
lat2 latitudine in gradi del secondo punto
lon2 longitudine in gradi del secondo punto
N.B. La formula considera la terra sferica con raggio medio r: non
essendolo, la formula dà un risultato con un errore massimo dello 0.5%.
Per la formula del arco-coseno si utilizzi la formula seguente:
 x  

arccos( x)  arctan
2 
 1 x  2
Calcolare le distanze tra gli aeroporti di: Torino (TRN, 45.02ºN, 07.65ºE),
Roma (FCO, 41.81ºN, 12.25ºE) e Los Angeles (LAX, 33.94ºN, 118.40ºW).
[TRN-FCO: 515.20 km, TRN-LAX: 9692.7 km, FCO-LAX: 10205.48 km]

Input/Output da tastiera e su video

4

29

Input/Output da tastiera e su video

Il punto di vista di un’operazione di input/output (I/O) è sempre quello del
microprocessore, quindi un’operazione di input (che significa “mettere
dentro”) consiste nel prelevare un valore dall’esterno (dalla tastiera ad
esempio) e memorizzarlo in una variabile; mentre un’operazione di output (che
significa “mettere fuori”) consiste nel mandare all’esterno un valore (ad
esempio sul video). Questo capitolo fornisce ulteriori informazioni sulle già
note istruzioni InputBox e MsgBox. Esistono in Visual Basic molte altre
istruzioni di Input/Output, ma queste sono le essenziali e più semplici, anche se
non certo le migliori in ogni circostanza. Altra possibilità è costituita dalle
TextBox descritte nel paragrafo 13.1.

4.1

L’istruzione MsgBox

L’istruzione MsgBox viene usata per visualizzare in una finestrella il valore di
una variabile, o più in generale il risultato di un’espressione, indicata tra
parentesi. La sua sintassi più in dettaglio (anche se non nella sua completezza)
è la seguente (le parentesi possono anche essere omesse, comunque si noti la
posizione della parentesi di chiusura):
MsgBox (prompt), buttons, title

prompt è ciò che verrà visualizzato, title è il titoletto della finestrella, buttons
serve per indicare che nella finestrella non vogliamo solo il bottone OK, ma
anche altri. Non considereremo i bottoni.
Alcuni esempi. MsgBox 12 visualizza il numero 12, MsgBox 3*X
visualizza il risultato del calcolo 3*X. Per visualizzare una scritta (ossia una
sequenza di caratteri, detta stringa), questa deve essere racchiusa tra doppi
apici: MsgBox "Ciao".
Che cosa sarebbe successo se non avessimo messo i doppi apici? Il traduttore
Visual Basic avrebbe considerato Ciao come il nome di una variabile; non
avendola mai incontrata prima (non essendo stata dichiarata con Dim) la
definirebbe ora in modo implicito, quindi di tipo Variant, e vuota. Quindi la
MsgBox ne mostrerebbe il contenuto, vuoto, visualizzando una finestrella

30

Capitolo 4

assolutamente vuota. Scopriremo nell paragrafo 14.1 come evitare questo
problema con la direttiva Option Explicit.
Poiché la MsgBox vuole un unico prompt, per visualizzare più elementi
affiancati nella stessa finestrella li si unisce per mezzo dell’operatore &
(attenzione a mettere sempre uno spazio sia prima sia dopo il carattere &):
MsgBox "Ci sono " & X & " valori"
In questo esempio si hanno due sequenze di caratteri (stringhe): la prima è
composta dai caratteri “Ci sono ”, la seconda da “ valori”; supponendo
che X contenga il valore 10, l’istruzione MsgBox visualizzerà nella finestrella:
Ci sono 10 valori
Si notino gli spazi dopo sono e prima di valori: se non li avessimo messi,
avremmo ottenuto la scritta:
Ci sono10valori
La MsgBox converte in stringa ciò che si trova nel campo prompt, anche i
valori numerici (dopo aver calcolato le espressioni). Anche l’operatore & che
unisce le stringhe (si dice che le concatena) trasforma in stringa tutto ciò che
gli sta accanto (la X dell’esempio precedente è valore di tipo numerico, quale
un Integer, ma viene trasformato nella sequenza di caratteri 1 e 0).
Sia title sia buttons possono essere omessi, come nel primo esperimento del
Sottrattore; ma per indicare solo title e omettere buttons si deve scrivere come
segue (attenzione alle due virgole che indicano di saltare il campo dei buttons,
inoltre si noti la posizione delle parentesi – che si possono anche omettere):
MsgBox "Ci sono " & X & " valori",, "Conteggio"
E l’output generato è indicato nella figura sotto, a sinistra, dove Conteggio è
il titoletto (title).
Se volessimo stampare su più righe, dovremmo indicare i punti di ritorno a
capo all’interno del prompt stesso. I punti di ritorno a capo si indicano con
vbNewLine, si tratta di una stringa costante definita dal sistema. Quindi per
scrivere su tre righe la scritta precedente, dovremmo scrivere (tralasciamo il
titoletto per esigenze tipografiche):
MsgBox "Ci sono" & vbNewLine & X & vbNewLine & "valori"
vbNewLine è una stringa che quando viene visualizzata fa andare a capo,
dovendola concatenare si devono usare i caratteri &. Il risultato generato è
indicato nella figura sotto, a destra.

Input/Output da tastiera e su video

4.2

31

L’istruzione InputBox

Una delle istruzioni di input da tastiera è la già nota InputBox; la sua sintassi
più in dettaglio (anche se non nella sua completezza) è la seguente (le parentesi
non possono essere omesse):
variabile = InputBox(prompt, title, default)
L’esecuzione di questa istruzione fa sì che sul video venga visualizzata una
finestrella con la scritta indicata dal prompt (è una stringa e quindi può essere
composta da altre stringhe concatenate insieme con l’operatore di
concatenazione &). Il sistema si ferma in attesa che un valore venga introdotto
e venga quindi premuto il bottone OK. Premuto il bottone OK, il valore scritto
alla tastiera viene collocato temporaneamente in una variabile di tipo stringa e
questo subito copiato nella variabile indicata. title serve per mettere un
titoletto alla finestrella; default è la risposta tipica da mettere nel campo di
introduzione dei dati, se va bene l’utente preme semplicemente OK, se non va
bene l’utente la cancella e scrive altro. Esempio:
X = InputBox("Primo valore", "Valore", "0")
Quando il programma eseguirà la funzione InputBox verrà visualizzata la
finestrella indicata nella figura sotto, si è supposto che il primo valore sia
spesso uno zero così il default è stato impostato appunto a 0, se non va bene,
l’utente lo cambierà.

Nomenclatura: default significa mancanza, in informatica un default è un
qualcosa che viene automaticamente utilizzato se non viene specificato di
usare qualcos’altro. I valori di default di un programma sono quelli che
vengono da esso utilizzati se l’utente non indica altri valori. Ad esempio,
quando si fa partire Word per scrivere un nuovo documento, il sistema
imposta di default (ossia automaticamente perché non gli abbiamo ancora
richiesto altro) un carattere di tipo Times New Roman 10 punti. Se ci va
bene lo usiamo, altrimenti lo cambiamo (ossia specifichiamo ben precisi
valori, non usiamo più quelli di default).
Come già detto, l’input dei numeri frazionari, se il sistema operativo è
configurato con lo standard italiano, richiede di usare la virgola (3,1415), se
con lo standard anglosassone, richiede di usare il punto decimale (3.1415).

Capitolo 4

32

Poiché l’istruzione InputBox produce una stringa, quando si vuole leggere
un valore numerico ed assegnarlo ad una variabile numerica (come
nell’esempio) la stringa prodotta viene dapprima implicitamente interpretata
dalla funzione Val (vedere 6.3.6 a pag. 52) per ricavarne il valore numerico e
questo a sua volta convertito da una delle funzioni di connversione CInt,
CLong, CSng e CDbl (con il problema dell’approssimazione dei valori x.5 già
considerato).

4.3
1)

Esercizi
Scrivere un programma che chieda 4 numeri interi da tastiera e li
visualizzi uno sotto l’altro nella stessa MsgBox.

Esecuzione condizionale

5

33

Esecuzione condizionale

Finora abbiamo visto programmi composti da sequenze di istruzioni da
eseguirsi una dopo l’altra nell’ordine in cui sono scritte nel programma.
Spesso invece si ha la necessità di eseguire alcune istruzioni solo in determinati
casi e altre istruzioni in altri casi. Ad esempio se si vuole calcolare la radice
quadrata di un numero, si deve prima verificare che il numero sia positivo o
nullo, altrimenti non si può calcolarla. Si parla di esecuzione condizionale: si
eseguono alcune operazioni solo SE una certa condizione è verificata.

5.1

Il costrutto If-Then

Il costrutto principale di esecuzione condizionale è il costrutto If-Then:
If condizione Then
istruzioni
End If

SE (If) la condizione è vera ALLORA (Then) vengono eseguite le istruzioni
che seguono fino alla End If; se invece la condizione non è vera le istruzioni
non vengono eseguite. In entrambi i casi l’esecuzione prosegue poi con le
istruzioni dopo la End If. Si noti che il Then deve essere l’ultima istruzione
della riga dove c’è l’If. Il blocco di istruzioni la cui esecuzione dipende da
condizione viene scritto rientrato (indentazione) di alcuni spazi (consigliati 3)
in modo che sia visivamente evidente.
Ecco un esempio:
F
V
numero = InputBox("Dammi un numero")
N>0
If numero > 0 Then
POS
MsgBox "Il numero è positivo"
End If
MsgBox "FINE PROGRAMMA"
In questo esempio viene richiesto un numero all’utente, se è positivo vengono
visualizzate due MsgBox con le scritte “Il numero è positivo” e
“FINE PROGRAMMA”, se è negativo o nullo la MsgBox interna all’If non
viene eseguita e si ha solo la seconda MsgBox con “FINE PROGRAMMA”.

34

Capitolo 5

Graficamente si può rappresentare il flusso del programma mediante lo schema
(flow chart) indicato sulla destra del codice (che in realtà rappresenta solo il
costrutto If): il rombo indica la condizione (all’interno si indica la condizione
da verificare), da esso si dipartono due rami che sono indicati con V e con F, il
ramo con la V (detto ramo then) viene percorso se la condizione è Vera, il ramo
con la F (detto ramo else) se è Falsa. Nel percorrere il ramo then si esegue
l’istruzione indicata nel parallelogramma (si usa un parallelogramma quando
l’operazione è di Input o di Output, un rettangolo se di altro tipo). Il ramo else
non contiene alcuna istruzione).
Se vogliamo che il programma scriva qualcosa anche se il numero non è
positivo, possiamo modificarlo come segue:
F
V
N>0
numero = InputBox("Dammi un numero")
If numero > 0 Then
POS
MsgBox "Il numero è positivo"
End If
If numero <= 0 Then
V
F
N0
MsgBox "Il numero non è positivo"
Non
End If
POS
MsgBox "FINE PROGRAMMA"
Il simbolo <= significa “minore o uguale”. Il flow chart corrispondente ai due
blocchi If si trova sulla destra. Il programma appena scritto funziona, ma è
migliorabile. Consideriamo le due condizioni: si nota subito che in questo caso
sono mutuamente esclusive (o il numero è positivo o non lo è). Si potrebbe
voler scrivere una sola delle condizioni, in quanto l’altra è l’opposta. Si
utilizza la clausola Else che significa altrimenti e non richiede di indicare una
condizione poiché si sa già quale sarebbe.
numero = InputBox("Dammi un numero")
F
V
If numero > 0 Then
N>0
MsgBox "Il numero è positivo"
Non
POS
Else
POS
MsgBox "Il numero non è positivo"
End If
MsgBox "FINE PROGRAMMA"
In questo esempio, se il numero è positivo la condizione della If risulta essere
vera e come prima viene scritto “Il numero è positivo”, ma se il
numero è negativo o nullo la condizione non è vera e l’esecuzione passa ad
eseguire le istruzioni dell’Else, quindi viene scritto “Il numero non è
positivo”. Alla fine viene comunque scritto “FINE PROGRAMMA”.
Questa istruzione If ha entrambi i rami contenenti istruzioni da eseguire.

Esecuzione condizionale

35

Modifichiamo ora il programma perché ci stampi “Il valore è nullo”
quando viene appunto introdotto il valore zero nella InputBox.
numero = InputBox("Dammi un numero") F
V
N>0
If numero > 0 Then
POS
MsgBox "Il numero è positivo"
End If
V
F
N<0
If numero < 0 Then
MsgBox "Il numero è negativo"
NEG
End If
If numero = 0 Then
F
V
N=0
MsgBox "Il numero è nullo"
NUL
End If
MsgBox "FINE PROGRAMMA"
Funziona, ma non è certo la soluzione migliore. Ogni If, infatti, qui ha una
condizione mutuamente esclusiva con tutte le altre, nel senso che un numero o
è positivo o è negativo o è nullo, però utilizzando questa scrittura le istruzioni
If vengono eseguite tutte e tre in ogni caso: ad esempio se un numero è
positivo viene eseguita la prima If e la MsgBox corrispondente, poi viene
eseguita la seconda If anche se logicamente non sarebbe necessario e infine
viene eseguita la terza If, anch’essa non necessaria. L’esecuzione di istruzioni
inutili è da evitarsi in quanto è una mera perdita di tempo. È vero che in un
programma come questo non ci se ne accorge, ma immaginiamo di voler
eseguire il codice precedente su 100000 valori diversi (con un ciclo, prendendo
i valori da un file, lo vedremo più avanti), allora la situazione cambia molto,
soprattutto in un linguaggio interpretato dove ogni If deve essere tradotta in
linguaggio macchina prima di essere eseguita.
Poiché una If ha soltanto due rami e non tre o più, usiamo più If una dentro
l’altra, ossia annidate.
numero = InputBox("Inserisci un numero")
If numero > 0 Then
MsgBox "Il numero è positivo""
 If esterno
Else
If numero < 0 Then
MsgBox "Il numero è negativo"  If interno
Else
MsgBox "Il numero è nullo"
End If
End If
MsgBox "FINE PROGRAMMA"

Capitolo 5

36

Se il numero è positivo, si va nel ramo then del primo If, ma se è negativo o
nullo si va nel ramo else e dobbiamo ancora verificare se è negativo o se è
nullo. Ecco che nel ramo else del primo If è stato messo un altro costrutto
If-Then-Else-End If proprio per poter discriminare i due casi: negativo
o nullo. Così facendo abbiamo minimizzato il numero di If da valutare. Si
noti che il secondo costrutto If-Then-Else-End If è completamente
(cioè dall’If all’End If) compreso in un ramo del primo.
Il flow chart corrispondente si trova nella figura seguente.
F

F

NUL

N<0

V

N>0

V

POS

NEG

Essendo questo costrutto molto frequente, il Visual Basic fornisce una struttura
alternativa utilizzando la clausola ElseIf (senza spazio in mezzo):
numero = InputBox("Dammi un numero")
If numero > 0 Then
MsgBox "Il numero è positivo"
ElseIf numero < 0 Then
MsgBox "Il numero è negativo"
Else
MsgBox "Il numero è nullo"
End If
MsgBox "FINE PROGRAMMA"
ElseIf vuol dire letteralmente altrimenti se. L’esecuzione qui avviene in
questo modo: SE il numero è positivo ALLORA stampa “Il numero è
positivo”, ALTRIMENTI SE il numero è negativo ALLORA stampa “Il
numero è negativo”, ALTRIMENTI stampa “Il numero è nullo”
in quanto è l’ultima delle 3 possibilità. La clausola ElseIf è tale per cui se la
If o ElseIf precedente è vera, essa e le successive non vengono neppure
considerate. Ossia se il numero è positivo (prima If vera) viene eseguita la
stampa “Il numero è positivo” e tutte le istruzioni successive fino alla
End If (che si noti è una sola) vengono saltate (è come se fossero in un ramo
Else). Questo secondo costrutto è assolutamente equivalente a quello con gli
If annidati.

Esecuzione condizionale

37

Ricapitolando, la forma completa di un’istruzione If è:
If condizione1 Then
istruzioni1
ElseIf condizione2 Then
istruzioni2
Else
istruzionie
End If
Le clausole ElseIf (opzionali) possono essere ripetute tante volte quante è
necessario per considerare tutti i casi, mentre la clausola Else (opzionale)
deve essere unica: è il caso che considera tutte le condizioni non espresse dalle
If precedenti e viene detto caso di default. Sono quindi leciti costrutti con più
ElseIf e senza Else: in questi casi, se nessuna delle condizioni delle If
risulta essere vera, tutta l’istruzione If-Then-ElseIf-End If non
produce alcun effetto (nessuna delle istruzionix viene eseguita), anche se,
ovviamente, tutte le condizioni delle If vengono valutate e questo consuma
tempo di elaborazione.
Si noti come è scritto il codice:
 Le parole chiave If, ElseIf, Else ed End If sono collocate alla
stessa distanza dal margine sinistro, questo serve per avere ben evidenti i
vari rami; inoltre possono essere precedute solo da spazi;
 Le parole chiave Then ed Else devono essere le ultime parole delle righe
dove compaiono; errore frequente è indicare una condizione dopo la
clausola Else: oltre a non essere l’ultima parola della riga, anche dal
punto di vista logico è sbagliato: Else indica “tutto il resto che non è stato
precedentemente considerato”, quindi è inutile specificare questo “resto”);
 I blocchi indicati con la parola istruzioni, che possono essere composti
anche di molte righe, sono spostati ulteriormente sulla destra rispetto alle
parole chiave (si dice che sono indentati) in modo che sia evidente da quale
riga ne dipenda l’esecuzione. Si veda il paragrafo 14.2 per ulteriori dettagli.
Anche se nell’esempio precedente le condizioni delle If e delle ElseIf
erano tutte relative al valore Numero, in realtà queste sono assolutamente
indipendenti tra loro, ossia possono contenere condizioni completamente
diverse. Ad esempio scriviamo un programma che chieda due numeri, se il
primo è maggiore di 10 lo stampi, altrimenti se il secondo è maggiore di 100
stampi il secondo, altrimenti (quindi se il primo è minore o uguale a 10 e il
secondo minore o uguale a 100) ne stampi il prodotto.

Capitolo 5

38

primoNumero = InputBox("Dammi il primo numero")
secondoNumero = InputBox("Dammi il secondo numero")
If primoNumero > 10 Then
MsgBox primoNumero
ElseIf secondoNumero > 100 Then
MsgBox secondoNumero
Else
MsgBox primoNumero*secondoNumero
End If

5.2

Espressioni relazionali

Le condizioni espresse nelle istruzioni If sono tipicamente confronti tra due
valori (vengono messi in relazione tra loro), ad esempio in:
If X = 10 Then ...
viene confrontata la variabile X con il valore 10, il risultato è vero se appunto X
contiene il valore 10, falso altrimenti. Più in generale il confronto avviene tra
due espressioni aritmetiche, o meglio tra i risultati prodotti da due espressioni
aritmetiche:
If X*(Y-Z^2) = Z-T*3.14 Then ...
Gli operatori di confronto, detti relazionali, sono sei:
Operatore
Uguale
Diverso
Maggiore
Maggiore o uguale
Minore
Minore o uguale

Simbolo
=
<>
>
>=
<
<=

Quindi possiamo scrivere condizioni quali le seguenti:
If X*(Y-Z^2) <= Z-T*3.14 Then ...
If area > PiGreco*raggio^2 Then ...
Ma è anche possibile utilizzare variabili di tipo Boolean:
Dim mag As Boolean
mag = area > PiGreco*raggio^2
If mag Then ...
Nella variabile mag viene posto il valore True o False a seconda che area
sia maggiore dell’area del cerchio o no. Se mag fosse stata una variabile di tipo
Integer, le sarebbero stati assegnati, rispettivamente, i valori –1 e 0 invece
di True e False. Il valore 0 in un contesto booleano viene considerato

Esecuzione condizionale

39

equivalente a False, mentre ogni altro valore a True, ma quando viene
prodotto dal Visual Basic stesso, il valore numerico di True è –1.
Poiché un qualsiasi valore non nullo viene considerato equivalente a True, in
una condizione come X<>0 la parte “<>0” può essere omessa:
If (X) Then ...

5.3

Espressioni logiche

Una condizione può essere composta da diversi confronti, per far questo
bisogna specificare quando la condizione è complessivamente vera, ad esempio
se basta che almeno uno dei confronti dia risultato vero oppure se è necessario
che tutti i confronti diano risultato vero per far eseguire il ramo Then. Più
precisamente, si usano operatori che collegano le espressioni relazionali tra di
loro: questi si chiamano operatori logici (o anche booleani).
5.3.1 Operatore Or
Se vogliamo scrivere una condizione che sia globalmente vera quando almeno
uno (ma anche più di uno) dei confronti è vero, utilizziamo l’operatore Or:
If eta <= 12 OR eta >= 65 OR giornoDelMese = 1 Then
MsgBox "Entri gratis al museo"
End If
Qui la condizione è globalmente vera se Eta è minore di 12 OPPURE Eta è
maggiore di 65 OPPURE se GiornoDelMese è uguale a 1, basta che anche
uno solo dei tre confronti (età massima di 12 anni oppure almeno 65 anni
oppure è il primo del mese) sia vero perché la condizione sia globalmente vera
e venga stampata la scritta.
5.3.2 Operatore And
Se vogliamo scrivere una condizione che sia globalmente vera solo quando
tutti i confronti sono veri, utilizziamo l’operatore And:
If voto >= 18 And voto <= 30 Then
MsgBox "Voto sufficiente"
End If
Qui solo se voto è compreso tra 18 e 30 viene scritto Voto sufficiente.
I due confronti devono essere entrambi veri (errore frequente: la variabile
voto deve essere ripetuta in ogni confronto, non si può scrivere la condizione
18 <= voto <= 30 in quanto ogni operatore relazionale deve sempre
avere due termini di confronto di sua esclusiva pertinenza – nel secondo
esempio, voto a quale relazione apparterrebbe?).

Capitolo 5

40

5.3.3 Operatore Xor
Se vogliamo scrivere una condizione che sia globalmente vera quando uno solo
di due confronti è vero (cioè non entrambi), utilizziamo l’operatore Xor
(EXOR, sta per Exclusive Or):
If X > 10 Xor Y > 10 Then
MsgBox "OK"
End If
In questo caso si ha la stampa di OK solo se X è maggiore di 10 e Y non è
maggiore di 10 OPPURE se X non è maggiore di 10 e Y è maggiore di 10. Se
entrambi o nessuno dei due è maggiore di 10 non si ha alcuna scritta in quanto
la condizione è globalmente falsa.
5.3.4 Operatore Not
L’operatore Not (negazione) serve per invertire il risultato di un confronto,
ossia trasforma il vero in falso e viceversa. Allora le due condizioni seguenti
sono equivalenti:
If X > 10 Then ...
If Not(X <= 10) Then ...
Come si vede il Not ha un solo operando e questo può essere un’espressione
relazionale complessa quanto si vuole:
Not (X > 10 Or Y < 14 And Z = 3 * X * Y)
L’espressione può eventualmente essere semplificata con il teorema di
De Morgan. Ma non sempre se ne ottiene una forma di significato altrettanto
chiaro.

5.4

Precedenza degli operatori

In una condizione vengono prima calcolate le espressioni aritmetiche,
utilizzando le regole di precedenza e associatività già indicate, poi vengono
valutate le espressioni relazionali e infine gli operatori logici. Il più prioritario
degli operatori è il Not, seguito da And, seguito da Or ed infine da Xor, così
l’esempio seguente:
If a>10 Or b>10 And c>10 Then ...
viene interpretato dalla macchina come se ci fossero le parentesi come indicato
sotto:
If a>10 Or (b>10 And c>10) Then ...
e nel caso a=20, b=0, c=0 l’And dà risultato falso (le due relazioni sono false),
ma la prima relazione è vera ed è in Or con il risultato dell’And (l’Or viene
calcolato dopo l’And), quindi complessivamente il risultato è vero. Si possono

Esecuzione condizionale

41

all’occorrenza utilizzare esplicitamente le parentesi per forzare un diverso
ordine di valutazione degli operatori logici, ad esempio in:
If (a>10 Or b>10) And c>10 Then ...
si forza prima la valutazione dell’Or e poi quella dell’And.
Altro esempio, in:
If x>0 And Not y<7 Then ...
prima viene valutato il Not applicato a y<7 e poi calcolato l’And (non
avrebbe senso altrimenti).

5.5

Il costrutto Select Case

È possibile utilizzare un costrutto If-Then-ElseIf-Else-End If in
ogni caso, ma quando il risultato di un’espressione deve essere confrontato con
più valori, il Visual Basic fornisce una soluzione ancora più chiara.
Supponiamo di voler scrivere un programma che chieda un valore intero
compreso tra 0 e 3 e scriva in lettere quanto vale il quadrato di questo valore.
Utilizzando un costrutto If si ha:
numero = InputBox("Dammi un numero tra 0 e 3")
If numero*numero = 0 Then
MsgBox "Zero"
ElseIf numero*numero = 1 Then
MsgBox "Uno"
ElseIf numero*numero = 4 Then
MsgBox "Quattro"
ElseIf numero*numero = 9 Then
MsgBox "Nove"
Else
MsgBox "Non era una numero tra 0 e 3"
End If
Si vede che in ciascuna If viene eseguito lo stesso calcolo, il quadrato di
numero, e questo viene confrontato con i possibili risultati: 0, 1, 4, 9, mentre
il caso Else, ossia quello di default, considera gli altri valori. La scelta di
confrontare il quadrato del valore con i vari risultati piuttosto che il valore
introdotto stesso con quelli previsti è solo una motivazione didattica.
Il costrutto Select Case serve proprio per questi casi, ossia quelli in cui il
risultato di un calcolo (ma potrebbe anche essere una semplice variabile) deve
essere confrontato con i possibili risultati.

42

Capitolo 5

La sintassi completa è la seguente:
Select Case espressione
Case risultato1
istruzioni1
Case risultato2
istruzioni2
ecc.
Case Else
istruzionie
End Select
Quando viene eseguita un’istruzione Select, viene calcolata, una volta sola,
l’espressione e questa produce un certo valore come risultato. Poi il risultato
viene confrontato con i risultati previsti (indicati a destra delle clausole Case)
nell’ordine in cui sono scritti. Se il risultato dell’espressione è risultato1 allora
viene eseguito l’insieme di istruzioni indicato con istruzioni1, altrimenti viene
saltato e si passa a confrontare il risultato dell’espressione con risultato2 e così
via fino all’ultimo Case risultatoi presente. Se nessuno dei risultati forniti nei
Case corrisponde a quello prodotto all’espressione, allora viene eseguito il
blocco di istruzioni della clausola Case Else (caso di default).
Ci possono essere tante clausole Case risultatoi quante se ne vuole, ma ci può
essere al massimo una sola clausola Case Else; se manca questa e nessuno
dei Case precedenti riporta il risultato dell’espressione allora nessuno dei rami
del Select Case viene eseguito e quindi tutto il costrutto non produce alcun
effetto, salvo consumare tempo di CPU. Viene eseguito al massimo uno solo
dei rami Case; inoltre, quando viene eseguito il blocco di istruzioni di un
ramo, tutto il resto della Select Case viene saltato.
Il nostro programma di prima diventa, utilizzando la Select Case:
numero = InputBox("Dammi una cifra tra 0 e 3")
Select Case numero*numero
Case 0
MsgBox "Zero"
Case 1
MsgBox "Uno"
Case 4
MsgBox "Quattro"
Case 9
MsgBox "Nove"
Case Else
MsgBox "Non era una cifra tra 0 e 3"
End Select

Esecuzione condizionale

43

espressione e risultatoi possono essere di qualsiasi tipo, quindi anche stringhe.
I risultati dell’espressione vengono indicati a destra dei singoli Case e
possono essere più complessi di quelli appena visti. Le possibilità sono le
seguenti:
Case valore
Case valore1 To valore2
Case Is > valore
Il primo caso è quello già considerato, il secondo considera tutti i valori
compresi tra valore1 e valore2 (estremi inclusi), il terzo caso considera tutti i
valori maggiori di valore. In quest’ultimo caso si possono utilizzare tutti gli
operatori di confronto (maggiore, minore, maggiore o uguale, minore o uguale,
uguale e diverso). Si noti che ciascuno dei valori può essere di qualsiasi tipo
(anche una stringa) e può essere una costante, una variabile o un’espressione:
Case 12*X-23
Case 11.4-Y To 3-Y*Z
Case Is > N^(X-Y)
Se si vogliono assegnare più risultati possibili a un singolo ramo Case, questi
si possono indicare separati da virgole (che agiscono quindi come degli Or):
Case valore1, valore2, valore3
Case valore1 To valore2, valore3 To valore4
Case Is > valore1, Is < valore2
Case valore1, valore3 To valore4, Is > valore5
Che cosa succede se gli insiemi di valori si intersecano? La prima clausola
Case che soddisfa la condizione viene eseguita e le successive vengono
saltate, anche qualora soddisfino la condizione. Un esempio:
numero = InputBox( "Dammi un numero tra 0 e 10")
Select Case numero
Case Is > 10, Is < 0
MsgBox "Non è tra 0 e 10!"
Case 2,4,6,8,10,12
MsgBox "Pari"
Case 5 To 9
MsgBox "Compreso tra 5 e 9"
Case 1,3,5,7,9
MsgBox "Dispari"
End Select

Capitolo 5

44

Se il valore introdotto è 12, la prima Case soddisfa la condizione e viene
visualizzato “Non è tra 0 e 10!”, quindi la seconda Case non viene
neanche valutata. Se il numero introdotto è 8, la seconda Case soddisfa la
condizione e quindi viene stampato “Pari”, quindi la terza Case non viene
considerata. I numeri 5, 7 e 9 non producono la scritta “Dispari”.
Due frequenti errori sono quelli che seguono, spesso commessi insieme:
Select Case var = espressione
Non si deve scrivere var = in quanto a destra di Select Case si deve
indicare solo un’espressione. Attenzione che sintatticamente è corretto (non
viene rilevato alcun errore dall’interprete): si tratta infatti di un confronto tra
var e l’espressione, questo produce un valore True o False e tale valore
viene cercato tra i Case valorei.
Case var = 1
Case var = 2
Non si deve scrivere var = in quanto a destra dei vari Case si deve indicare
un possibile risultato dell’espressione. Anche qui la sintassi è corretta: si tratta
di un confronto tra var e un altro valore, questo produce un valore True o
False e questo valore viene usato come risultato dell’espressione.
Altro errore frequente è scrivere:
Case Is > 0, Is < 10
pensando di determinare un intervallo tra 0 e 10 estremi esclusi, in realtà
vengono considerati i valori maggiori di 0 OPPURE minori di 10, cioè tutti. Si
usi la clausola To per indicare un intervallo.

5.6
1)
2)
3)
4)
5)

Esercizi
Scrivere un programma che chieda due numeri da tastiera e dei due
stampi il maggiore.
Scrivere un programma che chieda tre numeri da tastiera e dei tre stampi
il maggiore.
Scrivere un programma che chieda tre numeri da tastiera e li stampi in
ordine decrescente.
Scrivere un programma che chieda un numero da tastiera e determini se è
pari o dispari (consiglio: usare Mod).
Scrivere un programma che chieda da tastiera di introdurre un numero
intero corrispondente ad un voto e stampi a video “insufficiente”
se è inferiore a 18, “appena sufficiente” (18), “basso”
(19-20), “medio” (21-23), “buono” (24-26), “alto” (27-29),
“massimo” (30).

Esecuzione condizionale

6)

7)

8)

9)

10)

45

La funzione arctan() dell’esercizio 4) del capitolo 3 dà errore quando x=1
a causa della divisione per zero. Si corregga il problema considerando
che in questo caso la funzione arctan() dovrebbe dare il valore π/2.
Calcolare la distanza tra i punti di coordinate 0o N 0o E and 0o N 180o E.
[Risultato: 20020.726 km o 10810.327 NM]
Si vogliono dividere gli allievi di un corso in tre squadre denominate
ROSSA, VERDE e BLU, distribuendoli secondo il numero di matricola.
L’assegnazione avviene con il seguente criterio: l’allievo con matricola
1 va nella squadra ROSSA, quello con matricola 2 nella VERDE, quello
con matricola 3 nella BLU, quello con matricola 4 nella ROSSA, quello
con 5 nella VERDE ecc. Il programma deve chiedere da tastiera il
numero di matricola dell’allievo e deve indicare a quale squadra è stato
assegnato (consiglio: usare Mod, non si pensi di elencare in qualche
modo tutti i valori per le varie squadre!).
Variazione dell’esercizio precedente: si chieda anche se l’allievo è
straniero, in caso affermativo lo schema di assegnamento alla squadra
deve seguire l’ordine opposto (BLU, VERDE, ROSSA). A tal fine
chiedere all’utente di inserire, in altra InputBox, un 1 per indicare se è
straniero e uno 0 se non lo è.
Si scriva un programma che chieda i tre coefficienti a, b e c di
un’equazione di secondo grado e calcoli i valori delle soluzioni se questi
sono reali; nel caso non lo siano deve semplicemente scrivere a video
“Valori non reali”.
Scrivere un programma che dato il reddito (valore di tipo intero) calcoli
la tassa (il risultato deve essere di tipo reale) secondo la regola:
 10% sui redditi fino a 10 (migliaia di Euro);
 15% sulla parte che eccede i 10 fino a 15;
 20% sulla parte che eccede i 15 fino a 20;
 25% sulla parte che eccede i 20 fino a 25;
 30% sulla parte che eccede i 25 fino a 30;
 35% sulla parte che eccede i 30.
Esempi
Un reddito pari a 7 viene tassato con un importo pari al 10% di 7 (0.7).
Un reddito pari a 12 viene tassato con un importo che è la somma del
10% di 10 (pari a 1) e il 15% della parte eccedente che è 12–10 (15% di
2, pari a 0.3).
Un reddito di 17 viene tassato con un importo che è la somma del 10% di
10 (pari a 1), del 15% di 15–10 (15% di 5, pari a 0.75) e del 20% di 17–
15 (20% di 2, pari a 0.4).

46
11)

Capitolo 5

Un anno non secolare (cioè non divisibile per 100) è bisestile se è
divisibile per 4, mentre un anno secolare è bisestile se è divisibile per
400. Ad esempio l’anno 1900 non era bisestile, il 1996 era bisestile, il
2000 lo era, il 2002 non lo era.
Scrivere un programma che chieda all’utente di introdurre un anno e
indichi se è bisestile.

Le stringhe

6

47

Le stringhe

In informatica una stringa è una sequenza di caratteri. Un carattere è un segno
grafico, ad esempio A, $, *, 6, la maggior parte dei quali si ottiene premendo il
relativo tasto sulla tastiera. Ad ogni carattere corrisponde un codice numerico
all’interno del calcolatore secondo una corrispondenza stabilita dal cosiddetto
Codice ASCII, la cui struttura è la seguente:
Sezione
255
128
127
123
122
97
96
91
90
65
64
58
57
48
47
33
32
31
0

Caratteri ASCII estesi
Altri caratteri
a-z (lettere minuscole)

Altri caratteri
A-Z (lettere maiuscole)

Altri caratteri
0-9 (cifre)

Altri caratteri
Carattere SPAZIO
Altri caratteri

Ad esempio alla lettera A (maiuscola) corrisponde il valore 65, alla B il 66, alla
a (minuscola) il 97, alla b il 98, allo 0 (zero) il 48 (anche le cifre sono
caratteri), alla virgola il 44, e così via. Un carattere occupa un intero byte.
Il Codice ASCII standard ha 128 corrispondenze tra caratteri e valori e quindi
per rappresentarle tutte sono sufficienti 7 bit (27=128). Poiché però c’è ancora
un bit sfruttabile, tutti i sistemi operativi estendono a modo loro il codice

Capitolo 6

48

ASCII con altre 128 corrispondenze tra caratteri e valori (128+128=256
corrispondenze totali, tutte quelle possibili con 8 bit, che sono appunto 28=256)
e questa parte viene chiamata Codice ASCII Esteso. Il significato di quella
dicitura “a modo loro” scritta poco innanzi è questo: i codici ASCII di un
sistema operativo Windows, Unix, Linux, VMS ecc. saranno tutti uguali per la
prima metà (appunto i primi 128 caratteri) e diversi per la seconda metà (i
codici estesi, utilizzati per rappresentare simboli diversi, come le lettere
accentate).
In questo libro utilizzeremo solo il codice ASCII standard. Questo è costituito
da sezioni diverse (vedasi la figura precedente): ci sono tutti i caratteri
alfabetici maiuscoli in ordine alfabetico, ci sono tutti i caratteri alfabetici
minuscoli in ordine alfabetico, ci sono tutte le cifre in ordine numerico, ci sono
poi altri caratteri (quali i segni di interpunzione, le parentesi ecc.) che
costituiscono sezioni più piccole. È importante puntualizzare che la sezione
delle lettere maiuscole è compatta, ossia non ci sono altri tipi di caratteri tra la
A e la Z; lo stesso dicasi per le minuscole e per le cifre.
Si noti che anche lo spazio è un carattere come gli altri, solo che non si vede.
L’elenco dei codici ASCII standard ed esteso per sistemi Windows si trova
nella guida in linea del Visual Basic (cercare Character Set o set di caratteri).
Normalmente non serve conoscere la corrispondenza dei caratteri con i valori
del codice ASCII se non in programmi che proprio si basano su di esso, ma è
comunque importante ricordarsi che prima viene lo spazio (ha il codice ASCII
con il valore più basso), poi ci sono le cifre, poi le lettere maiuscole e poi le
minuscole.

6.1

Variabili stringa

Sono variabili adatte a contenere stringhe, la lunghezza massima della stringa è
di 231 caratteri (circa 2 miliardi). Vengono dichiarate per mezzo dell’istruzione
Dim come segue:
Dim variabile As String
Nei vecchi programmi, dove non si usava il dimensionamento, si trovano nomi
di variabili terminate da un carattere dollaro, come: nome$
I valori delle variabili stringa si assegnano come si fa per le variabili
numeriche:
nome = "Caio Giulio Cesare"
Una sequenza di caratteri tra virgolette è detta stringa costante, o costante di
tipo stringa e come tale non può essere modificata dal codice di
programmazione, mentre nome è una variabile e qindi può essere modificata.

Le stringhe

49

Una stringa può anche essere letta dalla tastiera per mezzo di un’istruzione
InputBox:
nome = InputBox("Come ti chiami")
I caratteri che l’utente introduce dalla tastiera vengono messi nella variabile
nome.
Una variabile del deprecato tipo Variant può contenere anche una stringa.

6.2

Operazioni sulle stringhe

L’unico operatore applicabile alle stringhe è l’operatore di concatenazione, ha
simbolo & e produce una variabile temporanea, “senza nome”, di tipo stringa
costituita da tutti i caratteri della prima stringa seguiti da tutti i caratteri della
seconda. Consideriamo il programmino seguente:
A = "Ciao"
B = "mondo"
C = A & B
MsgBox C
Questo programma stamperà a video “Ciaomondo”. Perché non separa le
due parole con uno spazio? Perché la concatenazione affianca soltanto, se
vogliamo uno spazio dobbiamo includerlo esplicitamente, ad esempio
mettendolo dopo la “o” di “Ciao” o prima della “m” di “mondo” oppure così:
C = A & " " & B
Si noti che tra le virgolette c’è uno spazio bianco. In realtà, per compatibilità
con vecchie versioni di Basic, anche il simbolo + serve per concatenare due
stringhe (oltre che per sommare due numeri). Anche se il simbolo è lo stesso,
questa non è una somma, ma una concatenazione e quindi scrivere C=A+B (che
equivale a C=A&B) o C=B+A (che equivale a C=B&A) non è indifferente, la
seconda infatti produce “mondoCiao”. L’utilizzo dell’operatore + può portare
problemi ad