Instrucțiuni de decizie

1. Introducere

Atunci când interacționăm cu un calculator, ne așteptăm ca acesta să poată lua decizii, la fel ca un om. De exemplu, dacă introducem o parolă corectă, vrem să avem acces la contul nostru; dacă jucăm un joc video, ne dorim ca oponentul să reacționeze diferit în funcție de acțiunile noastre. Dar cum știe un program ce trebuie să facă în funcție de o situație? Răspunsul este: instrucțiunile de decizie.

În viața reală, ne confruntăm constant cu decizii:

• Dacă plouă, luăm o umbrelă.
• Dacă semaforul e verde, traversăm strada.
• Dacă un produs are reducere, poate că îl cumpărăm.

Exact aceeași logică poate fi transpusă într-un limbaj de programare. În C++, acest lucru se realizează prin instrucțiunile condiționale, cum ar fi if, if-else, switch-case sau operatorul ternar (?:). Acestea permit unui program să evalueze o condiție și să execute anumite acțiuni în funcție de rezultatul evaluării.

Fără aceste mecanisme, programele ar fi statice și incapabile să reacționeze la datele primite de la utilizatori sau la schimbările din mediul de execuție. De exemplu, fără if, un joc video nu ar putea decide când un jucător a câștigat sau a pierdut, iar o aplicație bancară nu ar putea verifica dacă soldul este suficient pentru a efectua o tranzacție.

În acest articol, vom explora în detaliu cum să implementăm aceste decizii în C++, astfel încât programele noastre să fie mai inteligente, mai flexibile și mai interactive.

2. Instrucțiuni de decizie în C++

În această secțiune, vom explora cum putem determina un program C++ să ia decizii, folosind diferite tipuri de instrucțiuni condiționale. În esență, aceste instrucțiuni funcționează evaluând o expresie logică (o condiție), iar în funcție de rezultat, programul decide ce bloc de cod să execute.

Deciziile se bazează pe operatori de comparație (==, !=, <, >, <=, >=) și operatori logici (&&, ||, !). De exemplu, o expresie precum x > 10 verifică dacă variabila x este mai mare decât 10. Dacă expresia este adevărată (true), se execută un anumit bloc de cod; altfel, se poate executa altceva.

C++ oferă mai multe modalități de a implementa instrucțiuni condiționale:

• if – Verifică dacă o condiție este adevărată – execuție condiționată.
• if-else – Alege între două opțiuni posibile – ramificare.
• if-else if-else – Permite mai multe ramificații.
• Operatorul ternar ? : – O variantă scurtă a if-else.
• switch-case – Alternativă eficientă pentru verificarea unei singure valori.

Vom analiza fiecare dintre aceste structuri, vom explica când și cum să le folosim și vom oferi exemple practice. La finalul acestui articol vei înțelege cum să implementezi decizii logice în programele tale, făcându-le mai interactive și mai dinamice.

Înainte de a scrie mici programe care să ilustreze modul în care putem folosi instrucțiunile de decizie, haideți să învățăm din greșeli. Vă recomand să analizați atent fiecare dintre erorile prezentate mai jos și să încercați mai întâi să vă dați seama ce ar putea funcționa greșit.

3. Bune practici în utilizarea instrucțiunilor de decizie

Luarea deciziilor în C++ este un concept fundamental, dar poate deveni complicată dacă nu aplicăm bune practici în scrierea codului. Un cod bine structurat este mai ușor de înțeles, de întreținut și reduce posibilitatea apariției erorilor. În această secțiune, vom explora câteva situații frecvente în care dezvoltatorii pot întâmpina dificultăți și vom propune soluții mai eficiente și mai clare.

---

3.1. Utilizarea acoladelor {} pentru claritate și siguranță

În C++, dacă un bloc if sau else conține o singură instrucțiune, acoladele {} nu sunt obligatorii. Cu toate acestea, este o bună practică să le folosim întotdeauna pentru claritate și pentru a evita erori neașteptate.

