Fonction clear de C++ <vector>

Classe conteneur C++ <vector>


clearest utilisée dans vector pourEffacer tous les élémentsLa fonction est la manière la plus simple et la plus efficace de vider un conteneur.

clearest une fonction membre de la classe conteneur, utilisée poursupprimer tous les éléments du conteneur, rendant le conteneur vide. Après l'appel, du conteneursize()deviendra 0.

clearest la méthode standard pour réinitialiser un conteneur, souvent utilisée dans les scénarios où vous devez recommencer ou libérer de la mémoire.

Définitions de mots: clearsignifie « clear », c'est-à-dire supprimer tous les éléments.


Syntaxe de base et paramètres

clearest une fonction membre des classes conteneurs ; son appel ne nécessite aucun paramètre.

Format de syntaxe

void clear();

Description des paramètres

  • Paramètre: Aucun paramètre
    • clearn'accepte aucun paramètre.

Description de la fonction

  • Valeur de retour: void(aucune valeur de retour).
  • Effet: supprime tous les éléments du conteneur,size()devient 0.capacity()reste généralement inchangé (selon l'implémentation spécifique).
  • Remarque: clearne libère pas la mémoire sous-jacente, et la capacité reste inchangée. Pour libérer la mémoire en même temps, vous pouvez utiliserswap.

Exemple

Maîtrisons cela en profondeur à travers une série d'exemples.clearUtilisation.

Exemple 1 : utilisation de base - vider un conteneur

Exemple

#include <iostream>
#include <vector>

int main() {
    std::vector<int> numbers = {1, 2, 3, 4, 5};

    std::cout << "Avant le vidage - taille : " << numbers.size()
              << ", capacité : " << numbers.capacity() << std::endl;

    // Effacer tous les éléments
    numbers.clear();

    std::cout << "Après le vidage - taille : " << numbers.size()
              << ", capacité : " << numbers.capacity() << std::endl;

    return 0;
}

Sortie attendue :

清空前 - size: 5, capacity: 5
清空后 - size: 0, capacity: 5

Analyse du code :

  1. clear()vasize()devient 0.
  2. capacity()reste inchangé, et la mémoire n'est pas libérée.

Exemple 2 : réajout d'éléments après effacement

Le conteneur vidé peut continuer à être utilisé.

Exemple

#include <iostream>
#include <vector>
#include <string>

int main() {
    std::vector<std::string> tasks;

    // Ajouter une tâche
    tasks.push_back("Apprendre le C++");
    tasks.push_back(Terminer les devoirs);
    tasks.push_back("Lire la documentation");

    std::cout << Liste des tâches ( << tasks.size() << " tâches) :" << std::endl;
    for(const auto& t : tasks) {
        std::cout << "- " << t << std::endl;
    }

    // Effacer la liste des tâches
    tasks.clear();

    std::cout << "\nAprès effacement ( << tasks.size() << éléments) << std::endl;

    // On peut continuer à ajouter de nouvelles tâches
    tasks.push_back(Nouvelle tâche A);
    tasks.push_back(Nouvelle tâche B);

    std::cout << "\nAprès avoir rajouté ( << tasks.size() << " éléments):" << std::endl;
    for(const auto& t : tasks) {
        std::cout << "- " << t << std::endl;
    }

    return 0;
}

Sortie attendue :

任务列表 (3 项):
- 学习 C++
- 完成作业
- 阅读文档

清空后 (0 项)

重新添加后 (2 项):
- 新任务 A
- 新任务 B

Analyse du code :

  • clear()Après effacement, le conteneur peut continuer à être utilisé.
  • Comme la capacité reste inchangée, ajouter à nouveau des éléments ne nécessite pas de réallouer la mémoire.

Exemple 3 : Utilisation de empty() pour vérifier l'état vidé

clear()Ensuite, vous pouvez utiliserempty()Vérifie si le conteneur est vide.

Exemple

#include <iostream>
#include <vector>

void processData(std::vector<int>& data) {
    std::cout << Traitement des données, actuellement il y a << data.size() << éléments... << std::endl;

    // Traiter les données...

    // Nettoyer les données
    data.clear();
    std::cout << Données effacées << std::endl;
}

int main() {
    std::vector<int> cache = {1, 2, 3, 4, 5};

    // Simuler l'utilisation du cache
    for(int i = 0; i < 3; ++i) {
        cache.push_back(cache.size() + 1);
        std::cout << Après ajout d'éléments - taille: << cache.size()
                  << ", vide: " << (cache.empty() ? "true" : "false") << std::endl;
    }

    // Vider le cache
    cache.clear();
    std::cout << Après nettoyage - vide: << (cache.empty() ? "true" : "false") << std::endl;

    return 0;
}

Sortie attendue :

添加元素后 - size: 6, empty: false
添加元素后 - size: 7, empty: false
添加元素后 - size: 8, empty: false
清空后 - empty: true

Analyse du code :

  • empty()returntrueQuandsize() == 0Quand.
  • clear()Après,empty()returntrue。

Exemple 4 : libérer complètement la mémoire

Pour libérer la mémoire tout en vidant les éléments, vous pouvez utiliserswap.

Exemple

#include <iostream>
#include <vector>

int main() {
    std::vector<int> numbers;

    // Ajouter un grand nombre d'éléments
    for(int i = 0; i < 1000; ++i) {
        numbers.push_back(i);
    }

    std::cout << "Avant le vidage - taille : " << numbers.size()
              << ", capacité : " << numbers.capacity() << std::endl;

    // Méthode 1 : seulement clear (sans libérer la mémoire)
    numbers.clear();
    std::cout << "Après clear() - taille : " << numbers.size()
              << ", capacité : " << numbers.capacity() << std::endl;

    // Méthode 2 : utiliser l'astuce du swap (pour libérer la mémoire)
    std::vector<int>().swap(numbers);
    std::cout << "Après swap - taille : " << numbers.size()
              << ", capacité : " << numbers.capacity() << std::endl;

    return 0;
}

Sortie attendue :

清空前 - size: 1000, capacity: 1000
clear() 后 - size: 0, capacity: 1000
swap 后 - size: 0, capacity: 0

Analyse du code :

  • clear()Efface uniquement les éléments, tandis que la capacité reste inchangée.
  • std::vector().swap(numbers)Créez un vecteur vide temporaire et échangez-le avec numbers pour libérer complètement la mémoire.

Exemple 5 : utiliser clear dans une boucle

Peut être utilisé dans une boucleclearpour réinitialiser les données.

Exemple

#include <iostream>
#include <vector>

int main() {
    std::vector<int> buffer;
    buffer.reserve(100);

    // Simuler plusieurs tours de traitement
    for(int round = 1; round <= 3; ++round) {
        // Remplir les données
        for(int i = 0; i < 10; ++i) {
            buffer.push_back(round * 100 + i);
        }

        std::cout << "Tour " << round << " - Traitement des données : ";
        for(int n : buffer) {
            std::cout << n << " ";
        }
        std::cout << std::endl;

        // Après le traitement, vider pour préparer le prochain tour
        buffer.clear();
    }

    std::cout << "Tous les tours sont terminés, taille finale du tampon : " << buffer.size() << std::endl;

    return 0;
}

Analyse du code :

  • clear()Peut être utilisé dans une boucle pour réinitialiser le tampon.
  • CoordinationreserveSon utilisation peut éviter de fréquentes allocations mémoire.

Classe conteneur C++ <vector>

autres extensions