Sei sulla pagina 1di 4

Canto zero: dal nulla all'esecuzione del PRIMO programma

int main( ){ }

Questo è il programma C++ più breve che possa essere scritto senza che il compilatore segnali alcunché di errato, e
che può essere formalmente eseguito con successo quantunque non faccia assolutamente nulla. Come tale presenta
quanto ci deve essere di irrinunciabile in un normale documento di testo per poter affermare che si tratta di un
programma scritto in C++, vale a dire:

 una funzione chiamata obbligatoriamente main cui si attribuisce il tipo int che ne precede il nome;
 una lista di argomenti per tale funzione, che ne segue il nome, racchiusa tra parentesi tonde e
inserita obbligatoriamente anche se vuota come nel caso presente;
 un cosiddetto ambito della funzione, racchiuso tra parentesi graffe e inserito obbligatoriamente anche se vuoto
come nel caso presente.
L'unica spaziatura necessaria è quella che separi la parola int dalla parola main; oltre a questa ne possono essere
inserite quante altre se ne vogliano in qualsiasi posizione purché non si spezzino le due uniche parole presenti nel
testo, che devono essere considerate a tutti gli effetti come gli atomi di Democrito. In altri termini, se il testo presente si
riscrive così:

int main

){

al compilatore va altrettanto bene, anche se vien da chiedersi quanto abbia bevuto l'autore del codice, mentre non
verrebbe accettato se fosse scritto:

int ma in( ){ }

a causa della spaziatura illecita che spezza la parola main.


Il programma nullafacente fin qui introdotto va scritto, ovviamente, in un documento di testo usando esclusivamente un
normalissimo text editor, assolutamente NONun word processor. Per intendersi si rifugga dall'idea di scrivere codici
C++ usando programmi comunemente denominati suites per ufficio (word, wordpad, office et similia) dato che questi
introducono nel documento pletore di bytes di formattazione che il compilatore rifiuterebbe come la peste, e lo fanno
alla piena insaputa dell'autore del codice.
Un text editor (gedit, emacs, kate et similia) invece, introduce nel documento solo ed esclusivamente i caratteri che la
mente del programmatore, guidando i polpastrelli delle sue stesse dita sulla tastiera, intende effettivamente e
volontariamente che siano inseriti.

Molti text editors, per giunta, non sono affatto stupidi e sono in grado di riconoscere le parole appartenenti al
vocabolario del linguaggio e molti dei suoi costrutti sintattici, evidenziandoli con colori convenzionali che sono di
considerevole aiuto durante la redazione del codice.
Il nome del documento che contiene il testo del programma è a totale discrezione dell'autore, ma è molto opportuno che
termini con una delle sequenze di caratteri preferite dal compilatore che sono:

.c .C .cc .cpp .CPP .c++ .cp .cxx

Se qualcuno/a volesse fare l'originale e battezzare il proprio documento contenente il programma con lo stesso nome
della/del sua/o ragazza/o, si vada a cercare nelle 181 pagine della documentazione del compilatore quale opzione deve
fornirgli affinché sia disposto a ignorare il fatto che il nome del documento ha un suffissosconosciuto.

Siccome io non ho tempo da perdere, e non ho neppure la ragazza, supporrò senz'altro che il nome del documento
contenente il programma sia
pippo.C

e, per compilarlo, ossia per tradurlo in codice binario eseguibile dal processore, sarà sufficiente dare alla shell il
comando

g++ -std=c++11 pippo.C

La shell risponderà ripresentando semplicemente il proprio prompt, ossia disponendosi a ricevere il comando
successivo, beninteso se il compilatore C++ è correttamente installato, altrimenti risponderebbe Comando non trovato o
altre amenità.

L'opzione -std=c++11 attiva l'interpretazione del codice nello standard 2011 del linguaggio: è disponibile sul compilatore
GNU di Linux dalla versione 4.7; se qualcuno ha una versione precedente si suggerisce o un aggiornamento del
sistema, oppure NON USARE costrutti sintattici propri di quello standard. La prima opzione è caldamente
raccomandata.

Per evitare di dovere scrivere sempre quell'opzione si potrebbe creare un cosiddettoalias del comando che la contempli
implicitamente, ad esempio inserendo nel documento di configurazione della propria shell una linea del tipo

alias g++='/usr/bin/g++ -std=c++11'

Frattanto, in un modo o nell'altro, il compilatore avrà creato nella cartella corrente un nuovo documento dal nome
criptico

a.out

che contiene appunto il codice eseguibile e può essere mandato in esecuzione digitando ./a.out

terminato con Invio: il TASTO Invio, NON la parola I-n-v-i-o, a destra del promptdella shell: non accadrà nulla, se non la
reiterazione del prompt.
Evidentemente per ottenere qualcosa occorre inserire delle istruzioni nel programma e queste vanno poste all'interno
dell'ambito di main, ossia entro le graffe; ad esempio, per far apparire sul terminale il risultato di 2+2, si potrebbe
scrivere

#include <iostream>
int main( )
{std :: cout << "2+2 fa " << 2+2 << '\n';}

Come si vede, la semplice introduzione di un'istruzione, meglio dire: un'espressione, che produca un risultato così
banale ha provocato la comparsa sulla scena di parecchi nuovi personaggi:
 un oggetto chiamato std :: cout, il cui nome NON fa parte del vocabolario del linguaggio e per la cui
comprensione da parte del compilatore è NECESSARIO l'inserimento della misteriosa prima riga, che
precede main; questo oggetto si incarica di inserire dati nel cosiddetto standard output del programma, ossia,
salvo avvisi contrari, sul terminale da cui il programma stesso verrà eseguito: va da sé che qualsiasi
programma che faccia qualcosa di utile non potrà mai esimersi dall'usare oggetti di questo genere.
 un operatore (il segno <<, senza alcuno spazio tra i due <) che dice a coutche cosa inserire, e come,
nello standard output: ciò che lo segue immediatamente.
 una costante stringa ("2+2 fa ") che, trovandosi a destra dell'operatore, sarà inserita tale e quale nello standard
output;
 una sottoespressione aritmetica (2+2) che come tale sarà valutata e il cui risultato, trovandosi anch'essa a
destra di <<, sarà pure inserito in output;
 una costante carattere ('\n'), pure inserita in output, e che causerà una semplice andata a capo, utile per la
leggibilità dell'output stesso.
 il segno finale di punto e virgola OBBLIGATORIO perché occorre comunque segnalare al compilatore la fine
dell'espressione, ANCHE quando ce ne fosse una sola come nel caso presente.
Compilando novamente pippo.C con l'attuale contenuto e rieseguendo ./a.out(FATELO!) si vedrà apparire sul terminale
la confortante affermazione

2+2 fa 4

seguita, a capo, dal prompt della shell.

Naturalmente il linguaggio consente applicazioni migliori di quella appena riportata: tanto per procedere gradualmente
si potrebbe fare in modo che il programma sia capace di eseguire qualsiasi addizione i cui due addendi siano, in
qualche modo, forniti dall'esterno all'atto dell'esecuzione. Questo, per inciso, è insito nel concetto stesso di
programmazione: un programma non dovrebbe mai conoscere a priori il valore numerico dei propri dati. Un modo per
farlo è il seguente:

#include <iostream>
using namespace std;

int main( )
{double a, b;
cout << "fornisci i due addendi ", cin >> a >> b,
cout << a << '+' << b << " fa " << a+b << '\n';}

Si osservi che, rispetto alla versione precedente, non compare più alcuna costante numerica ma solo costanti carattere
e costanti stringa; si sono invece introdotte due variabili (a, b) che sono state dichiarate appartenenti al
tipo double immediatamente dopo l'apertura della parentesi graffa. La virgola che separa a da b e il punto e virgola
conclusivo sono obbligatori in una dichiarazione.
I valori numerici delle due quantità sono richiesti direttamente all'utente all'atto dell'esecuzione del programma e sono
introdotti nella sua memoria da parte dell'oggetto cin che svolge una funzione speculare rispetto a quella
dell'oggetto cout, vale a dire che estrae dati, attraverso l'operatore >>, dal cosiddetto standard input che, salvo avvisi
contrari, coincide con la tastiera del calcolatore.
Quando l'esecuzione del programma giunge a elaborare la sottoespressione
cin >> a >> b,
l'esecuzione stessa si arresta in attesa che qualcuno digiti sulla tastiera qualcosa di riconoscibile come due numeri
separati da uno spazio e terminati da Invio. I termini qualcosa di riconoscibile sono voluti: significano che se si digita del
ciarpame il programma, così com'è scritto, potrebbe arrestarsi o concludersi con esiti fantasiosi.
Si osservi anche la seconda riga qui introdotta (using namespace std;) che consente di riferirsi all'oggetto cout, e anche
all'oggetto cin, senza più dovere, ogni volta, citare anche il cosiddetto namespace (std ::) in cui tali oggetti sono stati
descritti al compilatore, perché tale namespace si conviene ora che sia sottinteso come, in pratica, recita la seconda
riga. Ciò è estremamente conveniente, specialmente quando, come accade sostanzialmente sempre, gli
oggetti cout, cin e molti altri debbano essere usati numerose volte: ecco il motivo per cui, di fatto, QUASI TUTTI i
programmi C++ iniziano con le due righe qui riportate.
Ricompilando e rieseguendo il programma, come sopra spiegato, si vedrà apparire sul terminale la frase:

fornisci i due addendi

con alla destra il cursore lampeggiante: il programma, a quel punto, sta valutando la sottoespressione:

cin >> a >> b,

e quindi, per poterne venire a capo con successo, occorre appunto fornirgli due numeri, come gli è stato
opportunamente detto di richiedere e come già è stato spiegato.
Se si ottempera alla richiesta comparirà, immediatamente dopo la pressione di Invio, il corretto risultato dell'addizione;
se invece si digiterà la vispa teresa... provate e vedrete.

NOTA BENE: se si vogliono fornire valori non interi la virgola deve essere in realtà un punto; in altre parole il valore
approssimato a due cifre decimali di pi greco va dato come 3.14 NON come 3,14.

È del tutto evidente che le altre operazioni aritmetiche elementari saranno trattabili allo stesso modo utilizzando gli
opportuni operatori, dotati già delle corrette regole di precedenza. La doverosa cautela contro l'eventualità delle
divisioni per zero è a carico dell'autore del codice: se si provasse a sostituire, nel programma precedente, l'addizione
con la divisione e si digitasse apposta, per la variabile b, il valore 0, si avrebbe come risultato inf, abbreviativo di infinito,
se il dividendo fosse non nullo enan, acronimo di Not A Number, se anche il dividendo fosse nullo.

Per concludere quest'introduzione si farà osservare come, in generale, un programma C++ possa essere concepito
come un insieme di funzioni che sono eseguite in un certo ordine stabilito dal programmatore, la prima funzione
eseguita essendo sempre quella chiamata main, eventualmente, come si è fin qui visto, unica. Come esempio si
tratteranno appunto le quattro operazioni artitmetiche elementari, la cui valutazione, piuttosto che effettuata come prima
in main, sarà demandata a quattro distinte funzioni dal nome parlante. Ecco il codice (compilatelo ed ESEGUITELO):

#include <iostream>
#include <cstdlib>
using namespace std;

double quoziente(double dividendo, double divisore)


{return dividendo / divisore;}

double prodotto(double moltiplicando, double moltiplicatore)


{return moltiplicando * moltiplicatore;}

double differenza(double minuendo, double sottraendo)


{return minuendo - sottraendo;}

double somma(double addendo_uno, double addendo_due)


{return addendo_uno + addendo_due;}

int main(int narg, const char * * args, const char ** env)


{double a = atof(args[1]), b = atof(args[2]);
cout
<< a << '+' << b << " fa " << somma(a, b) << '\n'
<< a << '-' << b << " fa " << differenza(a, b) << '\n'
<< a << '*' << b << " fa " << prodotto(a, b) << '\n'
<< a << '/' << b << " fa " << quoziente(a, b) << '\n';}

Da questo breve programma si imparano molte cose, ossia:

 I segni grafici (operatori) da usare per le quattro operazioni aritmetiche.


 La funzione main può avere degli argomenti, anzi, così com'è stata scritta, le vengono trasferiti tutti i parametri
che può legittimamente ricevere come propri argomenti, nel numero e nel tipo dovuti. Senza addentrarci qui
sul significato dei tipi, basterà notare che il secondo argomento (args) è qui usato per comunicare al
programma i valori dei due operandi di cui si vogliono calcolare somma, differenza, prodotto e quoziente.
Digitando, all'atto dell'esecuzione

./a.out 12.75 48.44

i due valori indicati saranno ricevuti, come stringhe di caratteri, rispettivamente in args[1] e args[2] e
trasformati nei rispettivi valori numerici dalla funzione atof, dichiarata e descritta al compilatore in cstdlib. Per il
significato dei numeri racchiusi tra quadre attendete di crescere.
 È sempre opportuno che la funzione main, quantunque sia sempre la prima a essere eseguita, sia l'ultima a
essere scritta nel documento contenente il programma: in questo modo è quasi sicuro che tutte le eventuali
altre funzioni siano già note al compilatore, o perché già scritte nel documento stesso, come le nostre quattro,
o perchè presenti in qualche documento incluso, come atof.
 Ogni altra funzione diversa da main le è sintatticamente equivalente: deve sempre avere, nell'ordine, un tipo,
un nome, una lista di argomenti tipizzati e un ambito: così per l'appunto sono
scritte somma, differenza, prodotto e quoziente.
 Quando, durante l'esecuzione del programma, in main o in qualsiasi altra parte si incontra il nome di una
funzione nota al compilatore, ovviamente seguito da appropriati parametri racchiusi in parentesi tonde, questa
viene eseguita a sua volta: ciò significa semplicemente che, al momento in cui si incontra il nome della
funzione, si passa all'interno del suo ambito e si eseguono ordinatamente le istruzioni ivi contenute finché
o o si arriva alla fine dell'ambito della funzione
o o vi si incontra l'istruzione return
In entrambi i casi il programma ritorna a eseguirsi ordinatamente dal punto immediatamente successivo a
quello in cui era stato incontrato il nome della funzione.
 Affinché quanto detto al punto precedente accada effettivamente occorreche vi sia
corrispondenza/compatibilità di tipo tra i parametri inseriti nella lista racchiusa tra parentesi tonde allorché si
vuol trasferire l'esecuzione alla funzione e gli argomenti che la funzione stessa attende; in difetto di ciò il
compilatore segnala errore e NON produce il codice binario eseguibile. Non ha invece alcuna importanza il
nome attribuito ai parametri rispetto al nome con cui la funzione battezza internamente i propri argomenti.
Infatti in mainsono usati i nomi a e b che non compaiono in nessun'altra parte del programma.
 Quando una funzione esegue l'istruzione return, a tutti gli effetti è come se in main, o comunque nella parte del
codice da cui la funzione era stata eseguita, la richiesta della sua esecuzione venisse rimpiazzata con il valore
dell'espressione che si trova a destra dell'istruzione return medesima. Tale espressione deve avere
corrispondenza/compatibilità di tipo con il tipo cui è stata attribuita la funzione, ossia quello che ne precede il
nome: questo dovrebbe bastare a spiegare come fa a funzionare il programma sopra codificato.

POSTILLA:

Le funzioni, in C++, sono di solito usate per scopi molto più intelligenti.