OPERATORI
Abbiamo visto variabili e costanti, ma che ci facciamo con queste variabili e costanti (a parte printarle a video) ?
Semplice, possiamo "operare" su di esse.
Gli operatori sono molteplici, e nel linguaggio C++ sono costituiti da simboli come + - * / == etc
Ma vediamo quelli piu comuni e piu utili:
---------------------------
ASSEGNAZIONE =
---------------------------
il simbolo = serve ad "assegnare" un valore ad una variabile
ad esempio
nome = "digger";
eta = 20;
carattere = 'a';
---------------------------------
ARITMETICI + - * / %
---------------------------------
somma = var1 + var2;
sottrazione = var1 - var2;
moltiplicazione = var1 * var2;
divisione = var1 / var2;
modulo = var1 % var2;
Diciamo che si spiegano tutti da soli, l'unico di cui dire qualcosa è % ovvero "modulo".
Altro non è che il RESTO della divisione dei due operandi passati
Ovvero il resto della divisione di var1 per var2
--------------------------------------------
INCREMENTO e DECREMENTO ++ --
--------------------------------------------
questi operatori sono UNARI ovvero non hanno bisogno di 2 operandi, agiscono su uno singolo, in questo modo:
patate++ incrementa di 1 il valore della variabile "patate"
patate-- decrementa di 1 il valore della variabile "patate"
Ma se dovessimo aggiungere o togliere piu di 1 alla volta?
in questo caso tornano comodi gli operatori...
--------------------------------------
COMPOSTI += -= *= /= %=
--------------------------------------
indovinate cosa fanno...
prima applicano l'operatore aritmetico e poi assegnano il risultato alla variabile.
Quindi nell'esempio di prima se vogliamo aggiungere 2 alle patate invece che 1 diventa:
patate += 2;
se vogliamo sottrarre 2 diventa
patate -=2;
chiaro no? ovviamente avremmo potuto scrivere anche cosi:
patate = patate + 2;
patate = patate - 2;
ma facendo diventare il programma piu "prolisso".
-----------------------------------------------
RELAZIONALI == != < <= > >=
-----------------------------------------------
a differenza dei precedenti, questi operatori non servono a cambiare il valore di una variabile ma ad effettuare delle "verifiche" su di esse , ma vediamo degli esempi
patate == patate; patate è UGUALE a patate?
patate != mele; patate è DIVERSO da mele?
piccoli < grandi; piccoli è MINORE di grandi?
diesel <= bluediesel; il diesel è MINORE O UGUALE al bluediesel
grandi > piccoli; ... MAGGIORE
bluediesel >= diesel; ... MAGGIORE UGUALE
questi erano esempi tra variabili ma chiaramente possiamo usare delle costanti:
patate == 5; la variabile "patate" vale 5 ?
patate != 0; il valore la variabile "patate" è diverso da 0 ?
da notare che il risultato dell'operatore relazionale è sempre "true" o "false" (vero o falso)
vero e falso vengono detti valori "booleani"
vengono usati in quelle situazioni in cui lo stato può assumere solo 2 valori :
acceso/spento
vero/falso
si/no
...
quindi vediamo qualche altro esempio:
patate = 5; // assegnamo 5 alla variabile patate
patate == 6; // restituisce FALSE, perché 5 NON è uguale a 6
patate !=6; // restituisce TRUE, perché è vero che 5 è diverso da 6
una delle applicazioni piu comuni e utili dell'operatore relazionale è modificare il flusso del codice, cosa che vedremo in un prossimo tutorial, ma tanto per dare un esempio:
int stamina;
...
if (stamina==100) // se stamina vale 100 allora 100==100 torna TRUE e il codice viene eseguito
{
... codice da eseguire quando stamina è a 100
}
ovvero controlliamo se la variabile "stamina" vale 100 nel qual caso eseguiamo il codice contenuto nel blocco {}
il costrutto appena visto "if" funziona cosi:
if (condizione)
{
// eseguo questo codice
// se condizione è VERA
} else
{
// eseguo questo codice
/ se condizione è FALSA
}
ovvero dopo la parola chiave "if" segue l'espressione da valutare "condizione" che può essere una qualsiasi espressione che alla fine ci tornerà un valore booleano TRUE/FALSE (vero/falso)
a quel punto il costrutto if eseue il primo blocco {} se la condizione era TRUE altrimenti esegue il secondo blocco
Ma queste cose le vedremo...
---------------------------
LOGICI && || !
---------------------------
Visti quelli relazionali non si può non passare a quelli logici.
&& è la AND logica , ad es.
condizione1 && condizione2 tornerà true se condizione1 è vera E CONTEMPORANEAMENTE condizione2 è pure lei vera
ad esempio:
if ((hack_stamina==1) && (valore_stamina<100))
{
... codice stamina
}
ovvero controllo al tempo stesso che la variabile hack_stamina valga 1 e che la variabile valore_stamina sia minore di 100 allora eseguo il codice che segue
|| è l'OR logico , ad es.
condizione1 || condizione2 tornerà true se condizione1 è vera OPPURE condizione2 è vera
ad esempio:
if ((hack_stamina==1) || (hack_entra == true ))
{
... codice stamina
}
il codice viene eseguito se hack_stamina vale 1 MA ANCHE nel caso in cui hack_entra sia true, cioè basta che anche solo UNA delle 2 condizioni sia vera
da notare che per rendere il codice piu compatto, il check su una variabile booleana può essere scritto in 2 modi:
bool flag=true;
if (flag==true)
{
...
}
oppure
if (flag) // è sottointeso if (flag==true)
{
...
}
! è un'altro operatore unario, serve a "invertire" il valore di un'espressione/variabile.
ad esempio:
bool variabile = true; // dichiaro una variabile bool (booleana ovvero true/false) e le assegno il valore vero
if (variabile)
{
... eseguo questo codice
}
il codice viene eseguito perché variabile è vera (true), ma se scrivessi cosi? :
if (!variabile)
{
... ora questo codice non viene piu eseguito
}
perché ? perché variabile è vera, ma con il punto esclamativo (not) davanti inverto il valore che quindi diventa FALSE
quindi mi ritrovo con una cosa cosi:
if (false)
{
...ora questo codice non viene piu eseguito
}
chiaramente essendo la condizione "false" non eseguo il blocco di codice.
! può essere usato anche in altri modi, es:
variabile != variabile;
ovvero prendo il valore di variabile, lo nego e lo riassegno alla stessa, in pratica dopo questa operazione se variabile era true diventerà false, se era false diventerà true.
Ci sono altri operatori oltre a quelli visti (ad esempio gli operatori a bit) ma per stasera non aggiungo altro, quelli fin qui visti sono quelli piu utili, per gli altri documentatevi
digger