Linguaggio C++

Iterazione While Do

L'istruzione di iterazione pre-condizionale 'while' in C++. Analisi del funzionamento, della sintassi e applicazione pratica in Dev-C++ per la risoluzione di problemi algoritmici con controllo in testa.

Durata

150 minuti

Software

Dev-C++

L'istruzione while è una struttura di controllo definita pre-condizionale o a "controllo in testa". Questo significa che la condizione viene verificata prima di eseguire il blocco di istruzioni. Se la condizione è falsa sin dall'inizio, il corpo del ciclo non verrà eseguito nemmeno una volta.

Usa il while quando non sai a priori quante volte l’istruzione dovrà essere ripetuta e quando è possibile che l’operazione non debba essere eseguita affatto.
Sintassi del ciclo while:

while (condizione) {
    // Blocco di istruzioni da eseguire
    // Deve esserci qualcosa che modifica la condizione!
}

A differenza del do-while, qui non serve il punto e virgola dopo la condizione del while. È invece fondamentale che all'interno del ciclo avvenga una modifica alle variabili coinvolte nella condizione, altrimenti si genererà un ciclo infinito.

Differenze principali tra while e do-while:
Caratteristica Ciclo while (Pre-condizionale) Ciclo do-while (Post-condizionale)
Controllo condizione In testa (prima del blocco) In coda (dopo il blocco)
Esecuzioni minime Zero (se il test fallisce subito) Una (il blocco viene eseguito prima del test)
Sintassi while (cond) { ... } do { ... } while (cond);

Esempi Teorici


Contatore semplice

int i = 0;
while (i < 5) {
    cout << "Giro numero: " << i << endl;
    i++; // Incremento fondamentale per terminare il ciclo
}

Inserimento con tappo (Sentinel Value)

Leggere numeri e sommarli finché l'utente non inserisce 0.


int n, somma = 0;
cout << "Inserisci un numero (0 per terminare): ";
cin >> n;

while (n != 0) {
    somma += n;
    cout << "Inserisci il prossimo numero: ";
    cin >> n;
}
cout << "Totale: " << somma;



LABORATORIO

Monitoraggio e Controllo Soglie

In questo laboratorio utilizzeremo il ciclo while per simulare sistemi che devono restare in funzione finché non si raggiunge un limite critico.


1 Monitoraggio Temperatura Processore

Immaginiamo un sistema di sicurezza che monitora la temperatura di una CPU. Il sistema deve restare attivo finché la temperatura è sotto la soglia di sicurezza di 90°C.

  • Aprite Dev-C++ e create un nuovo file.
  • Inizializzate la variabile temp leggendo il primo valore.
  • Usate il while per continuare il monitoraggio finché temp < 90.

#include <iostream>
using namespace std;

int main() {
    float temp;
    
    cout << "Sistema di monitoraggio attivo." << endl;
    cout << "Inserisci temperatura attuale: ";
    cin >> temp;

    while (temp < 90.0) {
        cout << "[OK] Temperatura a " << temp << " gradi. Sistema stabile." << endl;
        cout << "Aggiorna temperatura: ";
        cin >> temp;
    }

    cout << "!!! ALLERTA !!! Temperatura critica: " << temp << " gradi. Spegnimento!" << endl;
    
    return 0;
}

2 Esercizio Guidato: Riempimento Automatico Cisterna

Dobbiamo simulare il riempimento di una cisterna da 1000 litri. Il programma deve aggiungere acqua in blocchi variabili finché non si raggiunge o supera la capacità massima.

Obiettivi della fase 2:
  • Variabile capacita_attuale inizialmente a 0.
  • Ciclo while che continua finché capacita_attuale < 1000.
  • All'interno del ciclo, chiedere quanti litri aggiungere.

#include <iostream>
using namespace std;

int main() {
    int capacita_attuale = 0;
    int aggiunta;
    const int MAX = 1000;

    while (capacita_attuale < MAX) {
        cout << "Livello attuale: " << capacita_attuale << " / " << MAX << endl;
        cout << "Quanti litri vuoi immettere? ";
        cin >> aggiunta;
        
        if (aggiunta > 0) {
            capacita_attuale += aggiunta;
        } else {
            cout << "Valore non valido!" << endl;
        }
    }

    cout << "Cisterna piena! Livello finale: " << capacita_attuale << endl;
    return 0;
}