🔹 Mai puțin recomandat (posibilă sursă de bug-uri):

if (x > 10) 
    cout << "Numărul este mare!";
    cout << "Aceasta este o altă linie."; // Aceasta se execută mereu, chiar dacă if-ul e fals!

🔹 O variantă mai clară și mai sigură:

if (x > 10) {
    cout << "Numărul este mare!";
    cout << "Aceasta este o altă linie.";
}

De ce este mai bine? Utilizarea acoladelor elimină ambiguitatea și asigură că toate instrucțiunile relevante sunt cuprinse în blocul if.

---

3.2. Optimizarea verificărilor logice

Un program poate avea mai multe ramificații, iar folosirea else acolo unde este posibil poate reduce numărul de verificări.

🔹 Mai puțin eficient (două verificări separate):

if (x >= 18) {
    cout << "Ești adult.";
}
if (x < 18) {
    cout << "Ești minor.";
}

🔹 Variantă mai eficientă și mai clară:

if (x >= 18) {
    cout << "Ești adult.";
} else {
    cout << "Ești minor.";
}

De ce este mai bine? În a doua variantă, evităm o verificare suplimentară, deoarece dacă x nu este mai mare sau egal cu 18, atunci cu siguranță este mai mic.

---

3.3. Evitarea condițiilor redundante

Uneori, condițiile pot fi simplificate pentru a face codul mai curat și mai ușor de citit.

🔹 Cod care poate fi optimizat:

if (x > 10) {
    cout << "Numărul este mare.";
} else if (x <= 10) { // Această verificare este redundantă
    cout << "Numărul este mic sau egal cu 10.";
}

🔹 O variantă mai simplă și mai clară:

if (x > 10) {
    cout << "Numărul este mare.";
} else {
    cout << "Numărul este mic sau egal cu 10.";
}

De ce este mai bine? Eliminăm verificarea redundantă x <= 10, deoarece else acoperă automat această posibilitate.

---

3.4. Alegerea potrivită între if-else și switch-case

Când avem mai multe opțiuni distincte pentru o singură variabilă, switch-case poate fi mai eficient și mai clar decât mai multe blocuri if-else.

🔹 Caz în care if-else poate fi greu de citit:

if (zi == 1) {
    cout << "Luni";
} else if (zi == 2) {
    cout << "Marți";
} else if (zi == 3) {
    cout << "Miercuri";
} else {
    cout << "Zi invalidă!";
}

🔹 O variantă mai structurată folosind switch-case:

switch (zi) {
    case 1: cout << "Luni"; break;
    case 2: cout << "Marți"; break;
    case 3: cout << "Miercuri"; break;
    default: cout << "Zi invalidă!";
}

De ce este mai bine?

• switch este mai ușor de citit și clarifică toate opțiunile posibile.
• Este mai eficient atunci când verificăm o singură variabilă cu multe valori posibile.

---

3.5. Când să folosim operatorul ternar ? :

Operatorul ternar poate face codul mai concis, dar trebuie folosit doar pentru expresii scurte.

🔹 Mai puțin optim pentru cazuri mai complexe:

if (x % 2 == 0) {
    cout << "Numărul este par.";
} else {
    cout << "Numărul este impar.";
}

🔹 O alternativă concisă folosind operatorul ternar:

cout << (x % 2 == 0 ? "Numărul este par." : "Numărul este impar.");

De ce este mai bine? Pentru decizii simple, operatorul ternar reduce numărul de linii de cod și îmbunătățește claritatea. Totuși, dacă logica devine mai complicată, este mai bine să folosim if-else pentru lizibilitate.

---

Concluzie

Aplicarea bunelor practici în scrierea instrucțiunilor de decizie ne ajută să:

✅ Scriem cod mai clar și mai ușor de înțeles.

✅ Reducem erorile prin utilizarea corectă a acoladelor și a structurii if-else.

