De ce contează?
Mergi pe un drum și ajungi la o bifurcație: un semafor decide pe unde o iei. Dacă e verde, mergi drept; altfel, o iei la stânga. Tu nu poți merge pe ambele drumuri deodată — alegi unul, în funcție de semn. Structura alternativă din program este exact această bifurcație: o condiție (semaforul) decide care drum (care bloc de cod) se execută.
Intuiția
Până acum, programele tale executau pașii unul după altul, în linie dreaptă. Dar de multe ori vrei să faci ceva doar dacă s-a întâmplat ceva: „dacă numărul e par, scrie un mesaj; altfel, scrie altul". Programul trebuie să poată alege. Condiția logică e semaforul: în funcție de ea, programul intră pe un drum sau pe celălalt — niciodată pe amândouă.
Ce este
Structura alternativă lasă programul să aleagă între două ramuri, în funcție de o condiție logică (o expresie care e fie adevărată, fie falsă):
if (conditie) {
// ramura A — se executa DOAR daca conditia e adevarata
} else {
// ramura B — se executa DOAR daca conditia e falsa
}Citește-o ca o propoziție: „dacă condiția e adevărată, fă A; altfel (else), fă B". Partea else e opțională — uneori vrei să faci ceva doar când condiția e adevărată și nimic în rest.
Regula de aur: dintre cele două ramuri se execută exact una, niciodată ambele și niciodată niciuna (când există else). Condiția e ca un comutator: o singură poziție e activă la un moment dat. Dacă ți se pare că „ambele se execută", aproape sigur ai pus din greșeală cod în afara acoladelor.
Cum arată
Să luăm un exemplu concret: citești un număr și vrei să afișezi dacă e par sau impar. Trucul: un număr e par exact când restul împărțirii lui la 2 este 0. În C++, restul se scrie n % 2. Deci condiția „numărul e par" se scrie n % 2 == 0.
Bifurcația arată așa — semaforul din vârf testează condiția, iar cele două drumuri de sub el sunt cele două ramuri:
Hai să urmărim care ramură se ia pe o valoare concretă, n = 7:
| Pas | Ce verifică / face | Rezultat |
|---|---|---|
| 1 | citește n | n = 7 |
| 2 | calculează n % 2 | 7 % 2 = 1 |
| 3 | condiția n % 2 == 0? | 1 == 0 este fals |
| 4 | fals → sare peste ramura if, intră pe else | afișează impar |
Pentru n = 8 ai fi mers pe celălalt drum: 8 % 2 = 0, condiția 0 == 0 e adevărată, deci s-ar fi executat ramura if și ai fi afișat par. Observă cum aceeași condiție trimite programul pe drumuri diferite, în funcție de date.
Mai multe cazuri: else if
Uneori ai mai mult de două drumuri. Atunci lanțui condițiile cu else if: programul le verifică pe rând, de sus în jos, și se oprește la prima care e adevărată. Exemplu: transformi o notă într-un calificativ.
| Condiție verificată | Dacă e adevărată | Dacă e falsă |
|---|---|---|
nota >= 9 | afișează Foarte bine, gata | treci mai jos |
nota >= 7 | afișează Bine, gata | treci mai jos |
nota >= 5 | afișează Suficient, gata | treci mai jos |
altfel (else) | afișează Insuficient | — |
Pentru nota = 8: prima condiție 8 >= 9 e falsă, deci treci mai jos; a doua 8 >= 7 e adevărată → afișează Bine și se oprește (nu mai verifică restul). De aceea ordinea contează: pui condițiile de la cea mai „strâmtă" spre cea mai „largă".
Implementare C++
Programul complet par/impar:
#include <iostream>
using namespace std;
int main() {
int n;
cin >> n;
// restul impartirii la 2 spune daca numarul e par
if (n % 2 == 0) {
cout << "par" << endl; // ramura pentru rest 0
} else {
cout << "impar" << endl; // toate celelalte cazuri
}
return 0;
}
// pentru n = 7 afiseaza: impar
// pentru n = 8 afiseaza: parȘi varianta cu else if pentru calificativ:
#include <iostream>
using namespace std;
int main() {
int nota;
cin >> nota;
// se verifica de sus in jos, se opreste la prima adevarata
if (nota >= 9) {
cout << "Foarte bine" << endl;
} else if (nota >= 7) {
cout << "Bine" << endl;
} else if (nota >= 5) {
cout << "Suficient" << endl;
} else {
cout << "Insuficient" << endl;
}
return 0;
}
// pentru nota = 8 afiseaza: BineDouă capcane clasice te pândesc în condiții.
1. = în loc de ==. Un singur egal (=) înseamnă „atribuie", iar dublul (==) înseamnă „compară". Dacă scrii if (n = 0), nu compari pe n cu zero — îi pui valoarea 0 și condiția devine mereu falsă. Vrei să întrebi „sunt egale?", deci folosești ==.
2. Scrierea unui interval ca în matematică. La școală scrii „mai mare decât zero și mai mic decât zece" sub forma scurtă din matematică, cu numărul la mijloc. În C++ acea formă nu verifică ce crezi: calculatorul evaluează doar câte două lucruri o dată, iar rezultatul intermediar (adevărat sau fals, adică 1 sau 0) ajunge comparat mai departe cu zece — și obții un răspuns fără sens. Forma corectă spune explicit ambele condiții, legate cu „și" (operatorul &&):
if (x > 0 && x < 10) {
cout << "x este intre 1 si 9" << endl;
}Reține: un interval se scrie ca două comparații separate, unite prin &&, nu ca o singură expresie cu numărul la mijloc.