C++ moderne et alternatives en C

Programmation orientée objet (POO)

C++ fournit directement classes et fonctions virtuelles ; C reproduit ces relations avec des structures et pointeurs de fonction.

Qu’est-ce que la programmation orientée objet en C++ ?

La POO structure un programme autour d’objets avec état, invariants et comportements. C++ fournit classes, contrôle d’accès, héritage et dispatch virtuel ; C les exprime explicitement.

Les quatre principes fondamentaux

L’encapsulation protège les invariants en contrôlant l’état interne.
L’abstraction présente une petite interface publique.
L’héritage spécialise un contrat de base valide.
Le polymorphisme sélectionne le comportement concret lors d’un appel virtuel.

Expression en C et en C++

C combine données et pointeurs de fonction ; conventions et API assurent invariants et propriété.

C++

C++ combine état privé, héritage et override, vérifiés par le compilateur.

Conseil : Ajoutez un destructeur virtuel aux bases polymorphes, évitez les pointeurs bruts propriétaires et préférez la composition.

Exemples de code C et C++

Exécuter →

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

Résultat attendu

Ada: 150.00
Lin: 210.00

C++

Exécuter →

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

Résultat attendu

Ada: 150.00
Lin: 210.00

Comparaison entre C et C++

En C, une structure contient l’état et le pointeur de fonction. En C++, le solde est privé, une interface commune est héritée et une méthode virtuelle est redéfinie. Le code client n’a pas à tester le type concret.

C utilise préfixes, callbacks, macros et contextes explicites.

C++

Le langage fournit des abstractions typées, structurées et souvent sans surcoût.

Exercices pratiques

Exécutez les deux versions puis modifiez-les pour observer leurs garanties.

Écrivez d’abord le mécanisme C.
Remplacez le nettoyage manuel par RAII.
Mesurez allocations et dispatch virtuel.