Ogni programma scritto in un qualsiasi linguaggio di programmazione prima di essere eseguito viene sottoposto ad un processo di compilazione o interpretazione (a seconda che si usi un compilatore o un interprete). Lo scopo di questo processo e` quello di tradurre il programma originale (codice sorgente) in uno semanticamente equivalente, ma eseguibile su una certa macchina. Il processo di compilazione e` suddiviso in piu` fasi, ciascuna delle quali volta all'acquisizione di opportune informazioni necessarie alla fase successiva.
La prima di queste fasi e` nota come analisi lessicale ed ha il compito di riconoscere gli elementi costitutivi del linguaggio sorgente, individuandone anche la categoria lessicale. Ogni linguaggio prevede un certo numero di categorie lessicali e in C++ possiamo distinguere in particolare le seguenti categorie:

• Commenti;
• Identificatori;
• Parole riservate;
• Costanti letterali;
• Segni di punteggiatura e operatori;

Analiziamole piu` in dettaglio.



Commenti

 

I commenti, come in qualsiasi altro linguaggio, hanno valore soltanto per il programmatore e vengono ignorati dal compilatore. E` possibile inserirli nel proprio codice in due modi diversi:

1. secondo lo stile C ovvero racchiudendoli tra i simboli /* e */
2. facendoli precedere dal simbolo //

void Func() {
   ...
   int a = 5;         /* questo e` un commento
                      diviso su piu` righe */
   a = 4            /* commento */   + 5;
   ...
  }

Nel secondo caso, proprio del C++, e` invece considerato commento tutto cio` che segue // fino alla fine della linea, ne consegue che non e` possibile inserirlo in mezzo al codice o dividerlo su piu` righe (a meno che anche l'altra riga non cominci con //):

 

void Func() {
  ...
  int a = 5;  // questo e` un commento valido
  a = 4       // Errore! il "+ 5;" e` commento  + 5;
              e non e` possibile dividerlo
              su piu` righe
  ...
}

Benche` esistano due distinti metodi per commentare il codice, non e` possibile avere commenti annidati, il primo simbolo tra // e /* determina il tipo di commento che l'analizzatore lessicale si aspetta. Bisogna anche ricordare di separare sempre i caratteri di inizio commento dall'operatore di divisione (simbolo /):
 

  a + c        //* commento */ su
                 una sola riga

Tutto cio` che segue "a + c" viene interpretato come un commento iniziato da //, e` necessario inserire uno spazio tra / e /*.



Identificatori

Gli identificatori sono simboli definiti dal programmatore per riferirsi a cinque diverse categorie di oggetti:

All'interno delle espressioni e` possibile inserire direttamente dei valori, questi valori sono detti costanti letterali. La generica costante letterale puo` essere un carattere racchiuso tra apice singolo, una stringa racchiusa tra doppi apici, un intero o un numero in virgola mobile.

 

    'a'          // Costante di tipo carattere
    "a"          // Stringa di un carattere
    "abc"        // Ancora una stringa

Un intero puo` essere:

Nella rappresentazione in esadecimale, oltre alle cifre decimali, e` consentito l'uso delle lettere da "A" a "F" e da "a" a "f".
Si noti che un segno puo` essere espresso solo in base 10, negli altri casi esso e` sempre +:

 

    +45          // Costante intera in base 10,
    055          // in base 8
    0x2D         // ed in base 16

Si puo` forzare il tipo da utilizzare aggiungendo alla costante un suffisso costituito da u o U, e/o l o L: la lettera U seleziona i tipi unsigned e la L i tipi long; se solo una tra le due lettere viene specificata, viene scelto il piu` piccolo di quelli atti a contenere il valore e selezionati dal programmatore:

 

    20           // intero in base 10
    024          // 20 in base 8
    0x14         // 20 in base 16
    0x20ul       // forza unsigned long
    0x20l        // forza long
    0x20u        // forza unsigned

Un valore in virgola mobile e` costituito da:

L'uso della lettera E indica il ricorso alla notazione scientifica.
E` possibile omettere uno tra l'intero decimale e la frazione decimale, ma non entrambi. E` possibile omettere uno tra il punto decimale e la lettera E (o e) e l'intero decimale con segno, ma non entrambi.
Il tipo scelto per rappresentare una costante in virgola mobile e` double, se non diversamente specificato utilizzando i suffissi F o f per float, o L o l per long double. Esempi:

 

    .0          // 0 in virgola mobile
    110E+4      // 110 * 10000 (10 elevato a 4)
    .14e-2      // 0.0014
    -3.5e+3     // -3500.0
    3.5f        // forza float
    3.4L        // forza long double

   [ ]  ( )  { }  +  -  *  %  !  ^  &   

   =  ~  |  \  ;  '  :  "  <  >  ?  ,  .   

   ++  --  ->  .*  ->*  <<  >>  <=  >=  ==  !=  &&   

   ||  +=  -=  *=  <<=  /=  %=  &=  ^=  |=  ::  >>=