C++ moderno e alternative C

Programmazione orientata agli oggetti (OOP)

C++ offre classi e funzioni virtuali; C modella relazioni simili con struct e puntatori a funzione.

Cos’è la programmazione orientata agli oggetti in C++?

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

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.

Esempi di codice C e 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;
}

Output previsto

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';
    }
}

Output previsto

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 prefissi, callback, macro e context espliciti.

C++

Il linguaggio offre astrazioni con scope, type-safe e spesso zero-overhead.

Esercizi pratici

Esegui entrambe le versioni e modificale per osservare le diverse garanzie.

Scrivi prima il meccanismo C.
Sostituisci cleanup manuale con RAII.
Misura allocation e virtual dispatch.