Mémoire et Pointeurs

Articles sur les pointeurs, références, gestion dynamique de la mémoire et adressage en C++.

Mémoire et Pointeurs

La puissance bas niveau de C++ : adressage, pointeurs et références ; pile vs. tas ; gestion de la mémoire dynamique. Découvrez les risques de new/delete, les schémas sûrs et les techniques pour éviter les fuites de mémoire.

Objectif : Utiliser correctement l’adressage et la mémoire dynamique pour écrire un code C++ sûr et sans bogues.

TL;DR

Pointeurs et références : int* p, int& r, nullptr.
Mémoire dynamique : new/delete, new[]/delete[].
Tableaux et arithmétique des pointeurs : *(p + i).
Bonnes pratiques/outils : RAII ; transition vers std::unique_ptr.

Notions d’adresses et de mémoire

25 juin 2026 • Mémoire et Pointeurs

Comprendre les adresses mémoire : octets, disposition et références par pointeurs.

C++ Memory

Lire →

Références vs pointeurs

25 juin 2026 • Mémoire et Pointeurs

Différences clés : nullabilité, réaffectation, indirection et sémantique mémoire.

C++ Pointeur

Lire →

Passer des paramètres par pointeurs

25 juin 2026 • Mémoire et Pointeurs

Transmettre des adresses aux fonctions : modification des valeurs et coûts associés.

C++ Fonctions Pointeur

Lire →

Lien entre tableaux et pointeurs

25 juin 2026 • Mémoire et Pointeurs

Disposition contiguë, conversion en pointeur et arithmétique des pointeurs en C++.

C++ Pointeur Tableaux

Lire →

Gestion de mémoire dynamique : new et delete

25 juin 2026 • Mémoire et Pointeurs

Allocations sur le tas, usage sûr de new/delete et préambule vers RAII.

C++ Gestion de la Mémoire en C++ Opérateur new

Lire →

Fuites mémoire et analyse avec valgrind

25 juin 2026 • Mémoire et Pointeurs

Détecter les fuites, lire les rapports valgrind et éviter les pièges d’allocation.

C++ Fuites de mémoire

Lire →

Tableaux multidimensionnels et pointeurs

25 juin 2026 • Mémoire et Pointeurs

Deux/trois dimensions, disposition mémoire et calcul d’index via pointeurs.

C++ Pointeur Tableaux

Lire →

Introduction aux smart pointers

25 juin 2026 • Mémoire et Pointeurs

Prise en main de unique_ptr, shared_ptr et weak_ptr pour gérer les durées de vie.

C++ Smart Pointers

Lire →

En C++, utiliser vector.empty() pour vérifier si un conteneur est vide est plus lisible que size() == 0.


std::vector<int> numbers;

// moins lisible
if (numbers.size() == 0)
{
    // vide
}

// plus clair et recommandé
if (numbers.empty())
{
    // vide
}

En C++, il vaut mieux éviter les return true et return false inutiles. Retourner directement la condition rend le code plus clair.


// inutile
bool isPositive(int value)
{
    if (value > 0)
        return true;
    else
        return false;
}

// plus clair
bool isPositive(int value)
{
    return value > 0;
}

En C++, auto améliore la lisibilité lorsque le type est évident ou très long. Cela permet de se concentrer sur la logique du code.


std::map<int, std::string> users;

// long et peu lisible
std::map<int, std::string>::iterator it = users.begin();

// plus lisible
auto it = users.begin();

En C++, il est recommandé d’initialiser les variables dès leur déclaration afin d’éviter des valeurs imprévisibles.


int count = 0;      // initialisé, sûr

int total;              // non initialisé, risqué
total = 10;

En C++, utiliser un return anticipé dans une fonction permet de réduire les conditions imbriquées et de clarifier le code.


// conditions imbriquées
void process(int value)
{
    if (value > 0)
    {
        if (value < 100)
        {
            doWork(value);
        }
    }
}

// return anticipé
void process(int value)
{
    if (value <= 0)
    {
        return;
    }

    if (value >= 100)
    {
        return;
    }

    doWork(value);
}