Focus Tecnico: Gli Operatori di Assegnamento Composto

Nella programmazione C++, è molto comune aggiornare il valore di una variabile partendo dal suo valore attuale. Ad esempio, per incrementare una variabile x di 5, scriveremmo: x = x + 5;. Gli operatori composti ci permettono di scrivere la stessa operazione in modo più sintetico: x += 5;.

Tabella degli Operatori Composti:
Operatore Esempio Equivalente a... Utilizzo pratico in laboratorio
+= x += y; x = x + y; Aggiungere pezzi al magazzino o ricaricare credito.
-= x -= y; x = x - y; Scalare prodotti venduti o effettuare un pagamento.
*= x *= y; x = x * y; Applicare un raddoppio o un coefficiente di crescita.
/= x /= y; x = x / y; Dividere un totale in parti uguali.
%= x %= y; x = x % y; Calcolare il resto ciclicamente (es. turnazione).

Perché usarli?
1. Leggibilità: Il codice è più compatto.
2. Efficienza: In alcuni compilatori, l'operazione composta può essere leggermente più veloce a livello di microprocessore.
3. Manutenibilità: Se devi cambiare il nome della variabile, devi farlo in un solo punto invece di due.


3 Esercizio in autonomia: Simulazione Batteria Smartphone

Sviluppate un programma che simuli la scarica di una batteria di uno smartphone durante l'uso di un'applicazione pesante. In questa versione, non scaleremo i punti istantaneamente, ma simuleremo il "tempo di scarica" con delle pause nel programma.

Specifiche dell'algoritmo:
  • La batteria parte da 100.
  • Finché la batteria è superiore a 5, il programma chiede all'utente per quanti minuti intende usare l'app.
  • Per ogni minuto inserito, il programma deve mostrare un messaggio di "Scarica in corso..." e attendere un secondo prima di scalare i punti.
  • Regola di scarica: Ogni minuto di utilizzo scala 2 punti di batteria (usa l'operatore -=).
  • Se la batteria scende sotto il 20%, mostra l'avviso: "Risparmio energetico attivato!".
Come simulare il tempo in Dev-C++:

Per "fermare" il programma per qualche istante, dobbiamo includere la libreria <windows.h> e usare la funzione Sleep(millisecondi);.


#include <iostream>
#include <windows.h> // Libreria necessaria per la funzione Sleep

using namespace std;

int main() {
    int batteria = 100;
    int minuti;

    while (batteria > 5) {
        cout << "\nBatteria attuale: " << batteria << "%" << endl;
        if (batteria < 20) {
            cout << "[!] ATTENZIONE: Risparmio energetico attivo!" << endl;
        }

        cout << "Per quanti minuti vuoi usare l'App? ";
        cin >> minuti;

        // Simulazione dello scorrere del tempo
        cout << "Esecuzione App in corso..." << endl;
        for(int i = 0; i < minuti; i++) {
            Sleep(500); // Pausa di mezzo secondo (500 ms) per ogni minuto simulato
            cout << ". "; 
        }
        
        // Utilizzo dell'operatore composto per scalare la batteria
        batteria -= (minuti * 2);

        if (batteria < 0) batteria = 0; // Evitiamo percentuali negative
    }

    cout << "\n[X] Batteria scarica (5%). Collega il caricabatterie!" << endl;
    return 0;
}
Approfondimento: Estetica della Console

Volete rendere la simulazione ancora più realistica? Potete "pulire" la console ad ogni ciclo per far sì che la percentuale della batteria sembri aggiornarsi sempre nello stesso punto.

  • Utilizzate il comando system("cls"); per pulire lo schermo su Windows.

// Inserito all'inizio del ciclo while
system("cls"); 
cout << "--- SMARTPHONE SIMULATOR ---" << endl;

4 Esercizio in autonomia: Controllo Accessi Palestra

Un centro sportivo ha una capienza massima di 50 persone per motivi di sicurezza.

  • Il programma parte con un numero di persone presenti (inserito dall'utente).
  • Finché i presenti sono meno di 50, il programma permette di registrare nuovi ingressi.
  • Ad ogni ingresso viene chiesto quanti entrano. Se l'ingresso supera quota 50, il sistema deve impedire l'operazione.
  • Il programma termina quando viene raggiunta esattamente la capienza massima.





C++, While, Iterazione, Programmazione, Controllo in testa, Scuola Superiore,