HOWTO · C++

Supprimer l'élément du tableau en C++

Cet article montre comment supprimer un élément d'un tableau en C++

Sur cette page

La méthode de suppression dépend du conteneur. Un tableau de style C conserve sa capacité déclarée : le code peut donc décaler les valeurs et suivre séparément une longueur logique réduite, ou copier les valeurs conservées dans un autre conteneur. Un std::vector peut, lui, changer directement de taille. Les exemples ci-dessous suppriment une seule valeur correspondante ou toutes les occurrences, selon le cas.

Pourquoi la suppression d’un élément modifie la taille logique d’un tableau

Un tableau tel que int values[5] réserve toujours de la mémoire pour cinq entiers. Écraser un élément avec les valeurs qui le suivent peut raccourcir la séquence active, mais ne modifie pas la capacité du tableau. Conservez la longueur active dans une variable distincte et utilisez-la pour lire ou afficher la séquence. À l’inverse, un std::vector<int> gère à la fois son stockage et son nombre actuel d’éléments.

Décaler les éléments d’un tableau de style C

Pour supprimer sur place la première occurrence, recherchez-la, décalez chaque valeur suivante d’une position vers la gauche, puis décrémentez la longueur logique. La capacité du tableau reste égale à cinq ; seule la séquence formée par ses length premières valeurs est raccourcie. Exécutez cet exemple :

Le code et les libellés ou sorties affichés dans cette section restent en anglais.

#include <iostream>

void remove_first(int values[], int& length, int target) {
    int index = 0;
    while (index < length && values[index] != target) {
        ++index;
    }
    if (index == length) {
        return;
    }
    for (int i = index; i + 1 < length; ++i) {
        values[i] = values[i + 1];
    }
    --length;
}

int main() {
    int values[5] = {1, 2, 3, 4, 5};
    int length = 5;
    remove_first(values, length, 3);
    for (int i = 0; i < length; ++i) {
        if (i != 0) std::cout << ' ';
        std::cout << values[i];
    }
    std::cout << '\n';
}
1 2 4 5

Cette fonction supprime uniquement la première occurrence. Pour toutes les supprimer, compactez le tableau à l’aide d’un indice de lecture et d’un indice d’écriture : copiez chaque valeur différente de la valeur recherchée à la prochaine position d’écriture, puis définissez la longueur logique sur le nombre de valeurs écrites. Cette méthode parcourt chaque élément une seule fois. Décaler les éléments après chaque suppression est plus simple, mais peut déplacer plusieurs fois les mêmes valeurs.

Copier les éléments restants dans un nouveau tableau

Une destination distincte laisse la source intacte. Un std::vector constitue une destination pratique dont la taille s’adapte aux données et qui gère son propre stockage, sans devoir utiliser manuellement new[] et delete[]. Cet exemple copie toutes les valeurs autres que 3 ; si aucune valeur ne correspond, la destination contient simplement une copie de la source.

Le code et les libellés ou sorties affichés dans cette section restent en anglais.

#include <cstddef>
#include <iostream>
#include <vector>

int main() {
    const int source[] = {1, 2, 3, 3, 4, 5};
    const int length = sizeof(source) / sizeof(source[0]);
    std::vector<int> remaining;
    for (int i = 0; i < length; ++i) {
        if (source[i] != 3) {
            remaining.push_back(source[i]);
        }
    }
    for (std::size_t i = 0; i < remaining.size(); ++i) {
        if (i != 0) std::cout << ' ';
        std::cout << remaining[i];
    }
    std::cout << '\n';
}
1 2 4 5

La destination atteint exactement la taille nécessaire pour les valeurs conservées. Si une interface exige un tableau brut alloué dynamiquement, comptez d’abord ces valeurs, allouez le nombre d’éléments correspondant (qui peut être zéro), puis libérez l’allocation avec delete[] lorsque son propriétaire n’en a plus besoin. Préférez un conteneur standard si l’interface n’impose pas la gestion manuelle de la mémoire.

Supprimer les valeurs correspondantes d’un std::vector avec l’idiome erase-remove

Pour un conteneur redimensionnable, utilisez std::remove avec la méthode erase du vecteur. Incluez <algorithm> pour l’algorithme et <vector> pour le conteneur. std::remove déplace les valeurs non correspondantes vers le début et renvoie un itérateur à la nouvelle fin logique ; il ne modifie pas la taille du vecteur. erase supprime ensuite la plage restante et met à jour cette taille. Cette méthode supprime toutes les occurrences de la valeur recherchée.

Le code et les libellés ou sorties affichés dans cette section restent en anglais.

#include <algorithm>
#include <cstddef>
#include <iostream>
#include <vector>

int main() {
    std::vector<int> values = {1, 2, 3, 3, 4, 5};
    values.erase(std::remove(values.begin(), values.end(), 3), values.end());
    for (std::size_t i = 0; i < values.size(); ++i) {
        if (i != 0) std::cout << ' ';
        std::cout << values[i];
    }
    std::cout << '\n';
}
1 2 4 5

Utiliser std::remove avec un tableau de taille fixe

std::remove fonctionne également sur la plage d’itérateurs d’un tableau de style C. Il réorganise les valeurs et renvoie la nouvelle fin logique, mais ne peut pas réduire le stockage du tableau. Lorsque vous traitez le résultat, utilisez cet itérateur comme fin de la plage conservée ; ne considérez pas toute la plage initiale du tableau comme la séquence raccourcie.

Le code et les libellés ou sorties affichés dans cette section restent en anglais.

#include <algorithm>
#include <iostream>
#include <iterator>

int main() {
    int values[] = {1, 2, 2, 3, 4};
    int* logical_end = std::remove(std::begin(values), std::end(values), 2);
    for (int* current = std::begin(values); current != logical_end; ++current) {
        if (current != std::begin(values)) std::cout << ' ';
        std::cout << *current;
    }
    std::cout << '\n';
}
1 3 4

Les éléments compris entre logical_end et la fin réelle du tableau restent des objets valides, mais l’algorithme ne spécifie pas leurs valeurs. Ne les affichez pas et ne vous fiez pas à elles. Si vous avez besoin d’une séquence physiquement plus courte, copiez le préfixe qui se termine à logical_end dans une destination de taille appropriée.

Choisir une méthode et traiter les cas limites

Utilisez le décalage lorsqu’un tableau fixe doit être modifié sur place et que sa longueur logique peut être suivie séparément. Choisissez une nouvelle destination si le tableau d’origine doit rester intact ou si le résultat doit avoir son propre stockage. Optez pour std::vector lorsque la collection doit pouvoir grandir ou rétrécir naturellement ; l’idiome erase-remove est généralement la méthode la plus claire pour supprimer toutes les valeurs correspondantes.

Précisez si l’opération supprime la première occurrence ou toutes les occurrences. Si aucune valeur ne correspond, la séquence reste inchangée. Après la suppression dans un tableau d’un seul élément, la longueur logique peut être égale à zéro, tandis que sa capacité déclarée reste égale à un. Pour un vecteur vide, std::remove renvoie begin() ; effacer la plage vide qui en résulte le laisse vide. Il n’est pas nécessaire d’employer des techniques d’allocation particulières pour ces cas si les longueurs et les plages d’itérateurs sont gérées de manière cohérente.