Come tutti i linguaggi di programmazione anche il C++ pone le sue basi su presupposti matematici, ecco quindi gli operatori di base (le doppie virgolette ovviamente non sono parte dei simboli):

• "+" = la normalissima operazione di somma (es. 2 + 2 uguale  4).
• "-" = la sottrazione (es. 2 - 1 uguale  1).
• "*" = la moltiplicazione (es. 2 * 5 uguale  10).
• "/" = la divisione (es. 18 / 3 uguale  6)
• "%" = il modulo, fornisce il resto di una divisione (es. 10 % 3 uguale 1 poichè 1 è il resto della divisione di 10 / 3)
• "=" = l'assegnazione uguale impone ad un primo elemento di essere uguale ad un secondo elemento (es. x = 3, x è uguale a 3)

Per chiarire la simbologia vediamo alcuni esempi rapidi:

//Dichiariamo le nostre variabili
int var_uno = 5;
int var_due = 3;
int var_tre = 6;

//Facciamo qualche operazione
cout << "La variabile 1 sommata alla 3: " << var_uno + var_due << "\n";
cout << "La v. 1 sottratta alla 3: " << var_tre - var_uno << "\n";
cout << "La v. 1 moltiplicata per la 2: " << var_uno * var_due << "\n";
cout << "La v. 1 divisa per la 2: " << var_uno / var_due << ", resto " << var_uno % var_due << "\n\n";

OPERATORI DI MODIFICA PIU' COMPLESSI
Ciò che fa del C++ un linguaggio "speciale"

Ecco di seguito gli operatori "avanzati" del C++ (dai quali ha preso il nome il linguaggio stesso):

• "++" = incrementa di uno un determinato valore (es. 1++ è uguale a 2, variabile++ = variabile + 1).
• "--" = decrementa di uno un determinato valore (es. 22-- è uguale a 21, variabile-- uguale variabile - 1).
• ">>" = scorrimento dei bit a destra (es. 16 >> 1 è uguale a 8, 16 >> 2 è uguale a 4, 16 >> 3 è uguale a 2).
• "<<" = scorrimento dei bit a sinistra (es. 16 << 1 è uguale a 32, 15 << 2 è uguale a 60).

Bisogna dire ora che se mettiamo "++" (o "--") prima di ciò che deve essere incrementato (o diminuito) otterremo l'incremento prima di un'eventuale valutazione della variabile mentre se decidiamo di mettere l'operatore "++" (o "--") dopo ciò che deve essere elaborato otterremo prima la valutazione e poi l'incremento (o la diminuzione). Gli operatori "++" e "--" trovano largo impiego nei cicli e nelle iterazioni di cui parleremo più avanti. Per quanto riguarda ">>" e "<<" diciamo che per ora non sono parte fondamentale della trattazione (accontentiamoci di sapere che esistono).

Passiamo adesso ad un esempio pratico di quanto detto:

//Usiamo "++", "--" e "="
int var_quattro = 1;
int var_cinque = 1;

//Il "++" prima la variabile
cout << "La variabile var_quattro con ++ prima della variabile: " << ++var_quattro << "\n";

//Il "++" dopo la variabile
cout << "La variabile var_cinque con ++ dopo la variabile: " << var_cinque++ << "\n";
cout << "La variabile var_cinque dopo essere stata stampata: " << var_cinque << "\n\n";

GLI OPERATORI DI COMPARAZIONE
Come confrontare dei valori per poi eseguire determinate azioni

A questo punto, dato che abbiamo passato in rassegna i più importanti operatori in grado di modificare le variabili, rivolgiamo la nostra attenzione verso la simbologia matematica che ci permette di compararne i valori. Immaginiamo di avere due espressioni (A e B):

