Questo sito utilizza cookies, anche di terze parti, per mostrare pubblicità e servizi in linea con il tuo account. Leggi l'informativa sui cookies.
Username: Password: oppure
Guida al Visual Basic .NET - Variabili e costanti

Guida al Visual Basic .NET

Capitolo 5° - Variabili e costanti

<< Precedente Prossimo >>

Le variabili

Una variabile è uno spazio di memoria RAM (Random Access Memory) in cui vengono allocati dei dati dal programma, ed è possibile modificarne od ottenerne il valore facendo riferimento ad un nome che si definisce arbitrariamente. Questo nome si dice anche identificatore (o, più raramente, mnemonico), e può essere costituito da un qualunque insieme di caratteri alfanumerici e underscore: l'unica condizione da rispettare per creare un nome valido è che questo non può iniziare con un numero. Per esempio "Pippo", "_Pluto", "Mario78" o anche "_12345" sono identificatori validi, mentre "0Luigi" non lo è. Il principale scopo di una variabile è contenere dati utili al programma; tali dati possono risiedere in memoria per un tempo più o meno lungo, a seconda di quando una variabile viene creata o distrutta: ogni variabile, comunque, cessa di esistere nel momento in cui il programma viene chiuso. Essa, inoltre, può contenere una grandissima varità di tipi di dato diversi: dai numeri alle stringhe (testo), dalle date ai valori booleani, per allargarsi poi a tipi più ampi, in grado di rappresentare un intero file. Ma prima di arrivare a spiegare tutto questo, bisogna analizzare in che modo si dichiara una variabile. La dichiarazione, tanto di una costante quanto di una classe, è l'atto definitivo con cui si stabilisce l'esistenza di un'entità e la si rende disponibile o accessibile alle altri parti del programma. Ogni cosa, per essere usata, deve prima essere dichiarata da qualche parte: questa operazione equivale, ad esempio, a definire un concetto in matematica: la definizione è importantissima.
Ecco un semplice esempio:
Module Module1
    Sub Main()
        Dim Ciao As Int16
        Ciao = 78
        Ciao = Ciao + 2
        Console.WriteLine(Ciao)
        Console.Readkey()
    End Sub
End Module 
Facendo correre il programma avremo una schermata nera su cui viene visualizzato il numero 80. Perchè? Ora vediamo.
Come avrete notato, le variabili si dichiarano in un modo specifico, usando le keywords Dim e As:
Dim [nome] As [tipo] 
Dove [nome] è l'identificatore con cui ci si riferisce ad una variabile e [tipo] il tipo di dato contenuto nella variabile. Esistono molteplici tipi di variabile fra cui è possibile scegliere. Ecco un elenco dei tipi base (che sono considerati keywords):
  • Byte: intero a 8 bit che può assumere valori da 0 a 255;
  • Char: valore a 8 bit che può assumere i valori di ogni carattere della tastiera (compresi quelli speciali);
  • Int16 o Short: intero a 16 bit che può assumere valori da -32768 a +32767;
  • Int32 o Integer: intero a 32 bit da -2147483648 a +2147483647;
  • Int64 o Long: intero a 64 bit da circa -922000000000000000 a +9220000000000000000;
  • Single: decimale da circa -3,4e+38 a +3,4e+38, con un intervallo minimo di circa 1,4e-45;
  • Double: decimale da circa -1,79e+308 a +1,79e+308, con un intervallo minimo di circa 4,9e-324;
  • Boolean: dato a 4 bytes che può assumere due valori, True (vero) e False (falso). Nonostante la limitatezza del suo campo di azione, che concettualmente potrebbe restringersi ad un solo bit, il tipo Boolean occupa 32bit di memoria: sono quindi da evitare grandi quantità di questo tipo;
  • String: valore di minimo 10 bytes, composto da una sequenza di caratteri. Se vogliamo, possiamo assimilarlo ad un testo;
  • Object: rappresenta un qualsiasi tipo (ma non è un tipo base).
