Benvenuto! Per postare e godere delle funzionalità del forum registrati, occorrono pochi secondi ed è gratis!

[Guida] Il C++ [CH.06 : gli Operatori]

Il criceto mannaro
Messaggi: 3,536
Discussioni: 201
Registrato: 03-2011
Mix: 3,737
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


digger
13/03/2011, 0:50
#1
Cerca




Utenti che stanno guardando questa discussione: 1 Ospite(i)