Prima si ragiona. Poi si programma.

Programmare significa trasformare una richiesta in una sequenza di operazioni non ambigue. Prima di pensare alla sintassi bisogna riconoscere dati di ingresso, risultato atteso e procedimento.

Metodo guidato: dalla consegna alla soluzione

1. Sottolinea i dati forniti.“Leggi tre voti”: i tre voti sono gli input.
2. Cerchia il risultato richiesto.“Calcola la media”: la media è l’output.
3. Scrivi la formula a parole.Somma i voti e dividi il totale per il loro numero.
4. Scegli nomi chiari.voto1, voto2, voto3, media.
5. Prova a mano.Con 7, 8 e 9 ottieni (7 + 8 + 9) / 3 = 8.

Un algoritmo è una sequenza finita, ordinata e non ambigua di istruzioni che risolve una classe di problemi. Deve terminare, produrre il risultato corretto e funzionare con tutti i dati ammessi, non soltanto con l’esempio.

INIZIO
  LEGGI base, altezza
  area ← base × altezza
  SCRIVI area
FINE

Lo pseudocodice non è un linguaggio eseguibile: serve a concentrarsi sulla logica. Nomi chiari e indentazione rendono visibile la struttura.

I tre mattoni di qualunque algoritmo

Come si progetta: la strategia in 7 passaggi

1. Comprendi la consegna.Riscrivila con parole tue senza usare termini di programmazione.
2. Definisci il dominio.Quali valori sono ammessi? Sono possibili zero, numeri negativi o dati mancanti?
3. Individua input e output.Elenca separatamente ciò che conosci e ciò che devi ottenere.
4. Scomponi il problema.Dividi la soluzione in piccoli sottoproblemi: leggere, controllare, calcolare, mostrare.
5. Scegli le strutture.Usa sequenza, selezione o iterazione in base al comportamento richiesto.
6. Scrivi lo pseudocodice.Una sola azione per riga, verbi precisi, nomi significativi e blocchi indentati.
7. Verifica con una traccia.Simula l’algoritmo con un caso normale, un limite e un dato non valido.

Esempio completo: prezzo del biglietto

La consegna dice: “Leggi l’età di una persona. Il biglietto costa 10 euro; per chi ha meno di 14 anni costa 6 euro. Mostra il prezzo”.

INIZIO
  LEGGI eta
  SE eta < 0 ALLORA
    SCRIVI "Dato non valido"
  ALTRIMENTI
    SE eta < 14 ALLORA
      prezzo ← 6
    ALTRIMENTI
      prezzo ← 10
    FINE SE
    SCRIVI prezzo
  FINE SE
FINE

Dalla soluzione semplice a quella più complessa

INIZIO
  LEGGI N
  SE N <= 0 ALLORA
    SCRIVI "Quantità non valida"
  ALTRIMENTI
    somma ← 0
    PER i DA 1 A N ESEGUI
      LEGGI voto
      somma ← somma + voto
    FINE PER
    media ← somma / N
    SCRIVI media
  FINE SE
FINE

Controllo di comprensione

Un diagramma di flusso è la mappa di un procedimento: si legge partendo da INIZIO e seguendo le frecce, un blocco alla volta. La forma del blocco dice allo studente che cosa deve accadere: acquisire un dato, eseguire un calcolo oppure prendere una decisione.

Come si costruisce: metodo in 5 passaggi

1. Scrivi l’obiettivo.Stabilire se un numero è positivo.
2. Trova l’input.Serve un numero, che chiameremo n.
3. Formula la domanda.La condizione da verificare è n > 0?
4. Prepara i due risultati.Se SÌ scrivi “positivo”; se NO scrivi “non positivo”.
5. Collega e controlla.Ogni ramo deve arrivare a FINE e nessuna freccia deve restare sospesa.

Esempio svolto: verificare se un numero è positivo

#include <iostream>
using namespace std;

int main() {
  cout << "Ciao, mondo!" << endl;
  return 0;
}

Variabili e tipi principali

Costruiamo un programma completo

#include <iostream>
using namespace std;

int main() {
  double base, altezza, area;

  cout << "Inserisci base e altezza: ";
  cin >> base >> altezza;
  area = base * altezza;
  cout << "Area = " << area << endl;

  return 0;
}

1. Dichiara.Le tre variabili sono double perché possono contenere decimali.
2. Leggi.cin inserisce i due valori digitati nelle variabili.
3. Calcola.L’espressione a destra viene calcolata e assegnata ad area.
4. Mostra.cout unisce il testo al valore ottenuto.
5. Verifica.Con base 5 e altezza 3 il programma deve visualizzare 15.

La sequenza esegue le istruzioni nell’ordine. La selezione sceglie un ramo in base a una condizione.

double voto;
cin >> voto;

if (voto >= 6) {
  cout << "Promosso";
} else {
  cout << "Non promosso";
}

Le condizioni possono usare && (AND), || (OR) e ! (NOT). Quando i casi sono più di due si possono concatenare blocchi else if.

if (n > 0) {
  cout << "Positivo";
} else if (n < 0) {
  cout << "Negativo";
} else {
  cout << "Zero";
}

int n;
cin >> n;

for (int i = 1; i <= 10; i++) {
  cout << n << " x " << i
       << " = " << n * i << endl;
}

Ogni ciclo deve avere un’inizializzazione, una condizione e un aggiornamento. Se la condizione non diventa mai falsa, si crea un ciclo infinito.