I tipi base vengono detti anche atomici o primitivi, poiché non possono essere ulteriormente scomposti. Esistono, quindi, anche tipi derivati, appartenenti a svariate tipologie che analizzeremo in seguito, fra cui si annoverano anche le classi: ogni tipo derivato è scomponibile in un insieme di tipi base.
Ora, quindi, possiamo estrapolare delle informazioni in più dal codice proposto: dato che segue la keyword Dim, "Ciao" è l'identificatore di una variabile di tipo Int16 (infatti dopo As è stato specificato proprio Int16). Questo significa che "Ciao" può contenere solo numeri interi che, in valore assoluto, non superino 32767. Ovviamente, la scelta di un tipo di dato piuttosto che un altro varia in funzione del compito che si intende svolgere: maggiore è la precisione e l'ordine di grandezza dei valori coinvolti e maggiore sarà anche l'uso di memoria che si dovrà sostenere. Continuando a leggere, si incontra, nella riga successiva, un'assegnazione, ossia una operazione che pone nella variabile un certo valore, in questo caso 78; l'assegnazione avviene mediante l'uso dell'operatore uguale "=". L'istruzione successiva è simile a questa, ma con una sostanziale differenza: il valore assegnato alla variabile è influenzato dalla variabile stessa. Nell'esempio proposto, il codice:
Ciao = Ciao + 2
ha la funzione di incrementare di due unità il contenuto di Ciao. Questa istruzione potrebbe sembrare algebricamente scorretta, ma bisogna ricordare che si tratta di un comando (e non di un'equazione): prima di scrivere nella cella di memoria associata alla variabile il numero che il programmatore ha designato, il programma risolve l'espressione a destra dell'uguale sostituendo ad ogni variabile il suo valore, e ottenendo, quindi, 78 + 2 = 80. Le ultime due righe, invece, fanno visualizzare a schermo il contenuto di Ciao e fermano il programma, in attesa della pressione di un pulsante.
Come si è visto dall'esempio precedente, con le variabili di tipo numerico si possono eseguire operazioni aritmetiche. Gli operatori messi a disposizione dal Framework sono:
  • + : addizione;
  • - : sottrazione;
  • * : prodotto;
  • / : divisione;
  • : divisione tra interi (restituisce come risultato un numero intero a prescindere dal tipo degli operandi, che possono anche essere decimali);
  • Mod : restituisce il resto di una divisione intera;
  • = : assegna alla variabile posta a sinistra dell'uguale il valore posto dopo l'uguale;
  • & : concatena una stringa con un numero o una stringa con un'altra stringa.
Module Module1
    Sub Main()
        'Interi
        Dim Intero, Ese As Int16
        'Decimale
        Dim Decimale As Single
        'Booleano
        Dim Vero As Boolean
        'Stringa
        Dim Frase As String

        Intero = 90
        Ese = Intero * 2 / 68
        Intero = Ese - Intero * Intero
        Decimale = 90.76
        Decimale = Ese / Intero
        Vero = True
        Frase = "Ciao."
        'L'operatore "+" tra stringhe concatena due stringhe. Dopo la 
        'prossima istruzione, la variabile Frase conterrà:
        ' "Buon giornoCiao"
        Frase = "Buon giorno" + "Ciao"
        'L'operatore "&" può concatenare qualsiasi dato e
        'restituisce una stringa. Dopo la prossima istruzione, la 
        'variabile Frase conterrà:
        ' "Il valore decimale è: -0,0003705076"
        Frase = "Il valore decimale è: " & Decimale
    End Sub
End Module 
Esistono poi degli speciali operatori di assegnamento, che velocizzano l'assegnazione di valori, alcuni sono:
Module Module1
  Sub Main()
    Dim V, B As Int32

    V += B 'Equivale a V = V + B
    B -= V 'Equivale a B = B - V
    V *= B 'Equivale a V = V * B
    B /= V 'Equivale a B = B / V
  End Sub
End Module 
Le frasi poste dopo un apice (') sono dette commenti e servono per spiegare cosa viene scritto nel codice. Il contenuto di un commento NON influisce in nessun modo su ciò che è scritto nel sorgente, ma ha una funzione ESCLUSIVAMENTE esplicativa.


Le costanti

Abbiamo visto che il valore delle variabili può essere modificato a piacimento. Ebbene quello delle costanti, come il nome suggerisce, no. Esistono per semplificare le operazioni. Per esempio, invece di digitare 3,1415926535897932 per il Pi greco, è possibile dichiarare una costante di nome Pi che abbia quel valore ed utilizzarla nelle espressioni. La sintassi per dichiarare una costante è la seguente:
Const [nome] As [tipo] = [valore]
Ci sono due lampanti differenze rispetto al codice usato per dichiarare una variabile. La prima è, ovviamente, l'uso della keyword Const al posto di Dim; la seconda consiste nell'assegnazione posta subito dopo la dichiarazione. Infatti, una costante, per essere tale, deve contenere qualcosa: per questo motivo è obbligatorio specificare sempre, dopo la dichiarazione, il valore che la costante assumerà. Questo valore non potrà mai essere modificato.
Esempio:
Module Module1
  Sub Main()
    Const Pi As Single = 3.1415926535897932
    Dim Raggio, Area As Double

    'Questa istruzione scrive sul monitor il messaggio posto tra
    'virgolette nelle parentesi
    Console.WriteLine("Inserire il raggio di un cerchio:")
    
    'Questa istruzione leggè un valore immesso dalla tastiera e
    'lo deposita nella variabile Raggio
    Raggio = Console.ReadLine
    Area = Raggio * Raggio * Pi

    Console.WriteLine("L'Area è: " & Area)
    
    'Questa istruzione ferma il programma in attesa della pressione
    'di un pulsante
    Console.ReadKey()
  End Sub
End Module 
N.B.: a causa della loro stessa natura, le costanti NON possono essere inizializzate con un valore che dipenda da una funzione. Scrivo questo appunto per pura utiliztà di consultazione: anche se ora potrà non risultare chiaro, vi capiterà più avanti di imbattervi in errori del genere:
Const Sqrt2 As Single = Math.Sqrt(2)
Sqrt2 dovrebbe essere una costante numerica decimale che contiene la radice quadrata di due. Sebbene il codice sembri corretto, il compilatore segnalerà come errore l'espressione Math.Sqrt(2), poiché essa è una funzione, mentre dopo l'uguale è richiesto un valore sempre costante. Il codice corretto è
Const Sqrt2 As Single = 1.4142135


Le istruzioni

Tutti i comandi che abbiamo impartito al computer e che abbiamo genericamente chiamato con il nome di istruzioni (come Console.WriteLine()) hanno dei nomi più specifici: sono procedure o funzioni, in sostanza sottoprogrammi già scritti. Procedure e funzioni possono essere globalmente indicate con la parola metodo. I metodi accettano dei parametri passatigli tra parentesi: se i parametri sono di più di uno vengono separati da virgole. I parametri servono per comunicare al metodo i dati sui quali questo dovrà lavorare. La differenza tra una procedura e una funzione risiede nel fatto che la prima fa semplicemente eseguire istruzioni al computer, mentre la seconda restituise un valore. Ad esempio:
Module Module1
    Sub Main()
        Dim F As Double
    
        'Questa è una funzione che restituisce la radice quadrata di 56
        F = Math.Sqrt(56)

        'Questa è una procedura che scrive a video un messaggio
        Console.WriteLine("La radice di 56 è " & F)
        Console.ReadKey()
    End Sub
End Module 
Anche i metodi verranno trattai successivamente in dettaglio.


<< Precedente Prossimo >>
A proposito dell'autore

Programmatore e analista .NET 2005/2008/2010 (in particolare C# e VB.NET), anche nell'implementazione Mono per Linux. Conoscenze approfondite di Pascal, PHP, XML, HTML 4.01/5, CSS 2.1/3, Javascript (e jQuery). Conoscenze buone di C, LUA, GML, Ruby, XNA, AJAX e Assembly 68000. Competenze basilari di C++, SQL, Hlsl, Java.