Linguaggio D

Hello World               
 

Eccoci quindi pronti per l'inevitabile Hello World. Molto semplice:

Esempio 2-1
1
2
3
4
5
import std.stdio;
void main()
{
  writeln("Hello World");
}

la riga 1 inizia con l'istruzione di importazione della libreria di gestione del I/O. Una istruzione molto semplice che è vicina a Python piuttosto che a C++. Da notare immediatamente, alla riga 1, il richiamo alla libreria stdio che implementa le funzionalità di base, mettendocele a nostra completa disposizione. In particolare in questo esempio abbiamo usato la funzione writeln che scrive la stringa sullo standard output e va a capo (come indica il suffisso "ln" se usate solo write il programma a capo non ci va). Una stringa è racchiusa all'interno di una coppia di doppi apici. Ancora, va osservata la presenza di "main", riga 2, che costituisce l'entry point del programma. La sua presenza è pertanto sempre necessaria. Ricordate sempre che D è un linguaggio case sensitive, qundi esiste distinzione tra lettere maiuscole e minuscole. Se provate ad esempio a scrivere "Main" riceverete un messaggio, per la verità non chiarissimo, che le cose non sono filate liscie. Comunque, vi può magari interessare un saluto un po' più interattivo:

Esempio 2-2
1
2
3
4
5
6
7
import std.stdio;
void main()
{
  write("Inserisci il tuo nome: ");
  string nome = readln();
  writeln("ciao, ", nome);
}

In questo caso è entrata in gioco la funzione readln che, leggendo dallo standard input memorizza in una stringa, in questo caso la stringa si chiama "nome". La sintassi, come si vede, è molto vicina a quella del nostro beneamato C++, con le graffe che delimitano i blocchi di codice. L'uso delle graffe è opzionale se il "blocco" è costituito da una sola istruzione. Personalmente preferisco usarle sempre, imho rende migliore la leggibilità e più coerente la manutenzione, ripeto è un mio punto di vista. Ogni singola istruzione termina con il ; (punto e virgola) proprio come in C o Java o C#. Fin qui nulla di eclatante. Si può notare la presenza, alla riga 1, del . (punto) che ci indica che probabilmente, sarà lui l'operatore designato a permetterci la navigazione gerarchica. Ne riparleremo. La riga due pertanto ci consegna l'entry point del programma, come detto. In D tutte le funzioni devono specificare un valore di ritorno. Se questo non c'è vanno firmate tramite la parola riservata void, proprio come il nostro main. Come è noto assegnare un valore di ritorno al metodo main, può essere utile per comunicare all'esterno del programma, ad esempio in Windows attraverso la variabile di sistema %ERRORLEVEL, qualche informazione relativa alla terminazione del programma. Il prossimo esempio mostra la sintassi nel caso in cui si volesse attribuire un valore in uscita

Esempio 2-3
1
2
3
4
5
6
import std.stdio;
int main()
{
  writeln("ciao");
  return 0;
}

Con questo direi che è abbastanza chiaro, main invia verso ,l'esterno, in questo caso al di fuori del programma stesso, il valore zero. 

E' anche possibile fornire dei parametri al nostro programma. Anche in questo caso non c'è nulla di diverso da tanti altri linguaggi, solo bisogna avere una piccola accortezza:

Esempio 2-4
1
2
3
4
5
import std.stdio;
void main(string[] args)
{
  writeln(args[1]);
}

La riga 2 definisce un array di stringhe, vedremo di che si tratta più avanti. Per riprodurre il parametro che inseriremo dopo il nome del programma dobbiamo specificare, come alla riga 4, l'indice 1, anzichè lo 0 come in altri linguaggi, in quanto a quell'indice, lo 0, corrisponderebbe la stringa indicante il nome del programma stesso, come è semplice verificare. Omettendo il parametro e specificando l'indice 1 si ha invece una eccezione. Comunque bastano un paio di prove per capire, non vi è nulla di complicato. Un'altra considerazione volante, utile per il futuro, è che era possibile anche scrivere il programma 1-4 (e similmente, il 1-1 ecc) in questo modo:

void main(string[] args)
{
  writeln(args[1]);
}
import std.stdio;

ovvero ponendo l'istruzione di importazione della libreria alla fine. Il punto è che tutto quanto si trova ad un livello superiore è visibile da quanto sta dentro di esso, detto in maniera grossolana, e, da un punto di vista architetturale, import sarà disponibile non solo per main ma anche per tutte le eventuali istruzioni all'interno di ogni altro metodo definito. Cioè:

import libreria

metodo main()
le istruzioni all'interno "vedono "librera"

metodo m1()
le istruzioni all'interno vedono "libreria"

metodo m2()
le istruzioni all'interno vedono "libreria"

ecc... questo anche la libreria fosse richiamata al codice. Non così accade se l'importazione fosse all'interno del metodo:

void main()
{
  import std.stdio;
  writeln("Hello, World");
  readln();
}

questo funziona

void main()
{
  writeln("Hello, World");
  readln();
  import std.stdio;
}

quest'ultimo invece no perchè import viene visto dopo il tentativo di uso di writeln e readln. In questo caso, essendo l'import all'interno del metodo main ad essere decisivo è l'ordine delle istruzioni.

Ultima nota prima di chiudere riguarda i commenti, anche qui non vi è nulla di nuovo. D supporta i commenti su singola riga, introdotti dalla classica coppia // e quelli multilinea, introdotti da /* e chiusi da */ così come fanno più o meno tutti i linguaggi in voga oggigiorno.