✅ Optimizăm codul evitând condițiile redundante și alegând switch-case acolo unde este potrivit.

✅ Utilizăm operatorul ternar eficient, fără a compromite lizibilitatea codului.

Respectarea acestor recomandări face programele mai robuste, mai ușor de întreținut și mai eficiente.

Acum că știm cum să evităm capcanele comune, putem explora o aplicație practică care pune în valoare aceste concepte!

4. Aplicație practică: Joc „Ghicitoare de numere”

Pentru a pune în practică ceea ce am învățat despre instrucțiunile de decizie, vom crea un mic joc interactiv numit „Ghicitoare de numere”. În acest joc, computerul va genera un număr aleatoriu între 1 și 10, iar utilizatorul va încerca să ghicească acest număr. Programul îi va spune dacă a ghicit corect sau nu.

Acest exercițiu este util deoarece:

✅ Folosește instrucțiuni if-else pentru luarea deciziilor.

✅ Utilizează input de la utilizator cu cin.

✅ Aplică generarea de numere aleatorii folosind biblioteca <cstdlib>.

---

4.1. Planul jocului

1. Computerul generează un număr aleatoriu între 1 și 10.
2. Utilizatorul introduce un număr.
3. Programul verifică:
   • Dacă numărul ghicit este corect, afișează un mesaj de succes.
   • Dacă numărul nu a fost „ghicit”, anunță utilizatorul și afișează numărul corect.
4. Programul se încheie.

---

4.2. Implementarea în C++

Iată codul complet al jocului:

#include <iostream>
#include <cstdlib>  // Pentru funcția rand()
#include <ctime>    // Pentru a genera un număr aleatoriu diferit la fiecare rulare

using namespace std;

int main() {
    // Inițializăm generatorul de numere aleatorii
    srand(time(0));
    int numar_secret = rand() % 10 + 1; // Număr între 1 și 10

    // Citim valoarea pe care o "ghicește" utilizatorul
    int ghicire;
    cout << "Ghiceste numarul (1-10): ";
    cin >> ghicire;

    // Verificăm dacă utilizatorul a ghicit numărul corect
    if (ghicire == numar_secret) {
        cout << "Felicitări! Ai ghicit numărul corect." << endl;
    } else {
        cout << "Ai ghicit gresit. Numarul era: " << numar_secret << endl;
    }

    return 0;
}

4.3. Explicarea codului

1. Generarea unui număr aleatoriu
   • Funcția srand(time(0)) asigură că numerele generate sunt diferite la fiecare rulare.
   • rand() % 10 + 1 generează un număr între 1 și 10.
2. Citim numărul introdus de utilizator
   • cin >> ghicire; preia input-ul utilizatorului și îl stochează în variabila ghicire.
3. Folosim instrucțiunea if-else pentru verificare
   • Dacă numărul introdus este egal cu cel generat (ghicire == numar_secret), afișăm un mesaj de succes.
   • În caz contrar, afișăm numărul corect.

---

4.4. Îmbunătățiri posibile

Acum că avem un joc de bază funcțional, putem adăuga noi caracteristici:

• Mai multe încercări – Să permitem utilizatorului să încerce de mai multe ori înainte de a pierde.
• Feedback despre diferența dintre numere – Să spunem dacă numărul introdus este mai mare sau mai mic decât cel secret.
• Adăugarea unui scor – Să numărăm încercările utilizatorului și să-i oferim un scor la final.

Iată cum putem permite utilizatorului trei încercări pentru a ghici numărul corect:

#include <iostream>
#include <cstdlib>
#include <ctime>

using namespace std;