Metodo guidato per progettare un ciclo

1. Che cosa si ripete?Individua le istruzioni da eseguire più volte.
2. Quando deve fermarsi?Scrivi la condizione di continuazione prima del codice.
3. Che cosa cambia?Aggiorna il contatore o il dato che rende falsa la condizione.
4. Che cosa ricordi?Usa un accumulatore per una somma o un contatore per una quantità.
5. Traccia tre giri.Annota i valori prima e dopo ogni iterazione.

Un vettore raccoglie più valori dello stesso tipo; una funzione assegna un nome a un sottoproblema e può essere riutilizzata.

double media(const double voti[], int n) {
  double somma = 0;
  for (int i = 0; i < n; i++) {
    somma += voti[i];
  }
  return somma / n;
}

Gli indici partono da zero: in un vettore di 5 elementi gli indici validi vanno da 0 a 4. Accedere oltre il limite produce un comportamento non definito.

• Leggi la prima riga dell’errore, non soltanto l’ultima.
• Controlla parentesi graffe, tonde e punti e virgola.
• Stampa temporaneamente le variabili per seguirne il valore.
• Prova dati normali, valori limite, zero e numeri negativi.
• Confronta la traccia reale con quella prevista.
• Correggi un problema alla volta e ricompila.

Nel paradigma imperativo il programma è una sequenza di comandi che modifica nel tempo lo stato della memoria. Una variabile rappresenta una porzione di quello stato: quando esegui somma = somma + voto, il vecchio valore viene letto, aggiornato e riscritto.

Leggere il cambiamento di stato

int somma = 0;
somma = somma + 4;
somma = somma + 7;
somma = somma + 2;
cout << somma;

Dallo “spaghetti code” alla programmazione strutturata

Un programma comprensibile combina soltanto sequenza, selezione e iterazione, organizzandole in blocchi. Ogni blocco dovrebbe svolgere un compito riconoscibile e avere un ingresso e un’uscita chiari.

1. Definisci lo stato iniziale.Inizializza ogni variabile prima di usarla.
2. Raggruppa le azioni.Metti nello stesso blocco le istruzioni che realizzano un unico compito.
3. Limita le dipendenze.Evita che troppe parti del programma modifichino la stessa variabile.
4. Controlla ogni percorso.Verifica sia il ramo vero sia quello falso e la terminazione dei cicli.

Quando main cresce, leggere e correggere il programma diventa difficile. Una funzione assegna un nome a un sottoproblema: riceve dati attraverso i parametri, svolge un compito e, se previsto, restituisce un risultato.

double areaRettangolo(double base, double altezza) {
  return base * altezza;
}

int main() {
  double area = areaRettangolo(5, 3);
  cout << area;  // 15
}

1. Individua il sottoproblema.“Calcolare l’area” è un compito autonomo.
2. Definisci gli ingressi.La funzione necessita di base e altezza.
3. Definisci l’uscita.Restituisce un numero reale di tipo double.
4. Evita compiti estranei.La funzione calcola; sarà main a leggere o stampare.
5. Provala isolatamente.Controlla 5×3, 0×4 e valori decimali ammessi.

Nome, cognome e media descrivono un unico studente, ma con variabili separate il loro legame esiste soltanto nella mente del programmatore. Una struct crea un nuovo tipo che raccoglie dati collegati.

struct Studente {
  string nome;
  string cognome;
  double media;
};

Studente s;
s.nome = "Sara";
s.cognome = "Rossi";
s.media = 7.8;

Perché questo prepara agli oggetti

La struttura avvicina dati che appartengono allo stesso concetto. Il passo successivo consiste nell’avvicinare anche le operazioni valide su quei dati e nel proteggerli da modifiche scorrette: è il ruolo della classe.

La programmazione a oggetti organizza il software intorno a entità che possiedono uno stato e offrono comportamenti. Una classe è il progetto; un oggetto è un’istanza concreta creata da quel progetto.

class Conto {
private:
  double saldo;

public:
  Conto(double saldoIniziale) {
    saldo = saldoIniziale >= 0 ? saldoIniziale : 0;
  }

  bool deposita(double importo) {
    if (importo <= 0) return false;
    saldo += importo;
    return true;
  }

  double leggiSaldo() const {
    return saldo;
  }
};

Come progettare una classe in 6 passaggi

1. Trova l’entità.Nel problema esiste un “conto” con identità e durata nel tempo.
2. Definisci lo stato.Il saldo descrive la situazione corrente.
3. Proteggi gli invarianti.Il saldo non deve essere modificato direttamente dall’esterno.
4. Definisci i comportamenti.Depositare e leggere il saldo sono operazioni offerte dalla classe.
5. Costruisci oggetti validi.Il costruttore impedisce un saldo iniziale negativo.
6. Prova le regole.Testa deposito positivo, zero e negativo.

Conto mioConto(100);
mioConto.deposita(25);
cout << mioConto.leggiSaldo();  // 125

Nei programmi reali gli oggetti collaborano. Prima di usare l’ereditarietà bisogna scegliere la relazione corretta: “ha un” suggerisce composizione; “è un” può suggerire ereditarietà.

class Forma {
public:
  virtual double area() const = 0;
  virtual ~Forma() = default;
};

class Rettangolo : public Forma {
  double base, altezza;
public:
  Rettangolo(double b, double h) : base(b), altezza(h) {}
  double area() const override { return base * altezza; }
};

Verifica di competenza