• "A == B" (da non confondere con l'assegnazione "=" che non controlla ma impone) verifica se un primo elemento A è uguale ad un secondo elemento B (non viceversa).
• "!A" (operatore NOT) riceve un solo argomento (in questo caso A) e sta ad indicare che se che se A è vero !A sarà falso e viceversa (in sostanza "!" restituisce l'opposto di A).
• "A != B" verifica se un primo elemento A è diverso da un secondo elemento B (in caso di diversità restituisce un valore true).
• "A > B" verifica se un primo elemento A è strettamente maggiore di un secondo elemento B.
• "A >= B" verifica se un primo elemento A è maggiore o uguale ad un secondo elemento B.
• "A < B" verifica se un primo elemento A è strettamente minore di un secondo elemento B.
• "A <= B" verifica se un primo elemento A è minore o uguale ad un secondo elemento B.
• "A && B" (AND logico) restituisce un valore true se entrambe le espressioni A e B sono vere.
• "A || B" (OR logico) restituisce un valore true se almeno una delle espressioni A e B sono vere.

Ciascuno di questi segni restituisce in sostanza un valore booleano: o vero o falso, o "0" o "1" (0 falso se la relazione non è verificata, 1 vero se la relazione è veritiera). Questi nuovi operatori ci torneranno utili quando dovremo verificare determinate condizioni per poi generarne altre (ma di questo avremo modo di parlare più approfonditamente in seguito).

Per chiarire i concetti esaminiamo il seguente listato:

//Alcune comparazioni con relativo valore true o false
cout << "LEGENDA\n1 espressione vera\n0 espressione falsa\n\n";
cout << "1 == 1: " << (int)(1 == 1) << "\n";
cout << "1 != 1: " << (int)(1 != 1) << "\n";
cout << "1 > 1: " << (int)(1 > 1) << "\n";
cout << "1 <= 1: " << (int)(1 <= 1) << "\n";
cout << "1 + 1 == 2 && 1 - 1 == 2: " << (int)(1 + 1 == 2 && 1 - 1 == 2) << "\n";
cout << "1 + 1 == 2 || 1 - 1 == 2: " << (int)(1 + 1 == 2 || 1 - 1 == 2) << "\n";

GLI ASSEGNAMENTI VELOCI O "ABBREVIATI"
Operatori che sostituiscono operazioni "macchinose"

• "A += B" somma il valore B ad A.
• "A -= B" sottrae il valore B ad A.
• "A *= B" moltiplica il valore A per B.
• "A /= B" divide il valore A per B.

Ecco invece quelli più complicati (e per ora di facoltativa comprensione):

• "A %= B" salva il modulo (il resto) di A con B.
• "A <<= B" esegue uno scorrimento a sinistra in A del numero di bit specificato in B.
• "A >>= B" esegue uno scorrimento a destra in A del numero di bit specificato in B.
• "A &= B" esegue un AND bit-a-bit di A.
• "A |= B" esegue un OR bit-a-bit di A.
• "A ^= B" esegue un'inversione bit-a-bit di A.

GLI OPERATORI SUI BIT
Un approfondimento veloce

Elenchiamo per completezza gli operatori sui bit (anche se ad un programmatore principiante in realtà non serviranno a molto):

• "~A" calcola un NOT bit-a-bit (se un bit è uguale a 0 gli viene assegnato il valore 1 e viceversa).
• "A << B" fa scorrere un numero a sinistra di un determinato numero di bit (es. 1011 << 2 è uguale a 1100).
• "A >> B" fa scorrere un numero a destra di un determinato numero di bit (es. 1011 >> 2 è uguale a 0010).
• "A & B" esegue un AND bit-a-bit, se i bit nelle posizioni corrispondenti sono sia a destra che a sinistra uguali a 1 restituisce 1 altrimenti 0 (es. 1011 & 1010 è uguale a 1010).
• "A | B" esegue un OR bit-a-bit, se almeno uno dei bit nelle posizioni corrispondenti è uguale sia a destra che a sinistra a 1 restituisce 1 altrimenti 0 (es. 1011 | 1010 è uguale a 1011).
• "A ^ B" esegue uno XOR (OR esclusivo) bit-a-bit, se uno solo dei bit nelle posizioni corrispondenti è uguale sia a destra che a sinistra a 1 restituisce 1 altrimenti 0 (es. 1011 ^ 1010 è uguale a 0001).

LE PRECEDENZE NELLE OPERAZIONI DI CALCOLO
Ciò che viene eseguito prima e ciò che viene dopo

Rivolgiamo infine la nostra attenzione sull'ordine in cui gli operatori studiati in questo documento verranno eseguiti (il n°1 sarà il primo "calcolo" ad essere portato a termine):

1. "()" ciò che sta tra parentesi viene eseguito con la massima priorità.
2. "++" incremento, "--" decremento, "~" NOT bit-a-bit, "!" NOT.
3. "*" moltiplicazione, "/" divisione, "%" modulo (il resto di una divisione).
4. "+" somma, "-" sottrazione.
5. ">>" e "<<" scorrimenti di bit.
6. "<"minore, "<=" minore o uguale, ">" maggiore, ">=" maggiore o uguale.
7. "==" confronto di uguaglianza, "!=" confronto di diversità.
8. "&" AND bit-a-bit.
9. "^" XOR bit-a-bit.
10. "|" OR bit-a-bit.
11. "&&" AND logico.
12. "||" OR logico.
13. "?:" la più bassa precedenza (per comprendere a cosa serve vedere l'esempio seguente).

//Esempi di precedenze nelle operazioni di calcolo
int var_sei = 3;
int var_sette = 8;
int var_otto;

//Esempio "()"
cout << "(var_sette - var_sei) * var_sette = " << (var_sette - var_sei) * var_sette << "\n";
//Esempio di "?:" (bassa precedenza):
//se var_sette è strettamente maggiore di var_otto allora var_otto diventerà uguale a var_otto + 12
var_otto = (var_sette > var_otto) ? var_otto + 12 : var_otto;
cout << "L'esempio con ?: restituisce " << var_otto << "\n";
//Esempio "%"
var_otto = (var_sei + var_sette) % var_sei;
cout << "L'esempio con % restituisce " << var_otto;