C++ – Syntaxe, OOP, STL & Compilation

Qu'est-ce que C++ ?

C++ (créé par Bjarne Stroustrup) est un langage de programmation **compilé**, **typé statiquement**, **multi-paradigme** (impératif, orienté objet, fonctionnel) et à usage général.

Il est souvent décrit comme "C avec des classes". Sa philosophie principale est la **performance brute** et le **contrôle total de la mémoire** ("zero-cost abstraction").

C'est un langage complexe mais extrêmement puissant, utilisé lorsque la performance est la priorité absolue.

Domaines d'application

• Systèmes d'Exploitation (OS) : (Windows, macOS, Linux ont des parties en C++).
• Moteurs de Jeux Vidéo : (Unreal Engine, Unity).
• Navigateurs Web : (Google Chrome, Firefox).
• Calcul Haute Performance (HPC) : (Physique, Finance).
• Systèmes Embarqués & Robotique : (Contrôle temps réel).
• Backends (Modules) : (Modules Node.js, Python pour le calcul lourd).

IDE (Environnements)

• VS Code : (Recommandé) Léger, excellent support (IntelliSense C/C++, CMake Tools).
• Visual Studio (Windows) : Le "poids lourd", IDE complet (MSVC, Debugger).
• CLion (JetBrains) : (Payant) Excellent, centré sur CMake.

Build Systems (make, cmake)

g++ main.cpp math.cpp ... devient ingérable. Un "Build System" automatise la compilation.

Types (Tailles courantes)

Modificateurs (unsigned, long)

long int x;
long long y; // (Garanti 64 bits)
unsigned int z; // (Pas de négatifs)

Déclarations

#include <string> // (Nécessaire pour std::string)

int age = 30;
double prix = 19.99;
char initial = 'G';

// Chaîne (Style C) - (À éviter)
const char* nom_c = "Alice";

// Chaîne (Style C++ - Recommandé)
std::string nom_cpp = "Bob";
nom_cpp += " Martin"; // (Facile à manipuler)

// C++11 (Inférence de type)
auto x = 5;     // (Infère 'int')
auto y = 3.14;  // (Infère 'double')
auto z = "txt"; // (Infère 'const char*')

// Constantes
const double PI = 3.14159;

if / else if / else

int age = 20;

if (age >= 18) {
    std::cout << "Majeur";
} else if (age < 12) {
    std::cout << "Enfant";
} else {
    std::cout << "Adolescent";
}

// Opérateur Ternaire
std::string status = (age >= 18) ? "Majeur" : "Mineur";

switch (cas)

int note = 10;

switch (note) {
    case 20:
        std::cout << "Parfait";
        break; // (Ne pas oublier 'break' !)
    case 10:
        std::cout << "Moyen";
        break;
    default:
        std::cout << "Autre";
        break;
}

La "Stack" (Pile)

Analogie : Une pile d'assiettes.

• Gestion : Automatique (par le compilateur).
• Vitesse : Extrêmement rapide (allocation/libération).
• Durée : Locale (liée au "scope" {}).
• Usage : Variables locales (int a = 10;).

Le "Heap" (Tas)

Analogie : Un grand entrepôt.

