Code Power

F# - Tipi derivati

2012-01-15T20:38:00.000+01:00

Come è stato detto negli articoli precedenti F# possiede una serie di tipi nativi del linguaggio, come il tipo intero, float, boolean e così via. Ma come è stato detto, questi sono dei tipi nativi, già presenti nel linguaggio, che possono, però, contribuire alla creazione di nuovi tipi, i così detti tipi derivati. Esistono, sostanzialmente, tre categorie di tipi derivati: tipi enumerati, tipi unione e tipi record.

Tipi enumerati

Nella categoria dei tipi enumerati rientrano i tipi creati mediante l'enumerazione degli elementi che fanno parte dell'insieme del tipo. Se per esempio vogliamo creare un nuovo tipo, che rappresenti l'insieme dei giorni della settimana. Quello che dobbiamo fare è dare un nome ad ogni giorno della settimana e indicare che quel elemento appartiene all'insieme dei giorni della settimana. Di seguito è stato rappresentato l'insieme del tipo che andremo a creare:

giorno = {Lunedì, Martedì, Mercoledì, Giovedì, Venerdì, Sabato, Domenica}

In altre parole, l'insieme appena citato contiene soltanto i valori elencati. La creazione di un tipo enumerato in F# viene fatto in un modo analogo:

In questo modo abbiamo definito un nuovo tipo giorno, il cui insieme dei valori è uguale a quello elencato in precedenza. Proviamo ad eseguire in F# Interactive(Ctrl+Alt+F) il codice di seguito riportato:

let x = Sabato;;

Come risposta dell'interprete avremo questo messaggio:

val x : giorno = Sabato

Da questa risposta possiamo vedere che l'interprete ha deciso automaticamente che la variabile x è di tipo giorno ed il suo valore è uguale a Sabato.

A questo punto potremo scrivere una funzione, che prende come argomento un giorno della settimana e come risultato restituisce un valore booleano, per indicare se il giorno è lavorativo:

let lavorativo day =
match day with
| Sabato | Domenica -> false
| _ -> true;;

La funzione, quindi, prende come argomento un valore di tipo giorno e lo confronta con il valore Sabato e Domenica. Se day è uguale a Sabato, oppure a Domenica, allora restituisce false, perché day non rappresenta un giorno lavorativo. In tutti gli altri casi day rappresenta un giorno lavorativo, quindi la funzione restituisce true.

Tipi unione

A differenza dei tipi enumerati i tipi unione non devono essere elencati uno ad uno, quando si vuole definire un nuovo tipo, perché essi vengono creati sulla base degli altri tipi, già definiti. In pratica per definire un nuovo tipo unione dobbiamo elencare soltanto i suoi elementi e il tipo di tali elementi. Per esempio, potremo creare un tipo, che permetta di identificare un oggetto dal nome, oppure da un numero identificativo. Di seguito è riportato il codice di come sia possibile farlo:

type id = Name of string | Id of int;;

In questo modo verrà definito il tipo id, che ha come elementi Name e Id. Ma anche se la definizione del tipo unione è molto simile a quella dei tipi enumerati, l'impiego di questi tipi è leggermente diverso. Di seguito è riportato un esempio di come sia possibile dichiarare una variabile di tipo id:

let identity = Name "Tizio";;
let identity2 = Id 4231;;

Come si può vedere dall'esempio, bisogna fare attenzione a scrivere prima l'elemento dell'insieme del tipo, seguito dal valore del rispettivo tipo. Il vantaggio di avere questo modo di definire i tipi è quello di poter utilizzare il tipo stesso nella sua definizione, che ci permette di creare delle strutture informatiche molto importanti, quali le liste concatenate e gli alberi. Di seguito è riportato il codice che ci permette di creare una lista concatenata, una struttura dati molto simile alle liste:

type MyList = Empty | Nodo of int * MyList;;

In questo modo una variabile di tipo MyList può assumere il valore Empty, che rappresenta la lista vuota, oppure un valore formato da una coppia da un valore di tipo int e uno di tipo MyList. Concatenando in questo modo più valori è possibile creare una lista lunga a piacere di elementi. Ecco un esempio di come si può creare una lista di questo tipo:

let lista = Node(1,Node(2,Node(3,Empty)));;

La particolarità di questo tipo di struttura è che possiamo aggiungere una quantità illimitata di elementi e in ogni momento abbiamo la possibilità di aggiungerne un'altro, cosa molto utile nel caso in cui non sappiamo quanti elementi dobbiamo esaminare.

Tipi record

I tipi record differiscono dagli altri due per il fatto che è più adatto a descrivere le caratteristiche di un determinato oggetto o soggetto, per esempio l'eta, l'altezza ed il peso di una persona, per cui utilizzando i tipi record possiamo racchiudere facilmente in un'unica variabile delle grandezze che descrivono un determinato oggetto o soggetto. Giusto per fare un esempio di come vengono definiti i tipi record, cercheremo di creare un nuovo tipo che permetta di contenere le informazioni riguardanti il nome, l'altezza e l'età di una persona:

type Persona = {nome: string; altezza: float; eta: int};;

Sostanzialmente abbiamo creato un nuovo tipo, chiamato Persona, che è caratterizzato da tre elementi: nome, altezza ed eta. Ma a differenza dei tipi enumerati e quelli unione, se vogliamo creare una nuova variabile di tipo Persona dobbiamo inizializzare tutti i suoi attributi:

let p = {nome="Tizio";altezza=172.4;eta=23};;

Bene, abbiamo visto come creare un tipo record, abbiamo anche visto come creare ed inizializzare una variabile del tipo creato, ma come fare ad utilizzare questi tipi nella programmazione? Per rispondere a questa domanda proviamo a scrivere una funzione che, data una lista di persone e dato il nome di una persona, ci restituisce una lista contenente tutte le persone che hanno il nome indicato:

let rec search lst x =
match lst with
| [] -> []
| y::ys -> if y.nome=x then y::(search ys x)
else (search ys x);;

Dal codice si può vedere che se la lista contiene almeno un elemento, la variabile locale y assume il valore del primo elemento della lista e visto che la lista è di tipo Persona, per conoscere il nome della prima persona della lista, viene usata la scrittura y.nome. In questo modo viene letto l'attributo nome della persona corrispondente. Se viene trovata una corrispondenza tra il nome della persona della lista e il nome da cercare, la persona viene aggiunta in testa ad una nuova lista, che alla fine verrà restituita come risultato.

F# - Liste

2012-01-14T17:29:00.003+01:00

Al giorno d'oggi programmando, molto spesso si imbatte nella necessità di raggruppare più elementi dello stesso tipo. Proprio in questi casi in F# vengono usate le liste, per memorizzare queste sequenze di elementi. Nei linguaggi di programmazione procedurale, come Java e C++, queste strutture dati vengono chiamate liste concatenate, perché tra un elemento della lista e il suo successivo esiste un collegamento.
Oltre alle liste esiste un'altra struttura dati per raggruppare più elementi dello stesso tipo ed viene chiamata array, però gli array hanno il grosso svantaggio di essere limitati, perché una volta creato non può modificare la sua lunghezza.
Ma come segue dal titolo dell'articolo, ci occuperemo dello studio delle liste e non degli array, per cui andiamo a vedere i modi in cui possono essere create le liste:

let lista = [];;
let lista2 = 0::1::2::lista;;
let lista3 = [3;4;5;6];;
let lista4 = lista2 @ lista3;;

Con queste righe di codice abbiamo, sostanzialmente, creato 4 liste diverse. La prima lista non è altro che una lista vuota, ovvero una lista che non contiene elementi e quindi è lunga 0. Nella seconda riga di codice, invece, abbiamo usato l'operazione di concatenazione di elementi ad una lista, aggiungendo in testa alla prima lista gli elementi 0,1 e 2 e il risultato l'abbiamo scritto in lista2.

L'operazione di concatenazione può essere usato soltanto per aggiungere elementi in testa alla lista e come ultimo elemento della concatenazione deve per forza essere una lista.

Con la terza riga del codice abbiamo creato una nuova lista, inserendo direttamente gli elementi al suo interno, mentre la quarta lista l'abbiamo creata mediante la concatenazione della seconda e della terza lista, visto che l'operatore @ permette di concatenare due liste, mettendo per primi gli elementi della prima lista, seguiti da quelli della seconda lista.
Molto spesso, lavorando con le liste sorge la necessità di suddividere la lista in testa e coda, dove la testa rappresenta il primo elemento della lista, mente la coda rappresenta il resto della lista. Di seguito è riportato un esempio in cui viene fatto ciò:

let lista = [1;2;3;4];;
let testa::coda = lista;;

In questi modo abbiamo detto all'interprete di F# di assegnare al nome testa il primo elemento di lista e di assegnare la coda di lista al nome coda. Fare così è equivalente a spezzettare la lista originale in testa e coda, che spesso si rivela molto utile quando si scrivono funzioni ricorsive, che devono dare determinate operazioni sulle liste.
Proviamo a vedere un breve esempio di funzione, che determina la lunghezza di una lista. L'idea risolutivo è quello di spezzettare la lista in testa e coda, dopodiché aggiungere 1 alla lunghezza della coda della lista:

let rec lunghezza lst =
match lst with
| [] -> 0
| x::xs -> 1 + (lunghezza xs);;

Come possiamo vedere, per la scrittura della funzione abbiamo usato il pattern matching, in cui confrontiamo la lista, passata come argomento della funzione, con la lista vuota e con una lista, che contiene almeno un elemento. Con la scrittura x::xs viene la lista viene spezzettata, come è stato spiegato in precedenza, per cui richiamando la funzione stessa, passandogli xs come argomento, è equivalente al richiamo della funzione lunghezza sulla coda della lista lst. In questo modo primo o poi si arriva alla situazione in cui la lista lst è uguale alla lista vuota e quindi si chiude il ciclo. Ma aggiungere ad ogni passaggio 1 al risultato equivale al contare in quanti passaggi la lista si svuota, per cui viene trovata la lunghezza della lista.
Se proviamo ad analizzare i vari passaggi che esegue l'interprete di F# per restituire il risultato della funzione in un esempio concreto otteniamo il seguente risultato:

lunghezza [1;2;3;4]
1+(lunghezza [2;3;4])
1+(1+(lunghezza [3;4]))
1+(1+(1+(lunghezza [4])))
1+(1+(1+(1+(lunghezza []))))
1+(1+(1+(1+0)))
1+(1+(1+1))
1+(1+2)
1+3
4

Dalla traccia riportata in alto si può vedere molto bene come ad ogni passaggio viene aumentato il numero dei 1+, mentre dalla lista viene eliminato il primo elemento. Inoltre, vediamo che il risultato restituito dalla funzione è 4, che è proprio la lunghezza della lista passata come argomento alla funzione, quindi possiamo affermare che la funzione è corretta.

Web Server - Installazione MySQL

2012-01-13T22:19:00.000+01:00

Spesso nella costruzione dei siti web c'è la necessità di conservare dati, riguardanti gli utenti che utilizzano il vostro sito web, ma organizzando i dati sui file di testo è estremamente inefficace, specie nel momento in cui si deve cercare una particolare informazione. Il problema può essere risolto legando al sito un database, però per questo è necessario disporre di un DBMS(DataBase Managment System), che ci servirà per gestire i database del sito. MySQL è un DBMS molto usato per la gestione dei siti web, anche complessi, perché permette un interfacciamento molto semplice con PHP.

Vediamo, allora, come si fa ad installare MySQL e a configurarlo per l'interfacciamento con PHP. Prima di tutto scaricate il pacchetto di installazione, scaricabile gratuitamente da http://dev.mysql.com/downloads/installer/, dopo aver selezionato il vostro sistema operativo. Dopodiché basta far partire l'installatore e seguire i passi di installazioni, come descritto in basso:

