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

220 Pages·0.873 MB·Italian

by  Claudio Fornaro

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
vi INDICE
18.7 Capitolo 9 ....................................................................................... 162
18.8 Capitolo 10 ..................................................................................... 173
18.9 Capitolo 11 ..................................................................................... 184
18.10 Capitolo 12 ..................................................................................... 195
18.11 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 Introduzione
1.1 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