C++ moderno e alternative C

Programmazione orientata agli oggetti (OOP)

Impara incapsulamento, ereditarietà e polimorfismo in C++, confrontandoli con C.

  • Avanzato
  • 8 min di lettura
  • 2 esempi eseguibili

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.

Dal regolamento della banca al codice
class Account📗 Le regole del conto standard
class SavingsAccount : public Account📝 Un conto standard più una regola in più
void month_end() override💰 La regola in più: aggiungere gli interessi
account->month_end();🧑‍💼 Esegui la chiusura del mese senza controllare il tipo
Incapsulamento, ereditarietà e polimorfismo in un esempio.
In una frase

La 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

C combina struct e puntatori a funzione; convenzioni e API mantengono invarianti e proprietà.

C++

C++ usa stato privato, ereditarietà e override controllati dal compilatore.

Suggerimento: Usa un distruttore virtuale nelle basi polimorfe, evita raw pointer proprietari e preferisci la composizione.

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++

C
Esegui →
main.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;
}
Crea un pulsante Run per questo esempio Risultato dell'esecuzione
Ada: 150.00
Lin: 210.00
C++
Esegui →
main.cpp
#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';
    }
}
Crea un pulsante Run per questo esempio Risultato dell'esecuzione
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

C usa convenzioni sui nomi, callback, macro e struct con il contesto.

C++

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.

Problema
class Account {
public:
    double balance;
};
Correzione
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.

Problema
void month_End() { ... }
Correzione
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