1. Non appena parte il programma di installazione viene visualizzato un menu, dal quale potete scegliere l'operazione che volete eseguire, ma dato che vogliamo installare MySQL, dobbiamo scegliere la prima opzione: "Install MySQL Products"

2. Scelta l'opzione di installazione del prodotto vi viene presentata la licenza del prodotto, che dovete leggere ed accettare se volete utilizzarlo, quindi dovete spuntare la casella in basso e andare avanti.

3. Prima di procedere all'installazione vi viene chiesto se volete verificare la presenza di versioni più recenti del prodotto, quindi se siete sicuri di utilizzare la versione più recente del programma potete deselezionare la casella in basso e procedere con l'installazione.

4. A questo punto vi viene chiesto di selezionare il tipo di installazione che volete fare. Selezionando l'opzione "Developer Default" verranno installati i componenti necessari per lo sviluppo, che possono essere utili per lo sviluppo di database per il web.

5. I componenti aggiuntivi possono richiedere l'installazione di componenti aggiuntivi, necessari per il funzionamento delle utilità che andremo ad installare, quindi basta andare avanti e seguire i passi dell'installazione guidata.

6. Questo passo dell'installazione prevede l'installazione dei componenti di MySQL e delle utilità scelte al quarto passaggio.

7. Finita l'installazione si procede con la configurazione di MySQL. Se seguente schermata ha il compito di visualizzare i componenti da configurare.

8. Questo passo della configurazione permette di decidere la quantità di risorse di sistema da attribuire al servizio MySQL, che potrà essere utilizzato in ogni momento. Selezionando la prima opzione, "Developer Machine", si decide di dare poche risorse al servizio ed è la scelta migliore se il computer sul quale installate il prodotto lo utilizzerete anche per altri scopi. Le altre due opzioni permettono di attribuire al servizio sempre più risorse di sistema.

9. A questo punto dobbiamo impostare alcuni parametri funzionali del servizio MySQL. Andremo a modificare soltanto il terzo punto, nominato "Security Settings", dove andremo a mettere una password per proteggere i database dalle persone non autorizzate. Dovete digitare la stessa password sia nella prima, che nella seconda casella di testo.
N.B. Se dimenticate la password non c'è modo di recuperarla.

10. Finalmente l'installazione è giunta alla fine e se viene visualizzata la schermata riportata in basso, allora l'installazione è andata a buon fine e possiamo iniziare ad utilizzare MySQL.

Per verificare se MySQL funziona correttamente basta andare in Start-> Tutti i programmi-> MySQL-> MySQL Server x.x -> MySQL x.x Command Line Client (le x.x indicano la versione del prodotto). Verrà aperta una finestra di Prompt dei Comandi, dove vi verrà chiesta l'immissione della password che avete scelto:

Se avete inserito la password correttamente vi verrà mostrata la schermata che vedete sopra. Provate a eseguire i comandi riportati in basso:

show databases;

Come risultato dovreste ottenere una tabella con i database già presenti nel DBMS:

Per fare chiamate alle tabelle di un determinato database dovete prima scegliere il database, che volete caricare e dove si trova la tabella da voi cercata. Per fare ciò dovete inserire il seguente comando:

use nomedatabase;

dove al posto di nomedatabase dovete inserire il nome del database che volete selezionare.

Un'ultima cosa riguardante la configurazione del interprete PHP. Se avete installato una delle ultime versioni di PHP, allora dovreste avere già abilitato il supporto di MySQL. Per verificare se MySQL è abilitato per le connessioni da PHP dovete caricare la pagina *.php creata per verificare la configurazione di PHP, che visualizza un elenco dei parametri di PHP. Se nella lista trovate anche la tabella che riguarda MySQL, allora la funzionalità è abilitata:

Se, invece, non trovate questa tabella, allora dovete modificare il file di configurazione di PHP, nominato php.ini. Esso dovrebbe trovarsi nella cartella C:\Windows se avete installato una versione obsoleta di PHP e in ogni caso dovreste avere una copia nella cartella di PHP, di default C:\Programmi\PHP. Quello che dovete fare è togliere il simbolo ; davanti alla riga:

extension=php_mysql.dll

Fatto ciò dovrete riavviare il server web, nel nostro caso Apache e ricaricare la pagina web. Se tutto è andato a buon fine dovreste vedere anche la tabella riportata in alto.

F# - Ennuple

2012-01-13T00:03:00.001+01:00

Molto spesso programmando in qualsiasi linguaggio si verifica la necessità di raggruppare più variabili, anche di tipo diverso, che magari descrivono le caratteristiche di un determinato oggetto o soggetto. F# propone una soluzione molto semplice a questo problema, utilizzando le così dette ennuple.

Esse, in pratica, sono un raggruppamento di due o più valori, anche di tipo diverso. Molto spesso le ennuple vengono usate come l'insieme dei parametri da passare ad una funzione. Per esempio, se vogliamo che nel momento in cui viene richiamata la nostra funzione vengano passati tutti i parametri assieme, basta usare una ennupla come argomento della funzione. Ma prima di scendere in dettagli vediamo come possono essere create ed utilizzate le ennuple in F#:

let ennupla = (65,'A');;
let annedate = (ennupla,(1,3),12);;

Come si può vedere dal codice, una ennupla viene creata utilizzando le parentesi tonde e separando ogni elemento dall'altro mediante la virgola. Nella prima riga di codice vediamo una coppia formata da un numero intero e un carattere. Con la seconda riga di codice, invece, abbiamo creato un'ennupla formata da 3 elementi, di cui il primo non è altro che la coppia dichiarata in precedenza, il secondo elemento anch'esso è una coppia, però questa volta di interi, mente il terzo elemento è un intero. E qui abbiamo visto che le ennuple possono essere annidate e lunghe quanto vogliamo, però una volta create non possono modificare la dimensione e il tipo degli elementi.

Vediamo un semplice esempio di come possono essere impiegate le ennuple. Supponiamo di voler scrivere una funzione, che restituisce il risultato di una equazione di secondo grado, noti a, b e c. In quanto una equazione di secondo grado può avere al massimo 2 soluzioni, dobbiamo per forza restituire una coppia di valori e quindi useremo le ennuple per la scrittura della funzione:

let soluzioni (a:float) (b:float) (c:float) =
let d = b*b - 4.0*a*c in
match d with
d when d<0.0 -> failwith "l'equazione non ha soluzioni in R"
| 0.0 -> ((-b-sqrt(d))/(2.0*a),(-b-sqrt(d))/(2.0*a))
| d when d>0.0 -> ((-b-sqrt(d))/(2.0*a),(-b-sqrt(d))/(2.0*a));;

Proviamo ad esaminare il codice appena proposto. In pratica, abbiamo creato una funzione, che prende tre argomenti di tipo float. In questo caso abbiamo forzato il tipo dei parametri, per non dover di seguito convertire ogni volta il tipo delle variabili, inoltre in questo modo otteniamo un valore più esatto. Un'altra novità che introduce questo codice è la dichiarazione di una variabile locale nella funzione. Ciò è stato fato utilizzando la solita parola chiave let, seguita dalla dichiarazione del nome, dopodiché segue la parola chiave in, che indica la fine della dichiarazione. Dopo aver introdotto il nuovo nome, che abbiamo chiamato d, abbiamo attribuito ad esso il valore del discriminante dell'equazione.

Utilizzando il pattern matching abbiamo definito i tre casi, ovvero quando d>0, quando d<0 e quando d=0.

Nel caso in cui d<0 verrà generata un'eccezione, ovvero un messaggio in output, che indicherà che l'equazione con quei parametri non ha soluzione dell'insieme dei reali. Questa decisione è stata presa perché una funzione può restituire un valore di un solo tipo e non sarebbe molto corretto restituire una coppia di reali.

Se il discriminante, invece, vale 0, allora l'equazione ha un'unica soluzione, o meglio, le due soluzioni coincidono, per cui restituiamo una coppia di numeri float uguali.

Finalmente, nel caso in cui d>0 l'equazione ha due soluzioni, per cui viene restituita rispettivamente una coppia di numeri float. Per il calcolo delle soluzioni è stata utilizzata, inoltre, la funzione sqrt, una funzione predefinita di F#, che serve per calcolare la radice quadrata di un numero float.

Se proviamo a vedere lo stampo di questa funzione, eseguendo il codice in alto, utilizzando l'interprete di F#, otterremo il seguente output:

val soluzioni : float -> float -> float -> float * float

Come possiamo vedere, eseguendo il codice viene introdotta una nuova funzione, chiamata soluzioni, che prende tre argomenti di tipo float. Come risultato essa restituisce una coppia di float e visto che F# è un linguaggio che ha un forte legame con il linguaggio matematico, l'insieme delle soluzioni viene rappresentata come il prodotto dell'insieme dei reali per se stesso, ovvero float*float.

Web Server - Installazione PHP

2012-01-05T17:24:00.008+01:00

Fino ad ora abbiamo visto come installare il server web, per inviare la corrispondente pagina html, quando essa viene richiesta da un client. Ma in questo modo possiamo avere soltanto le pagine statiche, che potrebbero essere utili soltanto per depositare informazioni sul nostro sito e non avremo la possibilità di fare uno scambio di dati con l'utente.

Il problema si risolve utilizzando un linguaggio di programmazione come PHP, usato sul lato server, che permette di generare le pagine html a seconda della richiesta che viene fatta. Inoltre, in questo modo potremmo utilizzare anche un database, per gestire i dati degli utenti del nostro sito. Ma prima di utilizzare questo linguaggio di programmazione, dobbiamo installare un suo interprete e configurarlo in modo che Apache sappia utilizzare quel interprete.

L'interprete di un linguaggio di programmazione è un programma, che decodifica al volo il codice scritto nel corrispondente linguaggio di programmazione e esegue le istruzioni decodificate. Anche nel caso di PHP abbiamo un interprete, che decodifica le pagine *.php, eseguendo le istruzioni trovate nella pagina e restituendo come output una pagina *.html. In altre parole, quando verrà richiamata una pagina di estensione *.php, l'interprete eseguirà le istruzione PHP presenti in quel file e restituirà una pagina *.html, che verrà inviata al client. In questo modo potremmo alla stessa chiamata rispondere con una pagina completamente diversa.

Ma, come è stato detto, abbiamo bisogna dell'interprete PHP. Per chi utilizza il sistema operativo Windows, lo può scaricare da http://windows.php.net/download/, mentre per gli altri sistemi operativi, lo potete scaricare da http://php.net/downloads.php. Se avete deciso di scaricare l'archivio, allora lo dovete scompattare in una cartella, preferibilmente in modo da avere un percorso della cartella più corto(es. C:\php\), mentre se avete scaricato il pacchetto di installazione di PHP, allora basta seguire le indicazioni del installatore:

1. Viene visualizzata la schermata iniziale con la versione dell'interprete e qualche sugerimento.

2. Dopo aver letto i termini e le condizioni della licenza dovete spuntare le casella in basso, per indicare che accettate le condizioni della licenza. Questo è necessario per installare il programma.

3. Scegliete la cartella dove volete installare l'interprete e ricordatevela, perché ci servirà in seguito per configurare Apache.

4. Scegliamo il tipo di server che vogliamo configurare, nel nostro caso è Apache 2.2.x Module.

5. A questo punto dobbiamo scegliere la cartella dove è installato Apache.

6. Scegliete i componenti che volete installare. Potete lasciare anche la configurazione iniziale.

7. Confermate l'installazione e l'installatore farà il suo lavoro in automatico, configurando anche Apache.

8. Se tutto è andato a buon fine, verrà visualizzata la schermata finale con il messaggio di successo.

