Programmazione orientata agli oggetti (OOP)
Impara incapsulamento, ereditarietà e polimorfismo in C++, confrontandoli con C.
Cos’è la programmazione orientata agli oggetti in C++?
Il problema
Una banca ha conti standard e conti di risparmio. Entrambi hanno un titolare e un saldo, ma solo i conti di risparmio maturano interessi a fine mese. Copiare tutto il codice per ogni tipo di conto lo duplica, e le catene di if sul tipo si allungano a ogni nuovo tipo.
Immaginalo così
La OOP è come il regolamento di una banca. Le regole del conto standard (Account) coprono quello che hanno tutti i conti: un intestatario e un saldo. Un conto di risparmio (SavingsAccount) segue le stesse regole più una regola in più a fine mese: aggiungere gli interessi. L'impiegato esegue la chiusura del mese su tutti i conti della pila senza controllare di che tipo sono.
class Account📗 Le regole del conto standardclass SavingsAccount : public Account📝 Un conto standard più una regola in piùvoid month_end() override💰 La regola in più: aggiungere gli interessiaccount->month_end();🧑💼 Esegui la chiusura del mese senza controllare il tipoLa programmazione orientata agli oggetti (OOP) organizza il codice attorno a oggetti che uniscono i dati e le funzioni che ci lavorano sopra. Si basa su incapsulamento, ereditarietà e polimorfismo.
La OOP organizza programmi attorno a oggetti con stato, invarianti e comportamento. C++ fornisce classi, controllo d’accesso, ereditarietà e dispatch virtuale; C li esprime esplicitamente.
I quattro principi fondamentali
- L’incapsulamento protegge gli invarianti controllando lo stato.
- L’astrazione presenta una piccola interfaccia pubblica.
- L’ereditarietà specializza un contratto base valido.
- Il polimorfismo seleziona il comportamento concreto tramite chiamate virtuali.
Espressione in C e C++
C combina struct e puntatori a funzione; convenzioni e API mantengono invarianti e proprietà.
C++ usa stato privato, ereditarietà e override controllati dal compilatore.
Quando usarlo
- Modellare cose con dati comuni e comportamenti diversi: conti, forme, personaggi di gioco.
- Programmi grandi in cui nascondere i dati interni evita usi sbagliati.
- Framework che chiamano i metodi che hai ridefinito.
Quando non serve
- Semplici elaborazioni di dati, dove funzioni e struct bastano e sono più chiare.
- Alberi di ereditarietà profondi: preferisci la composizione quando i tipi condividono solo alcune parti.
Esempi di codice C e C++
#include <stdio.h>
typedef struct Account Account;
typedef void (*MonthEnd)(Account *account);
struct Account {
const char *owner;
double balance;
double interest_rate;
MonthEnd month_end;
};
void standard_month_end(Account *account) {
(void)account;
}
void savings_month_end(Account *account) {
account->balance *= 1.0 + account->interest_rate;
}
void print_account(Account *account) {
account->month_end(account);
printf("%s: %.2f\n", account->owner, account->balance);
}
int main(void) {
Account accounts[] = {
{"Ada", 150.0, 0.0, standard_month_end},
{"Lin", 200.0, 0.05, savings_month_end}
};
for (int i = 0; i < 2; ++i) {
print_account(&accounts[i]);
}
return 0;
}
Ada: 150.00
Lin: 210.00
#include <iomanip>
#include <iostream>
#include <string>
#include <utility>
#include <vector>
class Account {
std::string owner_;
double balance_;
protected:
void add_balance(double amount) { balance_ += amount; }
public:
Account(std::string owner, double balance)
: owner_(std::move(owner)), balance_(balance) {}
virtual ~Account() = default;
virtual void month_end() {}
const std::string& owner() const { return owner_; }
double balance() const { return balance_; }
};
class SavingsAccount final : public Account {
double interest_rate_;
public:
SavingsAccount(std::string owner, double balance, double rate)
: Account(std::move(owner), balance), interest_rate_(rate) {}
void month_end() override {
add_balance(balance() * interest_rate_);
}
};
int main() {
Account standard("Ada", 150.0);
SavingsAccount savings("Lin", 200.0, 0.05);
std::vector<Account *> accounts{&standard, &savings};
std::cout << std::fixed << std::setprecision(2);
for (Account *account : accounts) {
account->month_end();
std::cout << account->owner() << ": "
<< account->balance() << '\n';
}
}
Ada: 150.00
Lin: 210.00
Confronto tra C e C++
C memorizza stato e comportamento in una struct. C++ mantiene privato il saldo, eredita un’interfaccia e usa override. Il client non deve verificare il tipo concreto.
C usa convenzioni sui nomi, callback, macro e struct con il contesto.
C++ offre astrazioni con un ambito chiaro, sicure rispetto ai tipi e che di solito non costano nulla in più in esecuzione.
Esercizi di approfondimento
Esegui entrambe le versioni e poi modifica il codice per osservare la differenza di sicurezza che offre ciascun linguaggio.
- Scrivi prima il meccanismo in C e solo dopo usa la funzionalità equivalente del C++.
- Sostituisci la liberazione manuale delle risorse con RAII.
- Controlla se la funzionalità causa allocazioni di memoria o chiamate a funzioni virtuali.
Errori comuni
Membri dati pubblici
Qualsiasi codice può impostare il saldo a un valore non valido.
class Account {
public:
double balance;
};
class Account {
double balance_;
public:
double balance() const { return balance_; }
};
override mancante
Un errore di battitura nel nome del metodo crea in silenzio una nuova funzione invece di ridefinirla.
void month_End() { ... }
void month_end() override { ... }
Hai finito questa lezione?
Segnala come imparata per tenere traccia dei tuoi progressi.
Esercitati con una sfida
Usa ciò che questa lezione spiega per risolvere un problema reale. Ogni sfida gira nel browser, con test immediati e una revisione dell'IA.
Tutte le sfide