De ce contează?
Gândește-te la întrerupătorul de pe perete: el are doar două stări, aprins sau stins, fără nimic la mijloc. La fel funcționează și răspunsul la o întrebare de tip DA/NU: „Plouă afară?" are un singur răspuns corect în acest moment, da sau nu. Calculatorul are nevoie exact de acest fel de valoare cu două stări ca să poată lua decizii, iar acela este tipul logic.
Intuiția
Până acum, variabilele tale țineau numere: un int poate fi 7, sau -3, sau 1000. Dar de multe ori nu te interesează cât de mare e un număr, ci doar un răspuns simplu: „este pozitiv?", „sunt egale?". Răspunsul nu e niciodată un număr oarecare, ci unul dintre doar două cuvinte: adevărat sau fals. Aceasta este o valoare logică, iar tipul care o ține se numește bool (de la boolean).
Ce este
Tipul bool este un tip de date care poate avea doar două valori: true (adevărat) și false (fals). Nu există a treia stare, exact ca la întrerupător.
De unde apar aceste valori? Cel mai des, dintr-o comparație. Când scrii o întrebare despre numere, calculatorul îți dă înapoi un bool:
7 > 3producetrue(7 chiar este mai mare decât 3)2 == 5producefalse(2 nu este egal cu 5)4 != 4producefalse(4 chiar este egal cu 4, deci „diferit" e fals)
Operatorii de comparație sunt: == (egal), != (diferit), <, >, <=, >=.
În C++, true se stochează în memorie ca numărul 1, iar false ca numărul 0. De aceea poți chiar aduna rezultate logice între ele: dacă numeri câte condiții sunt adevărate, fiecare „adevărat" valorează 1. Pe scurt: fals înseamnă 0, orice altceva înseamnă adevărat.
Operatorii logici: ȘI, SAU, NU
De multe ori vrei să combini mai multe întrebări într-una singură: „numărul este par ȘI pozitiv?". Pentru asta ai trei operatori logici:
&&— operatorul ȘI: adevărat doar dacă AMBELE condiții sunt adevărate.||— operatorul SAU: adevărat dacă măcar UNA dintre condiții e adevărată.!— operatorul NU: răstoarnă valoarea (adevărat devine fals, fals devine adevărat).
Cum arată: tabelele de adevăr
Un tabel de adevăr arată rezultatul pentru fiecare combinație posibilă de intrări. Pentru că fiecare condiție are doar două stări, tabelele sunt scurte.
ȘI (&&) — pretențios: îți cere totul. Un singur „fals" strică rezultatul.
| a | b | a && b |
|---|---|---|
| fals | fals | fals |
| fals | adevărat | fals |
| adevărat | fals | fals |
| adevărat | adevărat | adevărat |
SAU (||) — generos: îi ajunge o singură condiție adevărată.
| a | b | a || b |
|---|---|---|
| fals | fals | fals |
| fals | adevărat | adevărat |
| adevărat | fals | adevărat |
| adevărat | adevărat | adevărat |
NU (!) — simplu: întoarce valoarea pe dos.
| a | !a |
|---|---|
| fals | adevărat |
| adevărat | fals |
Observă tiparul: && dă adevărat o singură dată (când totul e adevărat), iar || dă fals o singură dată (când totul e fals). Sunt oglinda unul altuia.
Implementare C++
Hai să citim un număr și să verificăm dacă este par ȘI pozitiv în același timp. Folosim && ca să legăm cele două condiții.
#include <iostream>
using namespace std;
int main() {
int n;
cin >> n;
// n % 2 == 0 verifica daca e par (restul impartirii la 2 e zero)
// n > 0 verifica daca e pozitiv
// && cere ca AMBELE sa fie adevarate
bool parSiPozitiv = (n % 2 == 0) && (n > 0);
if (parSiPozitiv) {
cout << "Da, e par si pozitiv";
} else {
cout << "Nu";
}
return 0;
}Urmărește ce se întâmplă pentru câteva valori concrete:
n = 6:6 % 2 == 0e adevărat,6 > 0e adevărat →true && true= adevărat → „Da".n = 3:3 % 2 == 0e fals (restul e 1) →false && ...= fals → „Nu".n = -4:-4 % 2 == 0e adevărat, dar-4 > 0e fals →true && false= fals → „Nu".
Cu && e destul ca o singură condiție să cadă pentru ca tot răspunsul să fie „Nu" — exact ca în tabelul de adevăr de mai sus.
Două capcane clasice, ușor de făcut și greu de observat:
1. = în loc de ==. Un singur = înseamnă atribuire, nu comparație. Dacă scrii if (x = 5), nu compari x cu 5 — îi pui lui x valoarea 5. Rezultatul atribuirii este 5, iar 5 e diferit de 0, deci condiția e mereu adevărată, indiferent ce avea x înainte. Pentru a compara, ai nevoie de == (două semne egal).
2. & în loc de && (și | în loc de ||). Un singur & sau | este un operator pe biți, care lucrează altfel decât te aștepți. Pentru condiții logice (ȘI, SAU) folosește mereu varianta dublă: && și ||.