Il primo programma in C++

Ora abbiamo tutto l'occorrente per scrivere il nostro codice e compilarlo.
Apriamo il nostro IDE, ad esempio Eclipse, e creiamo un nuovo progetto.
Il progetto è ancora vuoto, dobbiamo quindi aggiungere al progetto un file di testo in cui andremo a scrivere il nostro codice sorgente.
Il procedimento per creare un nuovo progetto ed aggiungere dei files al suo interno varia da IDE a IDE, ma in generale è abbastanza intuitivo, altrimenti basta dare un'occhiata alla guida del programma.

Ora che abbiamo il nostro bel progetto con al suo interno un file sorgente, che io ho chiamato "main.cpp" (.cpp è l'estensione tipica dei files sorgenti del C++, come .c lo è per quelli in C), possiamo iniziare finalmente a scrivere un po' di codice.

Come abbiamo già detto più volte, il C, e quindi di conseguenza anche il C++, è un linguaggio procedurale. Il secondo è anche un linguaggio Object Oriented, che include tuttavia l'utilizzo di procedure.

Le procedure, nel C così come nel C++, sono chiamate funzioni. Le funzioni non sono tra i primi argomenti che affronteremo, tuttavia le dobbiamo introdurre per una questione che vi sarà chiara fra poco. Ricordiamo che le procedure non sono altro che dei blocchi di codice che accettano dei dati in ingresso, e restituiscono dei dati in uscita.

In C/C++ una funzione minima si scrive nel modo seguente:

void nome_funzione()
{
    ...codice interno alla funzione...
}

Per ora non ci serve sapere altro, in futuro vedremo le funzioni più nel dettaglio.
Perché introdurre ora le funzioni? Perché un programma in C/C++ deve contenere almeno una funzione principale, detta funzione main, che è quella che viene richiamata per prima durante l'esecuzione del programma.
Questa è una funzione main minimale, che manca di alcune caratteristiche non fondamentali che vedremo in futuro:

int main()
{
    //qui va tutto il codice
    return 0;
}

La funzione main() dev'essere sempre presente in un programma C/C++.
Analizzando la funzione main notiamo alcune cose, ma prima di analizzarle una per una proviamo a scrivere la funzione main nel nostro IDE e a compilarla (su Eclipse basta fare Project > Build Project), dopodiché eseguiamo il programma appena compilato (su Eclipse basta fare Run, ma possiamo anche andare nella directory del progetto, e nella subdirectory Debug troveremo il file eseguibile, ad esempio progetto.exe).

Come vedete il codice si compila senza errori, ma all'esecuzione del programma non succede niente, questo perché il programma stesso non contiene niente da mostrare.
Cosa succede durante l'esecuzione del programma? Viene ricercata la funzione main e viene eseguito il codice al suo interno, ma nel nostro caso non essendoci codice da eseguire, il programma viene terminato subito dopo essere stato lanciato.

Vediamo ora le varie parti che compongono la funzione main.

La prima riga che incontriamo è int main()

main è il nome della funzione principale, e deve essere sempre questo (alle nostre funzioni invece potremo dare i nomi che vogliamo).

Come abbiamo già detto, una funzione (o procedura), può ricevere dei valori in ingresso e restituire dei valori in uscita.
I valori in ingresso vengono scritti all'interno delle parentesi tonde ( ). In questo caso la funzione main non riceve alcun valore in ingresso, quindi le parentesi sono vuote. Tuttavia la funzione main può ricevere due valori particolari in ingresso, passatigli dal sistema operativo, ma per adesso tralasciamo questo particolare.

Sempre nella prima riga è presente la parola int.

int significa che la funzione main() restituisce in uscita un valore intero.

Le parentesi graffe { } indicano l'inizio e la fine del blocco di codice appartenente alla funzione main().

Andando avanti nel codice incontriamo la linea return 0.

Così come gli eventuali dati passati all'interno delle parentesi tonde ( ) sono un mezzo per far comunicare il sistema operativo con il programma, la linea return 0 all'interno della funzione main() serve al programma per comunicare qualcosa al sistema operativo nel momento in cui il programma termina.
Nello specifico è un modo in cui il programma comunica al sistema operativo se il programma stesso è giunto a termine con o senza errori. Il valore 0 che segue return suggerisce al sistema operativo che il programma è terminato senza errori.

Avrete notato che il valore di return è un numero intero, ed è per questo che il nome della funzione è preceduto dalla parola int, ad indicare che la funzione restituisce un valore intero. Nelle funzioni interne al programma (impareremo presto cosa sono e come crearle) è possibile restituire altri tipi di valori, o addirittura non restituirne, mentre la funzione main() deve per forza restituire un valore intero.
Perciò, per forza di cose, le linee di codice che abbiamo appena descritto saranno sempre presenti, in tutti i nostri futuri programmi, e per questo motivo è meglio memorizzarle bene anche se per ora non le comprendiamo del tutto.

Per completezza dobbiamo dire che in C, a differenza del C++, la funzione main() può anche non restituire alcun valore:

void main()
{
    //codice...
}

Come potete vedere, la parola int è stata sostituita dalla parola void, che significa "vuoto", e sta ad indicare che la funzione non restituisce alcun valore. Infatti come avrete notato, non è presente la linea di codice con la parola return.
Tuttavia nel C++ la funzione main è obbligata a restituire un valore intero, altrimenti il compilatore restituirà un errore e non produrrà il file eseguibile.

Un'ultima cosa, la scelta del // a precedere i commenti non è arbitraria.
Infatti all'interno dei nostri files sorgenti, insieme al codice, è possibile scrivere dei commenti per rendere il codice più comprensibile. E' buona norma accompagnare il codice con dei commenti, altrimenti una volta finito il programma, se avremo bisogno di fare delle modifiche, rischieremo di perderci all'interno del codice e non capire più niente.

I commenti vengono ignorati dal compilatore, quindi servono esclusivamente per rendere il codice più chiaro al programmatore.

Ad esempio prima avremmo potuto scrivere:

int main() //questa è la funzione main

Il C++ eredita dal C un altro modo di scrivere i commenti, e cioé all'interno di /* */.
Vediamo un esempio per capire meglio:

int main()
{
    /* all'interno della funzione main
va tutto il codice, e le parentesi graffe
servono da delimitatori.
tutto cioé che è qua dentro è un commento */

    return 0;
}

A differenza dei commenti esclusivi del C++, e cioé quelli preceduti da //, i commenti in stile C permettono di scrivere su più linee.

Un'ultima cosa da dire prima di concludere è che la disposizione del codice è a discrezione del programmatore. Ad esempio la stessa funzione main si può scrivere anche così:

int main() {

e cioé con la parentesi graffa di apertura sulla stessa linea. Alcuni programmatori prediligono questo stile, mentre altri preferiscono mandare a capo la parentesi graffa.
Anche le tablature non sono necessarie da un punto di vista strettamente tecnico, e cioé anche scrivendo il codice seguente:

int main() {

return 0; //il return non è indentato
}

il compilatore non avrà problemi nel compilare questa versione del programma.
Tuttavia è buona norma mandare avanti di una tablatura ogni blocco di codice, solitamente gli IDE lo fanno in automatico, mentre se utilizziamo un editor di testo semplice dovremo usare il tasto TAB.

Ricordate che, benché non influisca sul funzionamento del programma in senso stretto, l'assenza di un'impaginazione nonché l'assenza di commenti, rendono il codice incomprensibile, mentre una corretta indentazione accompagnata da dei commenti esaurienti rende il codice più chiaro e leggibile.