Hello, World!

Il rito di iniziazione

Ogni programmatore, dal 1978 a oggi, ha iniziato scrivendo un programma che stampa “Hello, World!“. Non c’è una legge, ma quasi. Ecco la versione C3:

import std::io;

fn void main()
{
	io::printn("Hello, World!");
}

Cinque righe. Salvale in un file chiamato hello.c3 nella cartella degli esercizi, poi nel terminale:

c3c compile-run hello.c3

Program linked to executable './hello'.
Launching ./hello
Hello, World!
Program completed with exit code 0.

Le righe che iniziano con Program e Launching le scrive il compilatore per dirti cosa sta facendo. Hello, World! l’hai scritta tu. Congratulazioni: hai fatto fare qualcosa a un computer.

Ora smontiamo il programma. Ogni parola ha un motivo.

Riga 1: import std::io;

import std::io;

Un programma C3 parte “vuoto”: non sa nemmeno stampare sullo schermo. Le funzionalità sono organizzate in moduli, e import dice al compilatore quali vuoi usare. std::io è il modulo di input/output della libreria standard (std): dentro c’è tutto ciò che serve per leggere e scrivere testo.

I due punti doppi :: separano i livelli di un percorso: std è la libreria standard, io è un modulo al suo interno.

Riga 3: fn void main()

fn void main()

Questa riga dichiara una funzione: un blocco di codice con un nome, che puoi far eseguire chiamandolo. Leggila da sinistra a destra:

Il nome main è speciale: è il punto d’ingresso. Quando lanci il programma, il sistema operativo cerca main e comincia da lì. Ogni programma ne ha esattamente una.

Righe 4 e 6: le graffe { e }

Le parentesi graffe delimitano il corpo della funzione: tutto ciò che sta in mezzo viene eseguito quando la funzione viene chiamata. In C3 le graffe sono obbligatorie, anche per una sola riga.

Dove metti la graffa aperta (sulla stessa riga o su quella dopo) è questione di gusto. La libreria standard di C3 la mette a capo, come nell’esempio. Entrambe queste versioni sono identiche per il compilatore:

fn void main()
{
	io::printn("stile Allman");
}

fn void other() {
	io::printn("stile K&R");
}

Scegline uno e sii coerente.

Riga 5: io::printn("Hello, World!");

	io::printn("Hello, World!");

Questa è una chiamata di funzione: chiediamo alla funzione printn del modulo io di fare il suo lavoro. Il nome completo sarebbe std::io::printn, ma C3 permette di usare solo l’ultimo pezzo del percorso del modulo, io. È la convenzione: corta e leggibile.

Il testo tra virgolette, "Hello, World!", è una stringa (una sequenza di caratteri) e viene passato alla funzione come argomento. printn la stampa e poi va a capo (la n finale sta per newline). Esiste anche io::print, identica ma senza andare a capo.

Il punto e virgola ; chiude l’istruzione. In C3 ogni istruzione finisce con ;. Dimenticarlo è l’errore numero uno dei principianti: il compilatore te lo farà notare con gentilezza teutonica.

Il rientro della riga (la tabulazione all’inizio) è solo per gli occhi umani: al compilatore non interessa. Ma ai tuoi occhi sì, quindi rientra sempre il codice dentro le graffe.

Compilare: cosa succede davvero

Il comando c3c compile-run fa due cose in sequenza:

1. Compila hello.c3 in un eseguibile chiamato hello (o hello.exe su Windows).
2. Lancia l’eseguibile.

Puoi anche separarle:

c3c compile hello.c3   # crea l'eseguibile
./hello                # lo lancia (su Windows: hello.exe)

L’eseguibile è un file indipendente: puoi copiarlo su un altro computer con lo stesso sistema operativo e funzionerà anche senza c3c installato. È questo il bello dei linguaggi compilati.

Rompiamolo apposta

Il modo più rapido per capire un compilatore è farlo arrabbiare. Prova a togliere il punto e virgola:

import std::io;

fn void main()
{
	io::printn("Hello, World!")
}

 2:
 3: fn void main()
 4: {
 5:     io::printn("Hello, World!")
                                  ^
rotto.c3:5:29: error: Expected ';'

Il compilatore ti mostra il pezzo di codice incriminato, con un ^ sotto il punto esatto, e poi la riga nel formato nome file : riga : colonna : messaggio. Riga 5, colonna 29, “mi aspettavo un ;”. Non serve altro.

Ora prova a togliere import std::io;: il compilatore ti dirà che non conosce nessun io. Ora prova a scrivere Io::printn con la maiuscola. Ogni errore che provochi adesso è un errore che riconoscerai al volo dopo.

Più righe, più stampe

Puoi mettere quante istruzioni vuoi dentro main. Vengono eseguite in ordine, dall’alto in basso:

import std::io;

fn void main()
{
	io::printn("Prima riga");
	io::printn("Seconda riga");
	io::print("Terza");
	io::print(" riga");
	io::printn("");
}

Prima riga
Seconda riga
Terza riga

Nota l’ultima io::printn(""): stampa una stringa vuota e va a capo. È un trucco comune per “chiudere” una riga costruita con più print.

Ciao, C3!
Sono pronto.

import std::io;

fn void main()
{
	io::printn("Ciao, C3!");
	io::printn("Sono pronto.");
}

Commenti: note per gli umani

Una cosa che vedrai spesso nel codice sono i commenti: testo ignorato dal compilatore, scritto per chi legge. In C3 ci sono tre forme:

// Commento su una riga: tutto dopo le due barre è ignorato.

/* Commento su più righe.
   Può andare avanti quanto vuoi.
   /* E può anche contenere altri commenti, a differenza del C! */
*/

<*
 Commento di documentazione: descrive la funzione che segue.
 Lo useremo più avanti, perché può contenere "contratti".
*>
fn void main()
{
	io::printn("Hello"); // Anche qui, a fine riga.
}

Usa i commenti per spiegare il perché, non il cosa. // stampa Hello non aiuta nessuno; // il saluto deve essere in inglese per il test automatico sì.

Ricapitolando

• Un programma C3 è un file di testo con estensione .c3.
• import std::io; rende disponibili le funzioni di stampa.
• fn void main() { ... } è il punto d’ingresso: tutto parte da qui.
• io::printn("...") stampa e va a capo; io::print non va a capo.
• Ogni istruzione finisce con ;.
• c3c compile-run file.c3 compila e lancia in un colpo solo.

Nella prossima lezione vediamo come organizzare un programma in un progetto, perché un file solo ti va bene oggi ma non domani.