• Gestion : **Manuelle** (par le développeur).
• Vitesse : Lent (recherche d'espace libre).
• Durée : Globale (existe jusqu'à delete).
• Usage : Allocation dynamique (new).

C++ (new / delete)

(Appelle le constructeur/destructeur).

// 1. Allouer 1 objet
int* pInt = new int;
*pInt = 10;

// 2. Libérer 1 objet
delete pInt;

C++ (new[] / delete[])

(Le Piège)

// 1. Allouer 1 array
int* pArray = new int[50];

// 2. Libérer 1 array (CRUCIAL: [])
delete[] pArray;

// (Si 'delete pArray' -> Comportement indéfini)

RAII & Smart Pointers

Gérer new/delete est difficile. La solution C++ moderne est de ne **jamais** utiliser new/delete nus.

Utilisez les Smart Pointers (Pointeurs Intelligents) (voir 6.3) qui gèrent le delete automatiquement (RAII).

// (Moderne: C++14)
#include <memory>

void maFonction() {
    // 1. Alloue sur le Heap
    std::unique_ptr pInt = std::make_unique(10);
    
} // 2. 'pInt' sort du scope,
  //    le 'delete' est appelé automatiquement.

Surcharge (Overloading)

Plusieurs fonctions avec le *même nom* mais des *arguments différents*.

int addition(int a, int b);
double addition(double a, double b);
std::string addition(std::string a, std::string b);

addition(1, 2); // Appelle (int)
addition(1.5, 2.5); // Appelle (double)

Headers (.h) vs Source (.cpp)

(Voir 1.4). C'est la structure standard des projets C++.

• .h (Header) : Déclarations (signatures) des fonctions/classes. "Ce qui est public".
• .cpp (Source) : Définitions (implémentation) des fonctions/classes. "Comment c'est fait".

Array (Style C) (À éviter)

Taille fixe, pas de vérification des limites, "decay" (déchéance) en pointeur.

int monArray[5] = {10, 20, 30, 40, 50};
monArray[0] = 10;

// (DANGER: Dépassement de buffer, non vérifié !)
// monArray[50] = 999;

std::vector (STL) (Recommandé)

La version C++ moderne. Gère la mémoire, dynamique, sécurisé.

#include <vector>

// Crée un vecteur dynamique
std::vector monVecteur;

monVecteur.push_back(10); // (Ajoute à la fin)
monVecteur.push_back(20);

// Accès (sécurisé)
monVecteur.at(0); // (Vérifie les limites)

// Taille
monVecteur.size();

// Itération
for (int val : monVecteur) { ... }

Constructeur

Appelé lors de la création (new ou stack).

class MaClasse {
public:
    // 1. Constructeur par défaut
    MaClasse() { ... }
    
    // 2. Constructeur (Surchargé)
    MaClasse(int x) { ... }
    
    // 3. Constructeur de Copie
    MaClasse(const MaClasse& autre) { ... }
};

MaClasse obj1;      // (Appelle 1)
MaClasse obj2(10); // (Appelle 2)
MaClasse obj3 = obj1; // (Appelle 3)

Destructeur (~) & RAII

Appelé lors de la destruction (fin de scope (Stack), ou delete (Heap)).

RAII (Resource Acquisition Is Initialization) : C'est le concept C++ le plus important. Lier la *durée de vie* d'une ressource (mémoire, fichier, socket) à la *durée de vie* d'un objet (scope).

class FileHandle {
private:
    FILE* pFile;
public:
    // 1. Acquisition (Constructeur)
    FileHandle(const char* name) {
        pFile = fopen(name, "w");
    }
    
    // 2. Libération (Destructeur)
    ~FileHandle() {
        if (pFile) fclose(pFile);
    }
};

void test() {
    FileHandle f("log.txt"); // 1. Ouvre le fichier
    // ... (écritures)
} // 2. 'f' sort du scope, le destructeur
  //    est appelé, 'fclose' est garanti.

Syntaxe (: public)

Permet à une classe "enfant" (dérivée) d'hériter des membres (public, protected) d'une classe "parent" (base).

Exemple

// Classe de Base
class Animal {
protected:
    std::string nom;
public:
    Animal(std::string n) : nom(n) {} // Initializer list
    
    void manger() { std::cout << "Mange..."; }
};

// Classe Dérivée
class Chien : public Animal {
public:
    // (Appelle le constructeur parent)
    Chien(std::string n) : Animal(n) {}
    
    void aboyer() {
        // (Accès OK car 'nom' est 'protected')
        std::cout << this->nom << " aboie !";
    }
};

Chien c("Medor");
c.manger(); // (Hérité)
c.aboyer(); // (Propre)

Fonctions Virtuelles

Le polymorphisme permet à un objet (via un pointeur de base) d'appeler la *bonne* méthode (celle de l'enfant).

virtual (Parent) : Dit "cette fonction *peut* être surchargée (overridden)".

override (Enfant) : Dit "je *surcharge* cette fonction virtuelle" (sécurité).

Classe Abstraite (= 0)

Une fonction "pure virtuelle" (= 0) *doit* être implémentée par l'enfant. (Rend la classe "Abstraite").

Exemple

class Forme { // Classe Abstraite
public:
    // Pure virtual
    virtual double getAire() const = 0;
};

class Carre : public Forme {
private:
    double cote;
public:
    Carre(double c) : cote(c) {}
    // Implémentation (override implicite)
    double getAire() const override {
        return cote * cote;
    }
};

class Cercle : public Forme {
private:
    double rayon;
public:
    Cercle(double r) : rayon(r) {}
    double getAire() const override {
        return 3.14 * rayon * rayon;
    }
};

// --- Utilisation ---
// (Pointeur de Base)
Forme* f = new Cercle(10);
std::cout << f->getAire(); // Appelle getAire() de Cercle
delete f;

La Bibliothèque Standard C++

La STL est la raison pour laquelle le C++ moderne est utilisable. C'est une bibliothèque (basée sur des "templates" / generics) qui fournit des structures de données et des algorithmes pré-codés et optimisés.

Les 3 Piliers de la STL

• Containers (Conteneurs) : Les structures de données (vector, map, string...).
• Algorithms (Algorithmes) : Les fonctions (sort, find, for_each...).
• Iterators (Itérateurs) : Le "lien" entre les deux (ex: vec.begin(), vec.end()).

1. Backend (Modules Natifs)

Utiliser C++ pour un serveur web complet est rare (ex: Wt, CppCMS).

Usage principal : Écrire des **modules natifs** (add-ons) pour des backends (Node.js, Python) pour le calcul lourd (ex: IA, traitement d'image).

// (Node.js N-API)
// (Python CTypes/Pybind11)

2. Frontend (WebAssembly)

WebAssembly (Wasm) est le cas d'usage moderne.
Permet de compiler C++ (ou Rust) en un binaire .wasm qui s'exécute dans le navigateur (presque à vitesse native).

Usage : Figma (éditeur), AutoCAD Web, jeux vidéo 3D (Unreal Engine) dans le navigateur.

Bases

#include <iostream>
#include <string>
#include <vector>
using namespace std;

int main() {
    // ...
    return 0;
}
// Commentaire
/* Multi-lignes */

I/O (Console)

cout << "Texte " << variable << endl;
cin >> variable;

Compilation (g++)

g++ -std=c++17 -Wall main.cpp -o app
./app

Pointeurs & Références

int x = 10;
int* p = &x; // Pointeur
int& r = x;  // Référence

*p = 20; // x vaut 20
r = 30;  // x vaut 30

Mémoire (Moderne)

#include <memory>
unique_ptr p1 = make_unique(10);
shared_ptr p2 = make_shared();

STL

std::vector v;
v.push_back(10);
v.at(0);
v.size();

std::map m;
m["cle"] = 100;