CodeUtility
Faciliter la vie des développeurs !
C++ moderne et alternatives en C

Programmation orientée objet (POO)

Apprenez encapsulation, héritage et polymorphisme en C++, avec une conception C explicite.

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

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

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 de l’exécution
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 de l’exécution
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

C utilise des conventions de nommage, des callbacks, des macros et des struct de contexte.

C++

C++ offre des abstractions à la portée bien délimitée, sûres pour les types et généralement sans coût supplémentaire à l'exécution.

Exercices d'approfondissement

Exécutez les deux versions, puis modifiez le code pour observer la différence de sécurité qu'apporte chaque langage.

  • Écrivez d'abord le mécanisme en C, puis utilisez la fonctionnalité équivalente du C++.
  • Remplacez la libération manuelle des ressources par RAII.
  • Vérifiez si la fonctionnalité provoque des allocations mémoire ou des appels de fonctions virtuelles.

S'entraîner avec un défi

Utilisez le contenu de cette leçon pour résoudre un vrai problème. Chaque défi s'exécute dans le navigateur, avec des tests instantanés et une revue par l'IA.

Tous les défis