Adesso abbiamo completato l'installazione e il nostro server è completamente funzionante. Per provare se il server funziona correttamente, creiamo un nuovo file di estensione *.php e dentro scriviamo il seguente codice:

<?php phpinfo(); ?>

Il file deve essere copiato nella cartella delle pagine web, che avete indicato durante la configurazione di Apache (di default htdocs), dopodiché richiamato dal browser, digitando nella barra degli indirizzi http://localhost/nome_file.php. Come risultato dovreste ottenere una tabella con i dettagli della configurazione di PHP:

Con questo si conclude l'installazione e la configurazione di PHP.

Web Server - Installazione Apache

2012-01-05T17:24:00.007+01:00

Al giorno d'oggi l'Internet è diventato una risorsa molto importante del mondo intero, ma per molti ancora resta un mistero il funzionamento di tale sistema. Il tutto, in fondo, non è così complicato come potrebbe sembrare, se si cerca di astrarre un po' le varie parti di questo sistema, ignorando la struttura di esse e pensando soltanto alle operazioni che esse svolgono.

In generale l'Internet può essere pensato come un enorme graffo, ovvero una struttura fatta di nodi e di archi, dove ogni nodo rappresenta un computer e ogni arco rappresenta un collegamento tra due computer. Ma non tutti i nodi sono uguali, perché ci sono computer che fanno richiesta di un servizio e vengono chiamati client, mentre altri sono fatti per fornire i servizi richiesti e vengono chiamati server. Quindi nel momento in cui proviamo a collegarci all'Internet e vogliamo andare su un determinato sito, il nostro computer è un client e il computer, sul quale si trova il sito web rappresenta un server, che ci fornisce un servizio, inviandoci la pagina ipertestuale corrispondente.

Normalmente i computer sono dei client e vengono utilizzati per richiedere servizi, ma installando un programma come Apache possiamo rendere il nostro computer anche un server e quindi esso potrà sia richiedere servizi, che fornirli.

Installazione Apache

Come abbiamo visto, installando Apache possiamo fare in modo di avere un server sul nostro computer. Installando Apache, noi sostanzialmente creiamo un servizio sul nostro computer, che nel momento in cui viene fatta una richiesta, cerca in una cartella da noi indicata la pagina web richiesta e una volta trovata la invia al cliente che l'ha richiesta.

L'installazione di questo programma è molto semplice, perché basta seguire i passaggi dell'installatore, che farà tutto. Quindi dovete per prima cosa procurarvi il pacchetto di installazione o l'archivio di Apache, che lo potete scaricare gratuitamente da http://httpd.apache.org/download.cgi#apache22, scegliendo l'archivio, oppure il pacchetto corrispondente al vostro sistema operativo. In ogni caso vi consiglio di scaricare il pacchetto di installazione, perché è più semplice l'installazione. L'installazione avviene in 9 passaggi:

1. Al primo passaggio appare la schermata iniziale con la versione del programma.

2. Dopodiché viene visualizzata la licenza del programma, che dovette accettare per poter installare il programma. In questo modo accettate di rispettare i termini e le condizioni di questo prodotto.

3. Viene visualizzata una breve descrizione del software e sul suo funzionamento.

4. A questo passaggio dovete indicare le vostre preferenze riguardanti il nome del server e il suo dominio. Nell'immagine ho indicato localhost, in quanto questo server sarà visibile con questo nome soltanto dal vostro computer. In ogni caso questi nomi sono modificabili anche dal file di configurazione di Apache, però la modifica di quel file è consigliabile soltanto se avete un po' di esperienza con la configurazione di Apache, perché si rischia di rendere il programma non funzionante.

5. Scegliendo Typical, il programma verrà installato con le componenti e la configurazione standard.

6. Qui potete scegliere la cartella nella quale volete installare Apache.

7. A questo punto dovete confermare l'installazione.

8. L'installazione partirà automaticamente e durerà qualche minuto.

9. L'installazione è stata completata e potete vedere il risultato dell'installazione.

Una volta installato Apache, il server dovrebbe già essere funzionante, se tutto è andato a buon fine. Per verificare che tutto funziona correttamente, basta aprire il browser e digitare il nome del dominio, che nel mio caso è http://localhost . Come risposta dovreste ottenere il seguente risultato:

Il browser dovrebbe caricare una pagina predefinita, chiamata index.html, che si trova all'interno della cartella dove è stato installato Apache, dentro la cartella htdocs. Per rendere visibili anche altre pagine web, dovete metterle in questa cartella. Dal browser potrete richiedere i file, indicando i loro nomi dopo il nome del dominio (es. http://localhost/mio_file.html). Inoltre, è preferibile che non usiate gli spazi nei nomi dei file, perché alcuni browser potrebbero non capire il nome del file da richiedere.

Un'altra cosa, che potrebbe essere scomoda, è che i documenti che stanno sul server devono trovarsi nella cartella htdocs, non accessibile in pochi click. Ma modificando la configurazione di Apache, possiamo modificare anche la posizione della cartella delle pagine web.

Per fare ciò dobbiamo modificare il file httpd.conf, che si trova nella cartella conf della cartella di Apache. Il file può essere modificato anche con blocco note. Nel file trovate la riga

DocumentRoot "C:/Program Files/Apache Software Foundation/Apache2.2/htdocs"

e sostituite la parte tra apici con la posizione della cartella, nella quale volete mettere le pagine web. La posizione della cartella la potete copiare dalla barra degli indirizzi:

Però dovete fare attenzione ad usare le / e non le \ per indicare la posizione. Nel mio caso dovrei sostituire il testo sopra indicato con:

DocumentRoot "C:/Users/Administrator/Desktop/web"

In questo modo potrete accedere alla cartella con le pagine web da un posto più accessibile.

HTML - Hello, World!

2012-01-03T15:33:00.000+01:00

Fino ad ora si è parlato su come può essere impiegato il linguaggio di programmazione HTML e su come deve essere la struttura di un documento ipertestuale, scritto in questo linguaggio. Ma vediamo ora come procedere per creare la più semplice pagina, che dovrà contenere il messaggio "Hello, World!".

Beh, per creare in HTML una pagina che scriva un messaggio non ci vuole molto, perché una volta scritti i tag della struttura della pagina, basta inserire nel corpo il testo del messaggio che vogliamo visualizzare:

<html>
<head>
<title>Hello, World!</title>
</head>
<body>
Hello, World!
</body>
</html>

Per vedere il risultato può essere utilizzato anche un semplice editor di testo, va bene anche blocco note, basta che salviate il documento come file *.html. Quindi se usate blocco note, dopo aver inserito il codice, andate su File->Salva con nome... e scegliete di salvare come tutti i file. Nella casella di testo inserite il nome che volete, seguito da .html (es. hello.html) e il gioco è fatto. Adesso per vedere il risultato, è sufficiente aprire il file creato con un doppiò click e il file verrà aperto come documento ipertestuale nel browser predefinito installato sul computer. Il risultato che dovreste vedere dovrebbe essere il seguente:

Come potete osservare abbiamo creato un documento HTML, che scrive "Hello, World!", però questo testo lo vediamo scritto in due posti: come titolo della finestra del browser e all'interno della pagina. Anche se sembrerebbe che lo faccia in automatico, in realtà siamo stati noi a dire di fare così. Infatti, con <title>Hello, World!</title> abbiamo indicato di nominare la pagina con il testo contenuto tra i due tag, mentre il testo che è stato scritto all'interno della pagina è stato preso dal tag <body>. E in generale, tutto quello che deve essere visualizzato deve essere scritto tra <body> e </body>, mentre tutto ciò che si riferisce all'impostazione della pagina viene messo tra <head> e </head>.

F# - Funzioni ricorsive

2011-12-31T02:04:00.001+01:00

Nel mondo dell'informatica odierna viene spesso incontrata l'espressione di funzione ricorsiva, una funzionalità che possiedono alcuni dei linguaggi di programmazione, molto utile al giorno d'oggi nello sviluppo delle applicazioni, perché permettono di semplificare estremamente il codice di un programma, che utilizza determinate strutture dati.

Vediamo più in dettaglio perché questa funzionalità è così importante al giorno d'oggi. Il motivo più importante che spinge i nuovi linguaggi di programmazione ad avere la possibilità di scrivere funzioni ricorsive è che la correttezza di una funzione ricorsiva è possibile dimostrare matematicamente sfruttando la dimostrazione per induzione, per cui viene resa possibile la ricerca matematica della soluzione ad un problema e la successiva traduzione dell'algoritmo matematico in codice.

Fino ad ora si è parlato delle funzioni ricorsive, ma non è stato ancora detto cosa sono, per cui procediamo con la definizione di esse: una funzione è detta ricorsiva quando nel suo corpo esegue una chiamata a se stessa, ovvero rincorre se stessa come fa il cane con la sua coda.

Ma proviamo a vedere come si fa a creare una funzione ricorsiva in F#. Beh, è molto semplice, perché non ci sono molte differenze rispetto alla definizione di una normale funzione. L'unica differenza sta nel fatto che dobbiamo dichiarare esplicitamente che la funzione che stiamo definendo è una funzione ricorsiva, aggiungendo dopo let la parola chiave rec, inoltre non dobbiamo dimenticarci che la funzione deve richiamare se stessa per almeno una volta:

let rec somma n =
if n<1 then 0
else n+(somma (n-1));;

La funzione somma deve sostanzialmente restituire il risultato della somma di tutti i numeri interi da 0 a n. Ciò viene fatto sommando n alla somma di tutti i numeri da 0 a (n-1). Quando arriviamo alla condizione in cui n<1 restituiamo 0, e il ciclo si interrompe. La funzione può essere capita più facilmente analizzando i passaggi che esegue un compilatore in un esempio:

