Linguaggio C++

Operatore Logico NOT

Stampa WhatsApp Email

L'operatore logico NOT (!) in C++: inversione dei valori booleani, gestione dei flag e logica di negazione per il controllo del flusso.

Durata

60 minuti

Software

Dev-C++

L'operatore logico NOT, rappresentato dal punto esclamativo !, è un operatore unario: agisce su una singola condizione invertendone il valore.

[Image of NOT gate logic diagram and truth table]
Pensa al NOT come a un invertitore: se la luce è accesa, premendo il NOT la spegni. Se è spenta, la accendi. Trasforma il Vero in Falso e viceversa.

Sintassi e Tabella di Verità


bool luceAccesa = true;

if (!luceAccesa) {
    // Questo codice viene eseguito se la luce NON è accesa (quindi se è falsa)
}
A !A (NOT)
VeroFalso
FalsoVero

Quando è utile il NOT?

Il NOT è fondamentale quando è più semplice ragionare su cosa non deve accadere o per controllare variabili di stato (flag).

  • Controllare se un file non è stato aperto.
  • Verificare se un utente non è autorizzato.
  • Invertire il ciclo di un programma (es. mentre NON premi ESC).

Esempi Pratici di "Inversione Logica"

Il Sensore di Ostacolo (Robotica)

Immaginiamo un robot aspirapolvere. Il robot deve continuare a camminare finché NON rileva un ostacolo davanti a sé. 


bool ostacoloRilevato = false; 

// Se NON c'è un ostacolo, il robot avanza
if (!ostacoloRilevato) {
    cout << "Strada libera: il robot avanza...";
} else {
    cout << "OSTACCOLO! Cambio direzione.";
}

Il Controllo "Serbatoio Vuoto"

A volte è più intuitivo programmare un'azione quando una condizione manca. Ad esempio, una spia luminosa che si accende se il serbatoio NON è pieno. 


bool serbatoioPieno = false;

if (!serbatoioPieno) {
    cout << "\t[WARNING] Carburante in esaurimento!\n";
}

Validazione Email o Campi Obbligatori

In un sistema di registrazione, un errore deve essere mostrato se il campo "Email" NON è stato compilato. 


bool campoCompilato = false;

if (!campoCompilato) {
    cout << "\tERRORE: Devi inserire i tuoi dati per procedere!";
}
LABORATORIO NOT

Stati di Sistema e Negazione

1 Esercizio: Il Flag di Sistema (Abilitato/Disabilitato)

Scriviamo un programma che simula l'attivazione di un allarme. Usiamo una variabile booleana come "interruttore". 


#include <iostream>
using namespace std;

int main() {
    bool allarmeAttivo = false; // Stato iniziale: spento
    int scelta;

    cout << "Stato Allarme: " << allarmeAttivo << " (0=Spento, 1=Acceso)\n";
    cout << "Vuoi cambiare lo stato? (1=Sì, 0=No): ";
    cin >> scelta;

    if (scelta == 1) {
        allarmeAttivo = !allarmeAttivo; // Inverto lo stato attuale
    }

    if (allarmeAttivo) {
        cout << "\n[!] ATTENZIONE: Sistema di sicurezza ATTIVATO.";
    } else {
        cout << "\n[ ] Sistema di sicurezza DISATTIVATO.";
    }

    return 0;
}

2 Esercizio in autonomia: Controllo Password Errata

Spesso nei programmi di sicurezza si agisce se la condizione di validità non è soddisfatta.

  • Chiedere all'utente di inserire una password (stringa).
  • Creare una condizione if (!(password == "segreto123")).
  • Se la condizione è vera (ovvero la password NON è "segreto123"), stampare "Accesso Negato!".
  • Altrimenti stampare "Benvenuto!".

3 Esercizio Creativo: Sensore di Movimento

In un sistema domotico, una lampada deve rimanere accesa solo se il sensore non rileva luce solare E rileva movimento.

  • Chiedere all'utente se c'è luce solare (1=Sì, 0=No).
  • Chiedere se c'è movimento (1=Sì, 0=No).
  • La lampada si accende se: (!luceSole && movimento).
  • Usate \t e \n per mostrare lo stato della lampada in una cornice di asterischi.

4 Esercizio Avanzato: Gestore Sessione con Flag Booleano

In questo esercizio vedremo come l'operatore NOT possa essere usato per gestire la chiusura di un programma. Utilizzeremo una variabile booleana chiamata esegui che manterrà in vita il ciclo finché non decideremo di "negarla".

Logica del programma:
  • Inizializziamo bool esegui = true;.
  • Il ciclo while(esegui) continuerà a ripetersi finché la variabile è vera.
  • All'interno dello switch, l'opzione "Esci" userà il NOT per invertire la variabile: esegui = !esegui; (facendola diventare false).

#include <iostream>
using namespace std;

int main() {
    int scelta;
    bool esegui = true; // Il nostro interruttore logico

    while (esegui) {
        cout << "\n\t***********************************";
        cout << "\n\t* SISTEMA GESTIONALE        *";
        cout << "\n\t***********************************";
        cout << "\n\t1. Visualizza Profilo";
        cout << "\n\t2. Impostazioni";
        cout << "\n\t0. ESCI";
        cout << "\n\t***********************************";
        cout << "\n\tScelta: ";
        cin >> scelta;

        switch (scelta) {
            case 1:
                cout << "\n\t[INFO] Caricamento profilo utente...\n";
                break;
            case 2:
                cout << "\n\t[SETTING] Apertura pannello opzioni...\n";
                break;
            case 0:
                cout << "\n\t[LOG] Spegnimento sistema in corso...\n";
                // Usiamo il NOT per invertire il flag e uscire dal ciclo
                esegui = !esegui; 
                break;
            default:
                cout << "\n\t[ERRORE] Opzione non valida!\n";
        }
    }

    cout << "\n\t--- PROGRAMMA TERMINATO ---\n";
    return 0;
}

5 Esercizio in autonomia: Simulatore di Smart TV

Crea un programma che simuli il menu di una Smart TV:

  • Usa un ciclo while basato su una variabile booleana accesa.
  • Nello switch inserisci le opzioni: 1. Netflix, 2. YouTube, 3. Canali TV.
  • Inserisci l'opzione 0. Spegni che deve invertire lo stato della variabile booleana usando l'operatore !.
  • Sfida: Ogni volta che l'utente sceglie un'app (es. Netflix), usa \t e \n per disegnare un logo stilizzato fatto di caratteri ASCII.

Esempio di output desiderato: 

\t\t[ SMART TV - HOME ]
\t1. Netflix \t 2. YouTube
\t3. Canali  \t 0. SPEGNI
\n
\tScelta: 0
\n
\t\t[!] Spegnimento...




C++, NOT, !, Logica Booleana, Inversione, Programmazione,