Corso di programmazione: “Ciao Mondo!”, il nostro primo programma

Riprendiamo dopo una lunga pausa la nostra guida introduttiva alla programmazione, con la promessa che faremo una-due lezioni a settimana.

E’ arrivato il momento di compilare il nostro primo programma. Useremo come riferimento Ubuntu, ma la stessa cosa vale anche per qualsiasi distribuzione GNU/Linux molti altri sistemi Unix.

Prima di tutto abbiamo bisogno di un editor di testo con cui scrivere il nostro programma. Io userò Gedit, ma se avete KDE potrete usare Kate, mentre con Xfce avete mousepad. Altrimenti da terminale una scelta semplice è usare nano.

Poi abbiamo bisogno di un compilatore, cioè del programma che trasforma il codice sorgente in linguaggio macchina del processore. Il compilatore GNU si chiama gcc (che stava per GNU C Compiler quando compilava solo il C, mentre adesso che compila una caterva di linguaggi la sigla è passata a significare GNU Compiler Collection). Viene usato da GNU/*, da Mac OS X e dai vari sistemi BSD, nonché su OpenSolaris ma funziona anche su Windows.

Gcc è preinstallato, per cui non c’è bisogno di fare nulla.

Infine è necessario avere le librerie che contengono le istruzioni del C. La libreria fondamentale è la GNU C Library (glibc) che ovviamente è preinstallata, altrimenti non funzionerebbe nulla nel sistema operativo essendo questo basato proprio sul C. Ma a noi servono anche gli headers (intestazioni), vale a dire i file che contengono gli elenchi delle istruzioni contenute nelle librerie. Su Ubuntu ci basterà installare il pacchetto build-essential che contiene tutto e molto più di ciò che ci serve.

Apriamo quindi in nostro editor di testo e salviamo subito il file con il nome ciaomondo.c

Fatto ciò, copiamo questo programma:

#include <stdio.h>

int main()
 {
   printf("Ciao Mondo!\n");
   return 0; 
 }

L’include che vediamo all’inizio non è una istruzione del C, ma un’istruzione per il compilatore, o meglio per la parte del compilatore che si occupa di analizzare il codice prima della compilazione vera e propria. Questa parte si chiama preprocessore e l’include è per questo detta “direttiva per il preprocessore”. Il preprocessore legge questa direttiva e va a prendere il file stdio.h dalla cartella /usr/include/ che contiene appunto le intestazioni della libreria C che si occupano dell’Input/Output (difatti stdio sta per Standard Input/Output). Questo file verrà incorporato nel nostro sorgente, cosicché nei fatti il nostro programma sarà composto anche dalla libreria.

Vediamo a cosa ci serve… l’istruzione printf è una istruzione contenuta proprio in stdio. Essa stampa a video ciò che è contenuto nelle parentesi.

E’ importante ricordare che in C i parametri (ovvero i dati che le istruzioni debbono elaborare) sono racchiusi tra parentesi.

Nel nostro caso si tratta di una serie di caratteri che, tecnicamente, viene detta “stringa”. Una stringa è appunto una sequenza di caratteri.

Ora, prima di printf vediamo questo strano int main(). Vediamo anche qui queste parentesi, peraltro vuote. Cos’è questo Main? Non è altro che la parte principale del programma. Nel nostro caso è tutto il programma, ma questo non importa al compilatore: il C pretende che ci sia sempre una parte principale, anche se è l’unica.

Finora ho usato un termine generico: istruzione. Ma il termine giusto è funzione. Una funzione, in C, è una blocco di codice racchiuso tra parentesi graffe che può ricevere dei dati in Input e restituire (a volte si dice all’inglese: ritornare) il risultato come Output. E’ molto simile al concetto matematico di funzione: ad esempio y=f(x). f() può essere qualsiasi cosa, ad esempio y=x*2.

Il main è esso stesso una funzione: nel nostro caso non ha parametri in ingresso, ma vedremo in seguito che possiamo definirli. In uscita invece, ha un numero intero (int).  Vedremo tra poco a cosa può servirci.

Vediamo anche che certe istruzioni sono scritte più “dentro” di altre. Questo stile si chiama indentazione e non è obbligatoria, ma serve solo a rendere più leggibile il programma. In questo modo sappiamo che printf e return sono parte della funzione main, a colpo d’occhio. L’ultimo particolare da notare è che ogni istruzione deve terminare con il punto e virgola.

Ora salviamo il file e apriamo il terminale. Il comando per compilare il nostro programma è:

gcc -o ciaomondo  ciaomondo.c

il parametro -o (output) definisce il nome che vogliamo sia dato al file eseguibile. Di solito è lo stesso del sorgente (ovviamente senza il .c), ma possiamo scegliere quel che ci pare. Per convenzione però gli eseguibili non hanno estesione (cioè la parte del nome dopo il punto, come .txt, .exe, ecc.).

Infine eseguiamo il nostro programma:

./ciaomondo

e vedremo il risultato. Non vi sarete probabilmente accorti di un particolare: dopo aver stampato la scritta “Ciao Mondo!” il terminale è andato a capo. Questo perché abbiamo terminato la stringa con la sequenza \n, che appunto rappresenta un “a capo” (n=new line, nuova linea). Provate a toglierlo e a ricompilare per vedere l’effetto.

Ora diamo sempre da terminale:

echo $?

questa istruzione dice alla shell di stampare il codice di uscita dell’ultimo comando, nel nostro caso proprio ciaomondo. Vedremo che verrà stampato uno 0. Ora facciamo un esperimento: invece di return 0 mettiamo return 2. Ricompiliamo il programma, eseguiamolo e diamo di nuovo echo $?. Vedremo un bel 2 visualizzato dalla shell.

E’ infatti l’istruzione return che restituisce il valore della funzione main. Siccome main è il programma principale, il valore viene ritornato al programma chiamante, vale a dire la shell.

A cosa serve tutto ciò? Principalmente a segnalare un eventuale errore. Per convenzione 0 vuol dire che l’esecuzione è andata a buon fine, ogni altro valore indica un errore. In questo modo i programmi possono comunicare alla shell o ad altri programmi se sono riusciti a compiere il loro lavoro o meno.

Nella prossima puntata vedremo come interagire con l’utente e cosa sono le variabili.