int main() {
    srand(time(0));
    int numar_secret = rand() % 10 + 1;
    int ghicire, incercari = 3;

    cout << "Ghiceste numarul (1-10). Ai " << incercari << " încercări!" << endl;

    while (incercari > 0) {
        cout << "Introdu ghicirea ta: ";
        cin >> ghicire;

        if (ghicire == numar_secret) {
            cout << "Felicitări! Ai ghicit numărul corect." << endl;
            return 0; // Ieșim din program, deoarece a ghicit corect
        } else if (ghicire > numar_secret) {
            cout << "Numărul este mai mic!" << endl;
        } else {
            cout << "Numărul este mai mare!" << endl;
        }

        incercari--;
        if (incercari > 0) {
            cout << "Mai ai " << incercari << " încercări." << endl;
        }
    }

    cout << "Ai pierdut! Numărul corect era: " << numar_secret << endl;
    return 0;
}

Folosim în acest cod instrucțiunea while despre care nu am spus nimic. Dar asta nu trebuie să vă sperie, gândiți așa: „cât timp este adevărată condiția, execută încă o dată instrucțiunile dintre acolade”.

---

4.5. Cu ce am rămas?

Această aplicație practică demonstrează cum putem folosi instrucțiunile de decizie în C++ pentru a crea un program interactiv. Am învățat:

✅ Cum să luăm decizii folosind if-else.

✅ Cum să generăm un număr aleatoriu și să interacționăm cu utilizatorul.

✅ Cum să îmbunătățim un program adăugând mai multe funcționalități.

5. Concluzie și pași următori

Am parcurs un drum interesant în învățarea instrucțiunilor de decizie în C++, descoperind cum putem face programele să ia decizii inteligente. Aceste concepte sunt fundamentale în programare, iar stăpânirea lor îți va permite să scrii cod mai dinamic, interactiv și eficient.

---

5.1. Ce am învățat?

• Instrucțiunea if – ne permite să verificăm o condiție și să executăm un bloc de cod doar dacă aceasta este adevărată.
• if-else – oferă o alternativă în cazul în care condiția inițială nu este îndeplinită.
• if-else if-else – ne permite să testăm mai multe condiții succesive.
• Operatorul ternar ? : – o metodă compactă de a scrie un if-else simplu.
• switch-case – o metodă mai eficientă pentru verificarea unei singure variabile cu multiple valori posibile.
• Bune practici – evitarea erorilor comune, cum ar fi lipsa acoladelor {}, verificări redundante sau utilizarea greșită a switch-case.
• Aplicație practică – am creat un joc interactiv de ghicire a unui număr, aplicând conceptele învățate.

Acum, ești pregătit să folosești aceste instrucțiuni pentru a face programele tale mai inteligente și mai flexibile!

---

5.2. Ce urmează?

Acum că ai înțeles instrucțiunile de decizie, următorii pași logici sunt:

1. Bucle (for, while, do-while)

• Deciziile sunt adesea combinate cu bucle pentru a repeta anumite acțiuni (ex: repetarea unui joc până utilizatorul ghicește corect).
• Exercițiu sugerat: Creează o versiune îmbunătățită a jocului „Ghicitoare de numere” care permite utilizatorului să joace de mai multe ori.

2. Funcții și modularizare

• Organizarea codului în funcții reutilizabile face programele mai clare și mai ușor de întreținut.
• Exercițiu sugerat: Transformă jocul „Ghicitoare de numere” într-o funcție separată pe care să o poți apela oricând dorești.

3. Lucrul cu structuri de date (arrays, vectors, struct)

• Uneori, trebuie să luăm decizii pe baza unei colecții de date, nu doar pe variabile individuale.
• Exercițiu sugerat: Creează un program care citește notele unui elev, le stochează într-un vector și afișează un mesaj bazat pe media obținută.

4. Proiecte practice mai avansate

• Construirea unor mini-aplicații care folosesc decizii logice multiple (ex: un chatbot simplu, un sistem de recomandări sau un meniu interactiv).

5.3. La final

Felicitări! Acum ai o înțelegere solidă a instrucțiunilor de decizie în C++. Folosește-le în propriile proiecte și explorează mai departe lumea programării!

Tu ce vei programa în continuare?