somma 5 -> (5 non è minore di 1, quindi esegue l'istruzione del ramo else)
5+(somma 4) -> (4 non è minore di 1, quindi esegue l'istruzione del ramo else)
5+(4+(somma 3)) -> (3 non è minore di 1, quindi esegue l'istruzione del ramo else)
5+(4+(3+(somma 2))) -> (2 non è minore di 1, quindi esegue l'istruzione del ramo else)
5+(4+(3+(2+(somma 1)))) -> (1 non è minore di 1, quindi esegue l'istruzione del ramo else)
5+(4+(3+(2+(1+(somma 0))))) -> (0<1, quindi restituisce 0)
5+(4+(3+(2+(1+0))))
5+(4+(3+(2+1)))
5+(4+(3+3))
5+(4+6)
5+10
15

Come potete vedere il risultato restituito dalla funzione è 15, che è uguale alla somma dei numeri interi da 0 a 5. Infatti, se guardiamo il 7° passaggio possiamo identificare proprio la somma dei primi n numeri naturali. E adesso, tolto il dubbio della correttezza della funzione, analizziamo perché è stato possibile arrivare a questo risultato. In pratica noi non abbiamo fatto altro che riutilizzare la funzione stessa, però passandogli un parametro, che è minore di 1 del precedente, finché siamo arrivati alla condizione in cui sappiamo con certezza qual è il risultato che la funzione deve restituire. Questa condizione viene chiamata caso base. A quel punto è diventato possibile il calcolo del risultato della funzione, il cui parametro è maggiore di 1 e così via, fino ad arrivare a n.

Riassumendo, per scrivere una funzione ricorsiva dobbiamo trovare un caso base, ovvero una condizione in cui sappiamo con certezza il risultato della funzione, e richiamare la funzione stessa, modificando il parametro della funzione, per avvicinarlo al caso base, perché se il caso base non si verifica la funzione non termina.

Proviamo adesso a scrivere una funzione fatt, che calcolerà il fattoriale di un certo numero intero n>0. Ma prima di scrivere direttamente il codice della funzione vediamo la definizione matematica del fattoriale:

0! = 1
n! = n * (n-1)!

Partendo da questa definizione matematica, scrivere la funzione fatt sarà un gioco da ragazzi, perché il caso base è quando dobbiamo calcolare il fattoriale di 0, mentre in tutti gli altri casi basta moltiplicare n per il fattoriale di (n-1):

let rec fatt n =
if n=0 then 1
else n*(fatt (n-1));;

La funzione è praticamente identica alla precedente e, una cosa molto bella di F#, se proviamo a tradurre il codice in italiano otteniamo proprio la definizione matematica della funzione fattoriale. E questa è il vero punto di forza della programmazione funzionale.

Ma se da una parte l'impiego delle funzioni ricorsive nella programmazione permette di semplificare notevolmente il codice di un programma, dall'altra parte viene richiesta molta più memoria rispetto alle versioni iterative delle funzioni, che vedremo più avanti.

HTML - I tag e struttura pagina

2011-12-30T02:13:00.002+01:00

Nel post precedente è stato accennato che il linguaggio HTML è stato creato per rendere possibile lo scambio di informazioni tra i computer, mediante documenti ipertestuali, create utilizzando questo linguaggio di programmazione. HTML è un linguaggio di programmazione descrittivo, ovvero un linguaggio nel quale dobbiamo descrivere il risultato che vogliamo ottenere, mentre è il browser si impegnerà a trovare la strada per arrivare al risultato voluto.

I tag

Come è stato detto, il browser ha il compito di capire che cosa vogliamo che venga visualizzato, semplicemente descrivendo il risultato, ma una descrizione a parole in una lingua usata dagli uomini per comunicare sarebbe troppo complicata per il browser, per cui è stato proposto di usare dei tag, ovvero delle parole chiavi, che devono essere racchiuse tra < e >, e che devono portare l'informazione su come deve essere fatta la pagina. In altre parole, useremo i tag per dire al browser cosa vogliamo che venga visualizzato e come vogliamo che quel componente venga visualizzato. Quasi tutti i tag hanno un tag di chiusura, che hanno la forma </tag> e che indica dove finisce l'azione di un determinato tag.

Struttura pagina

Una pagina ipertestuale deve avere una struttura ben definita, affinché venga interpretata correttamente da tutti i browser, per cui esistono alcune regole che devono essere rispettate durante la scrittura di una pagina html. La prima regola da rispettare è quella di chiudere tutti i tag, che hanno un tag di chiudura, in modo da evitare la visualizzazione errata dei componenti della pagina. La seconda è quella di rispettare la struttura ad albero delle pagine ipertestuali, per non interferire con altri elementi dello stesso tipo presenti sulla pagina. E la terza regola è quella di rispettare la struttura base della pagina e mettere ogni elemento della pagina al suo posto.

Vediamo ora come deve essere fatta una pagina html:

<HTML>
<HEAD>
<TITLE> Titolo della pagina </TITLE>
</HEAD>
<BODY>
...
...
...
</BODY>
</HTML>

Proviamo ad analizzare la struttura proposta. Il tag <HTML></HTML> indica che la pagina è una pagina ipertestuale, e serve ad indicare al browser di non interpretare i tag come testo ma come comandi, inoltre deve contenere tutto il contenuto della pagina, per cui non ci deve essere nulla dopo </HTML>. Il secondo tag <HEAD></HEAD> rappresenta la testa della pagina, ovvero contiene le informazioni riguardanti la descrizione della pagina, dove rientra anche il tag <TITLE></TITLE>, che indica il titolo della pagina, che verrà visualizzato nella barra del titolo del browser. Infine, il tag <BODY></BODY> rappresenta il corpo della pagina, cioè l'insieme di tutti gli elementi che verranno visualizzati nel browser.

Il linguaggio HTML non è case sensitive, per cui i tag possono essere scritti sia in maiuscolo che in minuscolo, senza alcuna differenza, inoltre le pagine html non sono altro che documenti di testo, quindi possono essere create anche con un semplice editor di testo come il Notepad(blocco note) presente nei sistemi operativi Windows, però vi consiglio vivamente di utilizzare un editor che sia indirizzato alla scrittura delle pagine html, perché nel corso dello studio verrete aiutati dal programma.

HTML - Introduzione

2011-12-30T01:18:00.000+01:00

HTML - HyperText Markup Language è un linguaggio di programmazione sviluppato alla fine degli anni ottanta da Tim Berners-Lee allo scopo di editare dei ipertesti per poterli poi inviare via Internet. Assieme al linguaggio di programmazione è stato creato un protocollo per la trasmissione di documenti scritti in questo linguaggio, che venne, appunto, chiamato HTTP (HyperText Transfer Protocol). All'inizio non ebbe un grande successo, ma con lo sviluppo di Internet fu vivamente utilizzato e modificato, per soddisfare le esigenze dei web designer.

Con il tempo al linguaggio vennero aggiunte nuove funzionalità e la possibilità di includere codici di altri linguaggi come JavaScript, VBScript, CSS e Java, per rendere le pagine più dinamiche, in modo da interagire con gli utenti, senza dover cambiare pagina. In questo modo il web designer doveva soltanto scrivere le pagine html e pubblicarli su un server, che quando viene fatta una richiesta, deve inviare il contenuto del corrispondente documento ipertestuale, mentre un programma chiamato browser eseguito sul lato del cliente deve occuparsi dell'interpretazione di tale documento.

Tutto questo andava bene per creare delle semplici pagine web, che potevano contenere dei testi, delle immagini e magari contenere qualche elemento grafico o funzionale che interagiva con l'utente, però rivelava un grosso difetto nel momento in cui si voleva creare un sito più complesso, che doveva contenere più pagine, perché tutti i dati dovevano essere inseriti manualmente e diventava estremamente complicato aggiornare un sito, oppure modificare la sua grafica.

Il problema è stato risolto inventando nuovi linguaggi di programmazione lato server, che attraverso un interprete che viene lanciato sul server, permette di generare una pagina diversa a seconda della richiesta che arriva. In questo modo il web designer potrebbe scrivere soltanto una pagina per un sito, perché le parti statiche della pagina possono essere scritte in html, mentre la parte dinamica delle pagine viene scritta in uno dei linguaggi server. I linguaggi lato server attualmente più conosciuti sono PHP, ASP e JSP, che in fondo generano sempre delle pagine html, per poi spedirli al cliente.

F# - Costrutto if e pattern matching

2011-12-29T19:19:00.001+01:00

Il più delle volte, quando si scrive un programma si ricorre all'utilizzo di costrutti condizionali, che permettono di scegliere le istruzioni da eseguire in base ad un valore o al risultato di un confronto. Ciò è possibile grazie ai costrutti if, presente in tutti i linguaggi di programmazione e di pattern matching.

Il costrutto if

Come accennato prima, questo costrutto permette di far eseguire un'istruzione, oppure l'altra in base alla condizione imposta dopo la parola chiave if. Vediamo un esempio di come viene impiegato questo costrutto:

if a>b then a-b else b-a;;

Se proviamo a tradurre letteralmente in italiano, otteniamo la seguente frase: se a>b allora restituisci a-b, altrimenti restituisci b-a. In altre parole quando la condizione restituisce true, allora eseguiamo l'istruzione del ramo then, altrimenti eseguiamo l'istruzione del ramo else.
Se, per esempio, vogliamo restituire il massimo tra due numeri, allora possiamo fare in questo modo:

if a>b then a else b;;

letteralmente, se a è maggiore di b allora restituisci a, altrimenti restituisci b. Quindi se vogliamo scrivere una funzione max, che restituisce il massimo degli argomenti passati in input, avremo:

let max a b =
if a>b then a
else b;;

I pattern matching

I pattern matching sono sostanzialmente dei costrutti condizionali, che confrontano un valore con gli altri, che rappresentano i suoi rami, e una volta trovata la corrispondenza, esegue l'istruzione corrispondente. Volendo si potrebbe anche evitare l'utilizzo di tale costrutto, però il codice diventerebbe meno chiaro, perché saremmo costretti ad usare dei costrutti if annidati (una soluzione poco elegante e poco chiara). Ma vediamo come si utilizzano i pattern matching:

match valore with
corrispondenza1 -> istruzione
| corrispondenza2 -> istruzione
| _ -> istruzione_default;;

In pratica in questo modo confrontiamo valore con le corrispondenze e una volta trovata la corrispondenza eseguiamo l'istruzione scritta dopo ->, inoltre ogni corrispondenza deve essere separata dalle altre tramite il simbolo |. Qualcuno avrà notato che come ultima corrispondenza è stato messo il simbolo _, che in F# indica qualunque cosa e in questo caso sta per tutti gli altri casi e viene usato quando non vogliamo definire tutti i possibili casi. Dobbiamo, inoltre, tenere a mente che le corrispondenze vengono processate nel ordine scritto nel pattern matching e una volta trovata la corrispondenza, vengono ignorate tutte le altre.

L'utilizzo più approfondito di questo costrutto verrà spiegato assieme alle funzioni ricorsive, dove molto spesso viene preferito l'utilizzo di questo costrutto, invece del costrutto if.

F# - Funzioni

2011-12-29T01:29:00.002+01:00

Spesso programmando ci si ritrova di fronte ad un fatto poco gradevole, quale la ripetizione di una sequenza di istruzione all'interno del programma, rendendo il codice poco elegante e comprensibile. Il modo più semplice di evitare che ciò accada è quello di creare delle funzioni, che contengano la sequenza delle istruzioni che si ripetono e raggrupparle sotto un'unico nome. F# è uno dei linguaggi in cui le funzioni vengono usate molto spesso, per cui è un argomento molto importante per chi ha deciso di programmare in questo linguaggio.

Esistono due modi per scrivere una funzione, che in fondo hanno più o meno la stessa identica struttura e differiscono soltanto per il modo in cui viene indicato che si sta per definire una funzione.

Vediamo il primo modo in cui può essere definita una funzione:

let somma = fun a b -> a + b;;

Con questa istruzione abbiamo creato un nuovo nome, che e una funzione e che ha due argomenti a e b. Una volta ottenuti i due argomenti la funzione restituisce la somma di (a+b). In questo modo quando scriviamo il nome somma il compilatore si aspetta che noi gli diamo altri due valori dello stesso tipo e che supportano l'operazione di somma. Di default il compilatore decide che a e b devono essere interi, per cui anche il risultato della funzione sarà un intero.

Il secondo modo per scrivere una funzione è il seguente:

let somma a b = a+b;;

Questo modo è più corto di quello mostrato in precedenza e di conseguenza viene anche maggiormente usato. Dal punto di vista di funzionalità non c'è alcuna differenza tra usare il primo modo, oppure il secondo, perché il concetto è sempre lo stesso, visto che nel primo caso diciamo esplicitamente che la somma corrisponde a una funzione che ha due argomenti, mentre nel secondo caso diciamo che dopo il nome somma ci aspettiamo altri due argomenti, che devono essere di tipo intero, perché nel corpo viene usato l'operatore di somma.

Ma vediamo ora cosa succede se scriviamo la seguente istruzione:

let incrementa = somma 1;;

Proviamo ad analizzare questa istruzione e vedere come si comporta il compilatore di F#. In poche parole viene introdotto il nome incrementa ed è uguale alla funzione somma, però abbiamo indicato che il primo parametro della funzione somma deve valere 1, ma il compilatore si aspetta che alla funzione somma vengano passati due argomenti, quindi il secondo verrà richiesto nel momento in cui chiameremo la funzione incrementa. In questo modo abbiamo ottenuto un'altra funzione, che non fa altro che incrementare di 1 un numero intero, passato come argomento.

E questo è un modo per definire nuove funzioni sulla base di una già definita, mantenendo costante uno dei suoi argomenti.

Per provare ad eseguire queste istruzioni basta aprire Visual Studio e aprire F# Interactive dal menu View->Other Windows->F# Interactive, oppure premere Ctrl+Alt+F. Verrà aperta una nuova finestra come questa:

Subito dopo il carattere > digitate l'istruzione che volete provare, terminando ogni istruzione con ;; e dando Invio. Così scrivendo una delle istruzioni per la creazione della funzione somma otterremo la seguente risposta dal compilatore:

val somma : int -> int -> int

che ci dice che è stato introdotto il nome somma, che prende un argomento di tipo intero, dopodiché ne prende un'altro argomento intero e restituisce un risultato sempre intero. Mentre se proviamo a scrivere l'istruzione relativa alla dichiarazione della funzione incrementa, otteniamo il seguente risultato:

val incrementa : (int -> int)

che ci indica che è stato introdotto il nome incrementa, uguale ad una funzione che prende un argomento di tipo intero e restituisce un valore intero, che guarda caso è proprio lo stampo della funzione incrementa, la quale prende in input un numero intero, lo incrementa di 1 e restituisce il risultato, che è sempre intero.

F# - Variabili e tipi

2011-12-29T00:01:00.001+01:00

Come è stato detto nell'introduzione, F# è un linguaggio giovanissimo, che come abbiamo visto si vanta di alcuni punti di forza rispetto ai linguaggi di programmazione già esistenti. Un'altro punto di forza di questo linguaggio è quello di non dover specificare il tipo della variabile, o meglio, del nome che vogliamo creare, perché è il compilatore a capre il tipo del nome a seconda dei valori che gli viene attribuito, tuttavia non permettendo l'esecuzione di operazioni tra tipi diversi, allo scopo di evitare errori di precisione. Questo comportamento del compilatore facilità notevolmente lo sviluppo dei programmi, specie per i programmatori novellini.

Le variabili (nomi)

In F# dichiarare un nuovo nome è molto semplice, perché il programmatore non deve preoccuparsi del tipo della variabile che andrà a creare, visto che il compilatore si prende la responsabilità di fare questo lavoro, ma nonostante ciò dobbiamo dichiarare esplicitamente che vogliamo introdurre un nuovo nome. Per fare ciò viene usata la parola chiave let, che può essere tradotto in italiano come sia. Vediamo, allora, come vengono dichiarate le variabili:

let numero = 5;;
let decimale = 3.452;;
let booleano = true;;
let carattere = 'a';;
let stringa = "una sequenza di caratteri";;

Dal codice possiamo vedere che ogni riga inizia con la parola let, che dice sia numero uguale a 5 e sia decimale uguale a 3.452 e così via. Dopo questa definizione per il compilatore il nome numero e 5 sono la stessa cosa. Un'altra cosa che si può notare analizzando il codice è che ogni riga finisce con ;;. In questo modo viene indicata la fine dell'istruzione, tuttavia in F# non è strettamente necessario l'utilizzo di questo delimitatore.

Il tipo booleano

Il tipo booleano è un tipo nativo di F#, ovvero è un tipo predefinito, che non deve essere costruito e può essere usato per la reazione di altri tipi, non nativi. Questo tipo rappresenta un insieme che contiene solamente 2 elementi: true e false. Viene usato molto per risolvere problemi di tipo logico, perché possono indicare se una condizione è vera oppure è falsa. Esistono tre operazioni che possono essere applicate ai booleani. Le operazioni booleane sono state elencate e descritte in basso:

Operazione: and

Simbolo: &&

Descrizione: questa operazione può essere fatta tra due valori booleani e come risultato si può ottenere true se entrambi i termini valgono true, oppure false in tutti gli altri casi.

Operazion: or

Simbolo: ||

Descrizione: l'operazione può essere fatta tra due valori booleani e restituisce come risultato false se entrambi i termini valgono false e true altrimenti.

Operazione: not

Simbolo: not

Descrizione: la seguente operazione viene eseguita su un termine di tipo booleano, restituendo come risultato la negazione del suo valore, ovvero se il termine vale true, allora il risultato varrà false e viceversa.

Il tipo intero

Si può intuire dal titolo l'insieme che identifica questo tipo, cioè l'insieme dei numeri interi, ovvero in numeri che vanno teoricamente da -infinito a +infinito, ma in F# sono limitati con un intervallo più stretto, a causa della memoria finita del computer. Ad ogni modo sono i numeri con segno senza la parte decimale, quindi ...,-3,-2,-1,0,1,2,3,... Le operazioni che possono essere applicati a questi tipi sono:

somma: + -> esegue la somma tra numeri interi

sottrazione: - -> esegue la sottrazione tra numeri interi

prodotto: * -> esegue il prodotto tra numeri interi

quoziente: / -> restituisce la parte intera del quoziente
modulo: % -> restituisce il resto della divisione

Il tipo float

Questo tipo nativo rappresenta l'insieme dei numeri con virgola mobile, ovvero l'insieme dei numeri decimali, con l'eccezione di avere un insieme finito a causa del limite imposto dalla memoria. Le operazioni che si possono eseguire con i numeri con virgola mobile sono le stesse dei numeri interi, tranne il modulo, perché nei numeri decimali non c'è il resto della divisione. D'altronde per i numeri float c'è l'operatore per l'elevamento a potenza, che si indica con **. Però bisogna tener ben presente il fatto che non possono essere eseguite operazioni su termini che sono di tipi diversi. Ma a questo punto sorge un problema, perché se per esempio come risultato di una operazione abbiamo ottenuto un valore intero, però dopo dobbiamo eseguire un'operazione di cui un termine è intero e l'altro è float, come facciamo? La risposta è molto semplice: usiamo la funzione float(int), che converte un numero intero in uno di tipo float, oppure la funzione int(float), che permette di convertire un numero con virgola mobile in un numero intero. In questo modo il programmatore è costretto a decidere quale tipo devono avere i termini prima di eseguire un'operazione, evitando errori di precisione.

Il tipo carattere

Spesso nella programmazione viene incontrata la necessità di utilizzare il tipo carattere, ad esempio per confrontare due parole, che non è altro che una sequenza di caratteri. In F# ci sono 256 caratteri diversi, nominati anche caratteri ASCII. Essi comprendono le cifre, le lettere minuscole e maiuscole del alfabeto inglese e del alfabeto cirillico, inoltre contengono una serie di caratteri speciali, come lo spazio, il punto la virgola e cosi via. Ad ogni carattere corrisponde un codice, che non è altro che un numero intero da 0 a 255, che identifica quel particolare carattere. Visto che esiste la corrispondenza tra tipi interi e caratteri esiste anche la possibilità di convertire l'uno nel corrispondente dell'altro mediante le funzioni int(char) e char(int). L'unica operazione che può essere eseguita su di un carattere è l'operazione di somma, che permette di ottenere un'altro carattere, però appartenente ad un'altro insieme di caratteri, chiamato Unicode, che contiene tutti i caratteri del codice ASCII e gli alfabeti delle lingue del mondo.

Il tipo stringa

La stringa non è altro che una sequenza di caratteri. Esso è un tipo molto usato nella programmazione, perché nel momento in cui il programma deve comunicare qualche cosa all'utente in modo testuale, vengono usate le stringhe. Inoltre, F# possiede già un insieme di funzioni per permettere al programmatore di eseguire diverse operazioni sulle stringhe, senza doverle definire. L'operazione di base che può essere eseguito sulle stringhe è l'operazione di concatenazione, la cui funzione è di restituire una stringa formata dalla prima, seguita dalla seconda. Questa operazione può essere fatta mediante l'operatore +.

Gli operatori di confronto

Oltre agli operatori presentati in precedenza, che permettono di calcolare un nuovo valore dello stesso tipo esistono anche operatori di confronto, che dati due termini dello stesso tipo restituiscono un valore booleano. Questi operatori sono applicabili a tutti i tipi nativi e restituiscono sempre un valore true oppure false. Gli operatori di confronto sono 6:

uguale: = -> true se i termini sono uguali
non uguale: <> -> true se i termini non sono uguali
maggiore: > -> true se il termine a sinistra è maggiore di quello a destra
minore: < -> true se il termine a sinistra è minore di quello a destra
maggiore o uguale: >= -> true se il termine a sinistra è maggiore o uguale a quello di destra
minore o uguale: <= -> true se il termine a sinistra è minore o uguale a quello di destra

Gli operatori di confronto vengono usati molto per eseguire delle scelte in base ai valori che abbiamo e scegliere di eseguire un'istruzione o un gruppo di istruzioni, oppure un'altra istruzione o gruppo di istruzioni.

OpenGL in C/C++ - Impostazione progetto

2011-12-21T19:08:00.942+01:00

Per lavorare con OpenGL abbiamo bisogno di un elemento grafico come la finestra, per cui il primo passo da fare è aprire Dev C++ e creare un nuovo progetto di tipo Windows Application, e scegliere come linguaggio di programmazione C++, perché così possiamo utilizzare le funzionalità sia di C che di C++. L'ambiente di sviluppo genererà in automatico il codice per la creazione della finestra e della procedura principale per la gestione dei messaggi della finestra.

Per avere un progetto più ordinato possiamo suddividerlo in più file che conterranno un certo gruppo di funzioni, perciò ci serve un header file per contenere le definizioni delle funzioni, mentre creeremo dei file di estensione *.cpp, che conterranno i costruttori delle funzioni. Ai file da aggiungere ho deciso di dare i seguenti nomi:

functions.h - sarà il nostro file header e conterrà i nomi delle funzioni da noi definite
init.cpp - il file che conterrà i costruttori delle funzioni che ci serviranno per l'inizializzazione di OpenGL
draw.cpp - conterrà i costruttori delle funzioni necessarie per il disegno nella finestra

Per aggiungere un nuovo file al progetto basta andare in Project->New file.
A questo punto dobbiamo modificare le #include del nostro progetto sostituendo con quelli elencati in basso, nei file indicati nel codice:

// main.cpp
#include "functions.h"

// functions.h
#include <windows.h>
#include <gl/gl.h>
#include <gl/glu.h>

// init.cpp
#include "functions.h"

// draw.cpp
#include "functions.h"

Adesso dobbiamo dire al compilatore di importare le librerie che ci servono per utilizzare le funzioni definite nei header di OpenGL. Per questo dobbiamo andare in Project->Project Options e selezionare la scheda Parameters. Nella terza colonna sotto nome Linker aggiungere le seguenti righe:

../../../../../../../Dev-Cpp/lib/libopengl32.a
../../../../../../../Dev-Cpp/lib/libglaux.a
../../../../../../../Dev-Cpp/lib/libglu32.a
../../../../../../../Dev-Cpp/lib/libglut.a
../../../../../../../Dev-Cpp/lib/libglut32.a

Come risultato dovreste avere la seguente schermata:

Dopodiché dovete premere su ok per terminare la procedura. Adesso il compilatore sa dove andare a prendere il corpo delle funzioni di OpenGL che utilizzeremo nei nostri progetti.

Il passo successivo è quello di andare a impostare la finestra per rendere possibile il disegno su di essa da parte di OpenGL, per questo dobbiamo creare alcune variabili globali, che metteremo subito prima della funzione WinMain:

bool fullscreen = false; /* indica se vogliamo una finestra a schermo intero, oppure una finestra normale */
int width = 800; /* la larghezza della finestra */
int height = 600; /* l'altezza della finestra */
int bits = 32; /* il numero di bit per pixel che determinera` anche il numero di colori a disposizione e quindi la qualita` dell'immagine */
bool keys[256]; /* l'array di booleani ci permettera` di rilevare i tasti premuti, anche se contemporaneamente */
bool left_down = false; /* indica se è premuto il pulsante sinistro del mouse */
int x = 400; /* la posizione orizzontale del mouse */
int y = 300; /* la posizione verticale del mouse */
HDC hDC; /* l'HDC della finestra sulla quale disegneremo */

Le prime quattro righe servono sostanzialmente per impostare la modalità di visualizzazione della vostra applicazione. Le tre variavili width, height e bits ci serviranno per impostare la risoluzione dello schermo nel caso in cui andremo nella modalità fullscreen, mentre la variabile booleana fullscreen indicherà se vogliamo andare nella modalità fullscreen, oppure visualizzare l'applicazione nella modalità windowed.

Le successive tre variabili ci serviranno, invece, per determinare i tasti premuti e la posizione del mouse, visto che la procedura del disegno verrà effettuata in un'altra funzione, per non fare confusione. Quindi l'array keys verrà inizializzato a false per indicare che nessun tasto della tastiera è stato premuto e nel momento in cui viene premuto un tasto metteremo a true l'elemento il cui indice corrisponde al codice del tasto premuto. In questo modo ci assicuriamo di rilievare la pressione su più tasti. E come si è potuto capire le variabili x e y memorizzerano la posizione del mouse, che ci servirà nei casi in cui vorremo effettuare delle operazioni con il mouse. Mentre, invece, la variabile booleana left_down ci indicherà se è premuto il bottone sinistro del mouse ed non è stato rilasciato.

L'ultima variabile è molto importante, perché rappresenterà il handle al device context, ovvero l'accesso al dispositivo grafico che gestirà il processo di disegno della nostra finestra.

Per semplificare il codice del programma aggiungiamo altre tre variabili, però questa volta nel corpo della funzione WinMain:

RECT wndrect; /* necessaria per impostare la modalità di visualizzazione */

DWORD dwExStyle; /* conterrà il parametro ExStyle alla creazione della finestra principale */

DWORD dwStyle; /* conterrà lo stile della finestra principale */

La prima variabile ci servirà per impostare la dimensione della finestra nel caso in cui visualizzeremo l'applicazione della modalità windowed. dwExStyle ci servirà per memorizzare lo stile esteso della finestra a seconda della modalità di visualizzazione della finestra. Mentre dwStyle avrà il compito di contenere lo stile della finestra, anch'esso determinato in base alla modalità di visualizzazione.
Per quanto riguardo la classe della finestra, possiamo lasciare il codice generato da Dev C++.
Il passo successivo è quello di registrare la classe creata, che viene effettuata mediante la funzione RegisterClassEx(WNDCLASSEX). La funzione la mettiamo come condizione di un costrutto if, per avere immediatamente il risultato della registrazione e fermare il programma nel caso di fallimento. Per fare ciò inseriamo le seguenti righe di codice:

if (!RegisterClassEx (&wincl)){ /* in caso di fallimento */
MessageBox(NULL,
TEXT("Errore registrazione classe finestra"),
TEXT("Errore"),MB_OK); /* visualizza messaggio di errore */
return 0; /* esce dal programma */
}

Una volta verificato che la classe della finestra sia stata registrata procediamo con il riempimento della variabile wndrect, che è una struttura di tipo RECT e ci servirà per determinare l'area della finestra, nella quale potremo disegnare dopo l'impostazione della modalità di visualizzazione di essa. Il codice per il riempimento di questa struttura lo trovate di seguito:

wndrect.left = (long)0;
wndrect.top = (long)0;
wndrect.right = width;
wndrect.bottom = height;

In questo modo abbiamo definito la dimensione dell'area interna della finestra sulla quale andremo a disegnare, che nel caso della modalità fullscreen rappresenta la dimensione della finestra stessa, mentre nel caso in cui siamo nella modalità windowed rappresenta soltanto la parte interna, escludendo i bordi e l'intestazione.

Fatto ciò procediamo con l'impostazione della modalità di visualizzazione, quindi dobbiamo vedere se vogliamo andare nella modalità fullscreen e nel caso affermativo riempiamo una struttura di tipo DEVMODE, dopodiché con la funzione ChangeDisplaySettings(*DEVMODE,int) cambiamo la risoluzione dello schermo a quella da noi richiesta. Per fare ciò creiamo una nuova funzione nel file init.cpp:

bool set_fullscreen(int width, int height, int bits){
DEVMODE dmScreenSettings;
memset(&dmScreenSettings,0,sizeof(dmScreenSettings));
dmScreenSettings.dmSize = sizeof(dmScreenSettings);
dmScreenSettings.dmPelsWidth = width;
dmScreenSettings.dmPelsHeight = height;
dmScreenSettings.dmBitsPerPel = bits;
dmScreenSettings.dmFields = DM_PELSWIDTH | DM_PELSHEIGHT | DM_BITSPERPEL;
if (ChangeDisplaySettings(&dmScreenSettings,CDS_FULLSCREEN)!=
DISP_CHANGE_SUCCESSFUL){
MessageBox(NULL,
TEXT("Impossibile passare alla modalitа fullscreen"),
TEXT("Errore"),MB_OK | MB_ICONERROR);
return false;
}
return true;
}

In questo modo quando chiamiamo la funzione set_fullscreen appena definita riempiamo una struttura di tipo DEVMODE, per poi utilizzarla nella funzione ChangeDisplaySettings, che cambierà la risoluzione dello schermo. Ma nel caso in cui la risoluzione scelta non sia disponibile sul computer usato, viene visualizzato un messaggio di errore e la funzione termina restituendo false, che determina il relativo comportamento del programma, altrimenti esce restituendo true. Naturalmente la definizione della funzione deve essere fatta anche nel file functions.h, che viene fatta semplicemente aggiungendo la seguente riga di codice:

bool set_fullscreen(int width, int height, int bits);

A questo punto nel file main.cpp scriviamo:

if (fullscreen){ /* se è richiesta la modalità fullscreen */
  /* richiamiamo la funzione definita in init.cpp */
fullscreen = set_fullscreen(width,height,bits);
}
if (fullscreen){ /* se il dispositivo supporta il fullscreen */
  /* Visualizza la finestra sopra la barra delle applicazioni */
dwExStyle = WS_EX_APPWINDOW;
dwStyle = WS_POPUP; /* la finestra è una popup */
ShowCursor(false); /* nasconde il cursore quando è fullscreen */
}else{ /* se siamo nella modalità windowed */
dwExStyle = WS_EX_WINDOWEDGE | WS_EX_APPWINDOW;
dwStyle = WS_OVERLAPPEDWINDOW; /* la finestra ha i bordi */
}
/* adatta la dimensione della finestra alla dimensione indicata dalla struttura wndrect e a seconda dello stile della finestra */
AdjustWindowRectEx(&wndrect,dwStyle,false,dwExStyle);

E adesso possiamo procedere con la creazione della finestra principale, sulla quale andremo a disegnare. Nel codice generato abbiamo già la chiamata alla funzione che crea la finestra, però dobbiamo applicare qualche modifica per crearla in base ai valori delle variabili globali definite all'inizio del programma:

hwnd = CreateWindowEx(dwExStyle, /* lo stile esteso */

           szClassName,  /* nome della classe della finestra */

           TEXT("Model Editor"), /* titolo della finestra */

           dwStyle | WS_CLIPSIBLINGS | WS_CLIPCHILDREN, /* stile */

           CW_USEDEFAULT, /* posizione orizzontale definito da windows */

           CW_USEDEFAULT, /* posizione verticale definito da windows */ 

           wndrect.right-wndrect.left, /* larghezza finestra */

           wndrect.bottom-wndrect.top, /* altezza finestra */

           HWND_DESKTOP, /* la finestra padre */

           NULL, /* nessun menu */

           hThisInstance, /* istanza del programma */

           NULL); 

Con questa istruzione abbiamo creato la nostra finestra principale, che ha le impostazioni da noi richieste, quindi dobbiamo procedere con l'inizializzazione di OpenGL. Il primo passo da fare in questa direzione è quello di impostare le caratteristiche dei pixel di cui è formata la nostra area di disegno. Quindi andremo a definire una nuova funzione che fa questo lavoro e visto che anche questa parte si riferisce all'inizializzazione, la scriveremo dentro init.cpp:

GLvoid SetGLPixelFormat(HWND hwnd, int bits){
GLuint pxFormat;
HDC hDC;
HGLRC hRC;
  /* definisce il formato dei pixel */
static PIXELFORMATDESCRIPTOR pfd = {
sizeof(PIXELFORMATDESCRIPTOR), /* dimensione struttura*/
1, /* numero della versione */
PFD_DRAW_TO_WINDOW | /* supporta le finestre */
PFD_SUPPORT_OPENGL | /* supporta opengl */
PFD_DOUBLEBUFFER, /* supporta la doppia bufferizzazione */
PFD_TYPE_RGBA, /* richiesto un fromato RGBA */
bits, /* numero di bit per pixel */
0, 0, 0, 0, 0, 0, /* bit di colore ignorati */
0, /* nessun buffer per la trasparenza */
0, /* shift bit ignorato */
0, /* nessun buffer di accumulazione */
0, 0, 0, 0, /* bit di accumulazione ignorati */
16, /* buffer a 16 bit per la profondità */
0, /* nessun buffer per la matrice */
0, /* nessun buffer ausiliario */
PFD_MAIN_PLANE, /* disegno sul livello principale */
0, /* riservato */
0, 0, 0 /* maschere di livello ignorate */
};
hDC = GetDC(hwnd); /* cattura l'HDC della finestra principale */
pxFormat = ChoosePixelFormat(hDC,&pfd); /* sceglie il formato dei pixel */
SetPixelFormat(hDC,pxFormat,&pfd); /* imposta il formato dei pixel */
hRC = wglCreateContext(hDC); /* crea un contesto grafico */
wglMakeCurrent(hDC,hRC); /* lo imposta come corrente */
}

Creata la funzione, dobbiamo aggiungere la sua definizione al file functions.h, in modo che sia visibile a tutti i file del progetto, quindi aggiungiamo la seguente riga:

GLvoid SetGLPixelFormat(HWND hwnd, int bits);

A questo punto basta richiamarla nel file main.cpp:

SetGLPixelFormat(hwnd,bits); /* imposta il formato dei pixel */
ShowWindow(hwnd,nCmdShow); /* !!! generata dal ambiente di sviluppo */

Dopo aver visualizzato la finestra procediamo con l'inizializzazione di opengl e del modo in cui verranno visualizzate le figure disegnate con questa libreria. E anche questa volta creiamo una funzione esterna per fare questo lavoro, inoltre, definiamo un'altra funzione, che si occuperà di impostare la prospettiva a seconda della dimensione della finestra. Entrambe le funzioni andranno scritte in init.cpp:

int InitGL(GLvoid){
/* imposta il colore di pulizia dello schermo */
glClearColor(0.0f,0.0f,0.0f,0.5f);
glClearDepth(1.0f); /* la profondità della pulizia */
/* abilita la scrittura sul buffer di profondità */
glEnable(GL_DEPTH_TEST);
return 0; /* se tutto va bene termina con lo 0 */
}

GLvoid ResizeGLScene(GLsizei width, GLsizei height){
height = height==0?1:height; /* evita divisione per zero */
glViewport(0,0,width,height); /* imposta la vista */
/* seleziona la matrice della progettazione */
glMatrixMode(GL_PROJECTION);
glLoadIdentity(); /* resetta la matrice */
/* calcola la prospettiva con la profondità massima a 100 */
gluPerspective(45.0f,(GLfloat)width/(GLfloat)height,
1.0f,100.0f);
/* seleziona la matrice di visualizzazione delle figure */
glMatrixMode(GL_MODELVIEW);
glLoadIdentity(); /* resetta la matrice */
}

Ovviamente al file functions.h dovremo aggiungere:

int InitGL(GLvoid);
GLvoid ResizeGLScene(GLsizei width, GLsizei height);

Come è possibile notare, in queste due funzioni per la prima volta abbiamo usato delle funzioni che appartengono alla libreria OpenGL. Vediamo in breve cosa rappresenta ognuna di queste funzioni:

glClearColor - specifica il colore che verrà utilizzato per cancellare l'immagine disegnata precedentemente sullo schermo. I quattro parametri di tipo GLfloat possono assumere valori da 0.0f a 1.0f e rappresentano il colore espresso in RGBA, un formato che permette di definire anche la trasparenza di un colore.

glClearDepth - indica la profondità alla quale viene effettuata la pulizia dello schermo, cancellando tutto ciò che sta oltre a quella profondità. Bisogna tenere conto del fatto che OpenGL si prende la briga di occuparsi della visualizzazione delle figure nello spazio, per cui il programmatore deve soltanto indicare le coordinate di ogni figura e OpenGL deciderà quale parte della figura visualizzare e quale no, a seconda se viene coperta da un'altra figura che ci copre la vista. Inoltre, si deve tenere a mente il fatto che se vogliamo indicare una profondità di 10.0f, dobbiamo indicarla come -10.0f, perché tutto ciò che vogliamo visualizzare si trova oltre lo schermo, cioè sulla parte negativa dell'asse z.

glEnable(GL_DEPTH_TEST) - abilita l'utilizzo del buffer di profondità. In genere la funzione glEnable viene utilizzata per abilitare diverse funzionalità della libreria, come, ad esempio, l'abilitazione della luminosità o della visualizzazione delle texture.

glViewport - viene utilizzata per impostare i parametri utilizzati per la trasformazione delle immagini di un ambiente tridimensionale in uno bidimensionale, per produrre la sensazione di avere un mondo 3D dietro lo schermo.

glMatrixMode() - seleziona una delle matrici utilizzate per la generazione dell'immagine 3D desiderata. Le due matrici finora utilizzate sono la matrice di visualizzazione e la matrice della gestione delle figure dell'ambiente tridimensionale. La prima, chiamata projection matrix viene utilizzata per produrre le immagini 2D partendo dall'ambiente 3D, in modo da poterle visualizzare sullo schermo, che rappresenta, appunto, un ambiente bidimensionale. La seconda, invece, chiamata modelview matrix che serve per definire il posizionamento delle figure in un ambiente 3D.

glLoadIdentity() - utilizzata molto spesso, perché permette di reimpostare la matrice sulla quale si sta lavorando ad una matrice identica, che rappresenta la situazione iniziale.

gluPerspective - imposta i parametri della prospettiva da usare, il primo argomento indica il tipo di prospettiva a 45°, il secondo indica il rapporto larghezza/altezza, il terzo e il quarto indicano il minimo e il massimo della profondità, oltre la quale la figura sparisce.

Chiusa la parentesi, procediamo con il nostro programma. Sempre nel file main.cpp subito dopo la visualizzazione della finestra facciamo una chiamata alla funzione InitGL, seguita dalla chiamata alla funzione ResizeGLScene, dopodiché scriviamo il codice generato da Dev C++, leggermente modificato, per integrarsi con OpenGL. Le modifiche da efettuare stanno nel ciclo di elaborazione dei messaggi. Vediamo il codice:

InitGL();
ResizeGLScene(width,height);
hDC = GetDC(hwnd); /* ottiene l'HDC della finestra */
bool done = false; /* tiene aperto il ciclo */
while (!done){
/* cattura gli eventi della finestra */
if (PeekMessage(&messages,NULL,0,0,PM_REMOVE)){
/* se arriva il messaggio di chiusura */
if (messages.message==WM_QUIT){
done = true; /* esce dal ciclo e chiude il programma */
}
TranslateMessage(&messages); /* decodifica il messaggio */
DispatchMessage(&messages); /* lo invia a WindowProcedure */
}else{ /* se non ci sono messaggi */
/* disegna la scena da visualizzare */
if (DrawGLScene(keys,x,y,left_down)){
SwapBuffers(hDC); /* scambia il buffer */
}
}
}

Con questo abbiamo concluso la definizione della funzione WinMain, però ciclo di elaborazione dei messaggi abbiamo utilizzato la funzione DrawGLScene, che non abbiamo ancora definito, per cui andiamo subito a definirla. Visto che questa funzione ci serve per disegnare nella finestra andremo a definirla nel file draw.cpp, finora non utilizzato:

bool DrawGLScene(bool keys[], int x, int y, bool left_down){
glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT);
glLoadIdentity(); /* reimposta la matrice */
glTranslatef(0.0f,0.0f,-5.0f);
glBegin(GL_QUADS);
glVertex3f(-1.0f,1.0f,0.0f);
  glVertex3f(1.0f,1.0f,0.0f);
  glVertex3f(1.0f,-1.0f,0.0f);
  glVertex3f(-1.0f,-1.0f,0.0f);
glEnd();
return true;
}

Come per le altre funzioni definite esternamente anche questa deve essere dichiarata in functions.h:

bool DrawGLScene(bool keys[], int x, int y, bool left_down);

Abbiamo creato un'altra funzione, ma vediamo un attimo come è fatta:

glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT) - la seguente funzione della libreria OpenGL esegue la pulizia dello schermo alla profondità indicata. Viene fatta subito prima di disegnare un'altra immagine.

glTranslatef - trasla l'origine delle coordinate al punto indicato nelle coordinate, per cui ogni figura disegnata dopo questa istruzione verrà posizionata rispetto al nuovo origine. La funzione prende in input 3 parametri che indicano le coordinate x, y e z rispettivamente, che devono essere di tipo float. Esistono varie versioni di questa funzione: glTranslatei, glTranslated, che prendono in ingresso interi.

glBegin(GL_QUADS) - indica l'inizio della definizione delle coordinate dei vertici di una figura, che in questo caso è una quadrica, ma possono essere linee, triangoli, poligoni, a seconda del valore passato alla funzione. In base alla figura che si vuole disegnare cambia anche il numero di vertici che dobbiamo definire.

glVertex3f - definisce un vertice della figura che viene disegnata. La funzione, analogamente a glTranslatef, prende in ingresso 3 parametri di tipo float, che rappresentano le coordinate del vertice rispetto all'origine corrente. Anch'essa può prendere in input più tipi di dati, a seconda dell'ultima lettera del nome, che indica, appunto, il tipo dei dati.

glEnd() - indica la fine della definizione della figura.

Ormai siamo quasi arrivati alla fine, perché ci resta soltanto aggiungere qualche ramo allo switch di WindowProcedure, che si trova in main.cpp, per gestire gli eventi di movimento del mouse, della pressione dei tasti e del ridimensionamento della finestra. Quindi aggiungiamo allo switch il seguente codice:

case WM_SIZE:
/* ricalcola la prospettiva e la dimensione dell'ambiente a seconda della dimensione della finestra */
ResizeGLScene(LOWORD(lParam),HIWORD(lParam));
break;
case WM_MOUSEMOVE:
x = LOWORD(lParam); /* memorizza la posizione orizzontale del mouse */
y = HIWORD(lParam); /* memorizza la posizione verticale del mouse */
break;
case WM_KEYDOWN:
  /* imposta a true l'elemento con il codice del tasto premuto */
keys[wParam]=true;
break;
case WM_KEYUP:
  /* imposta a false l'elemento con il codice del tasto premuto */
keys[wParam]=false;
break;
case WM_LBUTTONDOWN:
  /* mette a true alla pressione del bottone sinistro del mouse */
left_down = true;
break;
case WM_LBUTTONUP:
  /* mette a false al rilascio del bottone sinistro del mouse */
left_down = false;
break;

Così abbiamo completato il programma, che deve soltanto disegnare una quadratica (quadrato nel nostro caso), e quindi possiamo eseguirlo, ottenendo il seguente risultato:

Qualcuno di voi si sarà chiesto perché fare tutto questo lavoro per avere soltanto un quadrato, quando è possibile disegnare direttamente sulla finestra? Ma la risposta è molto semplice, perché una volta inizializzata la libreria OpenGL possiamo disegnare facilmente diverse figure, avendo uno spazio tridimensionale e avendo a disposizione le funzioni necessarie per muovere, ruotare etc. le figure create, oltre che ad una notevole velocità del programma, dato che OpenGL ha accesso diretto all'interfaccia hardware che si occupa della grafica.

Download progetto Dev C++: impostazione_opengl.zip

OpenGL in C/C++ - Introduzione

2011-12-21T18:49:00.002+01:00

OpenGL è una libreria di C/C++ sviluppata appositamente per lo sviluppo di applicazioni grafiche, che comprendono elementi di disegno bidimensionale che il disegno di oggetti in 3D. Questa libreria è molto conosciuta nel giro degli sviluppatori di videogiochi, perché tale libreria permette lo sviluppo di applicazioni adatte a girare su più piattaforme, cosa che non si può dire del DirectX, sviluppato per la scrittura di programmi grafici che girano sotto Windows.

Il vantaggio di usare questa libreria è dovuto al fatto che essa propone una serie di funzioni già pronte per gestire il disegno in 2D e in 3D. Inoltre, la libreria possiede delle funzioni vitali nello sviluppo dei videogiochi, quali la rotazione, il movimento degli oggetti creati e la gestione automatica della prospettiva in base alla posizione degli oggetti nello spazio. Non è da meno il fatto che per la visualizzazione dei frame OpenGL accede direttamente alla componente hardware che risponde della visualizzazione, incrementando notevolmente la velocità di elaborazione delle immagini e quindi anche la velocità delle vostre applicazioni.

Per avere una maggiore affluenza ho deciso di utilizzare Dev C++ per la scrittura degli esempi pubblicati negli articoli, perché è un ambiente di sviluppo gratuito e contiene già la libreria OpenGL. Nonostante ciò cercherò di mettere le informazioni necessarie per gli sviluppatori che usano Visual Studio, ampliando la spiegazioni con i link ai progetti degli esempi sviluppati in entrambi gli ambienti di sviluppo.

Gli articoli di questa categoria sono indirizzati ai programmatori che hanno una buona conoscenza di C/C++ e dello sviluppo delle applicazioni API in questi linguaggi, in quanto verranno affrontati soltanto argomenti relativi alla libreria OpenGL e non al linguaggio di programmazione.

C/C++ - Lettura testo dalla tastiera

2011-12-21T14:07:00.011+01:00

Nel post precedente ho spiegato come creare il nostro primo programma in C/C++, che scrive in output il famoso saluto "Hello, World!", ma non abbiamo ancora visto come fare a leggere del testo dalla tastiera. Beh, non è una cosa molto difficile, perché basta importare la libreria che ci interessa e utilizzare la funzione per la lettura del tasto premuto.

Il modo più semplice è quello di usare un name space introdotto con il C++ chiamato cin che sta per c input, ovvero lettura dai dispositivi di input. Vediamo ora il codice che ci permette di fare questa lettura:

Come possiamo vedere la struttura generale dei programma resta uguale a quella del programma di "Hello, World!", cambiando soltanto il corpo della funzione main.

Da notare è che con '//' viene indicato l'inizio di un commento su una riga e tutto ciò che sta dopo '//' fino alla fine della riga verrà ignorato dal compilatore. Se, invece, vogliamo scrivere un commento su più di una riga dobbiamo indicare l'inizzio e la fine del commento con '/*' e '*/' rispettivamente.

Vediamo in dettaglio cosa fa ognuna delle istruzioni del corpo della nostra funzione:

char buff[255] - crea un array lungo 255 elementi di tipo char. In altre parole viene riservata una locazione di memoria per la scrittura di contenuti di tipo char(carattere), la cui lunghezza è, appunto, 255. E` importante sapere che in C/C++ gli array di caratteri vengono interpretati come stringhe e anche se sono stati creati nuovi tipi che rappresentano le stringhe, questo tipo di rappresentazione viene usata molto, soprattutto da quelli che sono agli inizi.

cout << "Digita qualcosa: " - con questa istruzione viene scritto in output il testo che segue dopo '<<'. Nell'esempio di "Hello, World!" abbiamo visto come scrivere del testo sullo schermo utilizzando la funzione printf, mentre qui ho deciso di mostrarvi come è possibile fare la stessa cosa, utilizzando le novità introdotte con l'avvento di C++. In questo esempio è stato usato il name space cout, dichiarato con la 4° riga del codice, dicendo di utilizzare il name space std(standard), che reindirizza con l'operatore '<<' il flusso di dati in output, inviando tutto quello che sta dopo tale operatore. Il risultato è la scrittura sullo schermo del testo "Digita qualcosa: ".

cin.getline(buff,255) - con questa istruzione, riusciamo a leggere una linea di testo inserito dalla tastiera, cioè il testo digitato fino alla pressione del tasto 'Invio'. Come possiamo notare la variabile cin non è stata dichiarata da nessuna parte, nonostante ciò l'abbiamo utilizzata, perché anche essa è un name space come cout, però per gestire il flusso in input, che nel nostro caso è il testo digitato sulla tastiera. Il punto messo dopo cin indica che esso è un oggetto, che ha degli metodi, o in altre parole su di esso possono essere effettuate delle operazioni, che nel nostro caso è la lettura di una linea dal prompt dei comandi. Il metodo getline ha due argomenti di cui il primo indica la variabile di tipo stringa(nel nostro caso un array di caratteri) nella quale andare a scrivere la sequenza dei caratteri premuti sulla tastiera, mentre il secondo argomento indica la lunghezza della stringa.

cout << "Hai scritto: " << buff << endl - anche in questo caso viene usato il name space cout per scrivere il output, però questa volta abbiamo più operatori '<<', che come se fossero degli '+' per concatenare tutti i termini. Infatti, in output avremo prima il testo "Hai scritto: ", dopodiché seguirà il contenuto di buff, in cui è memorizzato il testo scritto da noi e infine endl, che non è altro che una costante che indica la fine della linea e porta il cursore a capo di una nuova.

Adesso se provate ad eseguire il vostro programma dovreste vedere il seguente output:

Il programma sembra essere coretto, però se provate a digitare più di 255 caratteri il testo digitato viene troncato a 255 caratteri. Certo, potremo aumentare la lunghezza dell'array buff, però non possiamo sapere la lunghezza del testo che verrà inserito dall'utente e poi facendo così andremo a sprecare memoria. Questo problema è dovuto al fatto che in C nel momento della dichiarazione di un array dobbiamo indicare la sua lunghezza. Il problema può essere risolto con l'aiuto dei puntatori e lo vedremo più avanti, ma questo è un altro argomento.

Download progetto Dev C++ lettura_tastiera.zip.

Non dimenticate del +1 :)

C/C++ - Hello, World!

2011-12-20T19:36:00.005+01:00

Nel post C/C++ - Introduzione sono state spiegate a grande linee le caratteristiche di C/C++, ma non abbiamo ancora visto come scrivere il famoso "Hello, World!" in questi linguaggi, per cui procedo immediatamente con la spiegazione, ma prima di iniziare dovete procurarvi un compilatore, che tradurrà il vostro codice in programmi eseguibili.

Un ottimo IDE, cioè un ambiente di sviluppo, che naturalmente ha integrato anche un compilatore C++ è il Dev C++ scaricabile gratuitamente da qui. Per chi vuole invece un ambiente di sviluppo più professionale può procurarsi il Visual Studio della Microsoft, che però non è gratuito.

Comunque, a prescindere dal ambiente di sviluppo il procedimento è molto simile e differisce solo in alcune situazioni, dovute alle divergenze tra le librerie dei due ambienti di sviluppo, ma per adesso non preoccupiamoci della cosa e procediamo con il nostro "Hello, World!".

Ho deciso di illustrare lo sviluppo dei programmi utilizzando Dev C++, ma ripeto il procedimento è molto simile anche per Visual Studio e in questo caso non ci sono divergenze nel codice. Quindi apriamo il nostro ambiente di sviluppo e andiamo in File->New->Project e subito dopo si apre una nuova finestra dove scegliamo Console Application. Nella casella di testo in basso inserite il nome del progetto che volete creare e scegliete il linguaggio in quale volete scrivere il vostro programma (vi consiglio C++), dopodiché date l'ok. L'ambiente di sviluppo genera il seguente codice:

Se eseguito, questo programma sostanzialmente non fa nulla, ma nonostante ciò è un programma funzionante. Questo formato di programma di default è stato introdotto con l'arrivo di C++.

Riassumendo con le prime due righe vengono caricate due librerie che contengono le funzioni già definite per poter eseguire alcune operazioni di base come la scrittura sull'output oppure la lettura dei tasti premuti sulla tastiera.

La 4° riga, invece, definisce una serie di nomi che potremo utilizzare per eseguire velocemente operazioni di input/output e altro.

Nella 6° riga viene fata la definizione della funzione funzione, chiamata main, che rappresenta il punto di entrata nel nostro programma e il nome di questa funzione deve essere necessariamente main. La prima parola di questa riga (int) indica che al termine della funzione deve essere restituito un valore intero, che indicherà il codice d'uscita, dal quale il sistema operativo può capire se il programma è terminato con successo, oppure si è verificato un errore durante l'esecuzione del programma. I due argomenti della funzione argc e argv non sono vitali, cioè si possono anche omettere, ma sono necessari nei casi in cui al programma vengono passati argomenti dalla linea di commando (Prompt dei comandi in Windows).

Tutto ciò che è compreso tra { e } viene chiamato corpo della funzione e le istruzioni contenute nel corpo della funzione vengono eseguite dal alto verso il basso nel momento in cui viene fatta una chiamata a tale funzione. Quindi quando eseguite il vostro programma il sistema operativo non fa altro che chiamare quella funzione.

L'ottava riga del codice non fa altro che inviare un comando al prompt dei comandi di mettersi in pausa e attendere la pressione di un tasto prima di terminare il programma. Questa funzione fa parte della libreria cstdlib.h, per cui nella prima riga l'abbiamo inclusa nel nostro progetto.

La 9° riga rappresenta l'uscita dal nostro programma, infatti con la parola chiave return viene restituito un valore del tipo della funzione, dopodiché viene effettuata l'uscita dalla funzione. La scritta EXIT_SUCCESS identifica una costante intera di valore 0, che indica il termine del programma con successo.

Ma come abbiamo visto il programma non scrive nulla e noi vogliamo che scriva sull'output "Hello, World!". Per questo non dobbiamo far altro che aggiungere l'istruzione printf("Hello, World!\n"); che scriverà sullo schermo il testo fra apici. Il carattere '\n' serve a spostare il cursore su una nuova riga,cosa che non viene fatto in automatico. Vediamo come cambia il codice del programma:

L'istruzione per la scrittura del testo in output la mettiamo prima di mettere il prompt dei comandi in pausa. Per eseguire il programma basta premere F9, oppure andare in Execute->Compile & Run, che compilerà il vostro codice, dopodiché lo eseguirà, producendo il seguente output:

Con questo termina il nostro programma "Hello, World!".

Download progetto Dev C++ hello_world.zip.

Non dimenticate del +1 :)

C/C++ - Introduzione

2011-12-20T16:22:00.004+01:00

C è uno dei più conosciuti linguaggi di programmazione e come conseguenza anche il linguaggio nel quale sono stati scritti una grandissima parte dei programmi per i PC. Il suo successo è dovuto soprattutto al fatto che la Microsoft lo ha usato moltissimo per scrivere i programmi per i suoi primi sistemi operativi Windows.

Il motivo per il quale il gigante ha deciso di sviluppare i suoi programmi utilizzando proprio C è che questo linguaggio ha la particolarità di essere un linguaggio di alto livello, ovvero un linguaggio di programmazione molto simile al linguaggio umano, ma nonostante ciò è possibile scendere di livello per arrivare quasi al livello macchina. Questa particolarità permette di sviluppare velocemente programmi di grandi dimensioni, avendo a tempo stesso l'accesso diretto al hardware e avendo la possibilità di sviluppare praticamente qualunque tipo di programma.

Un'altro punto di forza del C è la velocità dei programmi scritti in questo linguaggio di programmazione, visto che il compilatore traduce le istruzioni di C in istruzioni Assembler, che è il linguaggio più vicino al linguaggio macchina e anche se viene considerato un linguaggio in via di estinzione attualmente è ancora molto utilizzato per la scrittura dei programmi che richiedono prestazioni elevate.
Molti credono che C e C++ sono lo stesso linguaggio di programmazione, ma non è così, perché C++ è un linguaggio di programmazione basato su C, ma che permette la creazioni di strutture come classi e introduce alcuni tipi e automatizzazioni. In altre parole il C++ è un'ottimizzazione di C, per cui è sempre preferibile usare C++ che C per la scrittura dei programmi, anche perché C++ può essere chiamato un linguaggio ad oggetti, che è una caratteristica dei linguaggi di programmazione attuali.

F# - Introduzione

2011-12-16T13:18:00.119+01:00

F# è un linguaggio di programmazione molto giovane, sviluppato e mantenuto dal gigante Microsoft, che ha deciso di includerlo nella famiglia .Net (Dot Net) con l'uscita del ambiente di sviluppo Visual Studio 2005. Il vantaggio di sviluppare applicazioni in F# usando Visual Studio sta nel fatto che la famiglia .Net contiene un gruppo di linguaggi di programmazione (C++/C#/Visual Basic/F#), permettendo di scrivere il programma utilizzando più linguaggi di programmazione assieme. Questo permette di sviluppare diversi tipi di applicazioni, a partire da console application e arrivando alle semplici applicazioni GUI e videogiochi 3d.

Ma questo non è l'unico punto di forza di F#, perché esso porta con il suo arrivo anche un altro stile di programmazione, chiamato programmazione funzionale. Questo tipo di programmazione viene considerato più semplice rispetto alla programmazione procedurale, che caratterizza i linguaggi di programmazione come C++, C#, Java etc. Esso, infatti, permette di tradurre facilmente l'algoritmo per la risoluzione di un problema in codice di un programma, perché richiede soltanto di indicare i passaggi da fare per arrivare alla soluzioni desiderata, mentre nella programmazione procedurale bisogna pensare anche al modo in cui eseguire ogni passo del algoritmo, che nella maggior parte dei casi complica notevolmente il programma, mettendo in serie difficoltà i programmatori che sono alle prime armi.
Ad ogni modo F# non è l'unico linguaggi di programmazione funzionale esistente, infatti, esso è stato sviluppato sulla base di un altro, sviluppato nel 1985 da INRIA e chiamato CaML, che però non ebbe lo stesso successo di F# a causa della richiesta di elevate prestazioni dei computer. Con il tempo i computer sono diventati sempre più potente e quindi è stato possibile l'impiego di questo tipo di linguaggi nello sviluppo di applicazioni.
Per chi non ha la possibilità di procurarsi Visual Studio, può comunque scaricare l'ambiente di sviluppo di CaML, che è gratuito e molto leggero e studiare il CaML invece di F#, dato che i due linguaggi sono molto simili. L'ambiente di sviluppo di CaML lo potete scaricare da http://caml.inria.fr/download.en.html, però dovete ricordare che CaML è più rigido per quanto riguarda le operazioni tra interi e tra float, perché quando vogliamo sommare due numeri interi usiamo l'operatore '+', mentre per sommare due numeri con virgola mobile dobbiamo usare l'operatore '.+', altrimenti l'interprete ci segnalerà un errore.