Fonction capacity de <vector> en C++

Classe conteneur C++ <vector>

capacityest utilisée dans vector pourInterroger la capacitéla fonction qui renvoie la taille de l'espace de stockage actuellement alloué par le conteneur.

capacityest une fonction membre des classes de conteneurs, utilisée pourRenvoie le nombre d'éléments que l'espace de stockage actuellement alloué du conteneur peut contenir. Cette valeur est généralement supérieure ou égale àsize()。

capacityReflète l'espace mémoire préalloué à l'intérieur du vector ; le comprendre aide à optimiser les performances du programme et à éviter des réallocations de mémoire inutiles.

Définitions de mots： capacitySignifie "capacity", c'est-à-dire le nombre d'éléments que le conteneur peut contenir.

Syntaxe de base et paramètres

capacityEst une fonction membre de la classe conteneur, et son appel ne nécessite aucun paramètre.

Format de syntaxe

size_type capacity() const;

Description des paramètres

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

Description de la fonction

  • Retour: renvoiesize_typeType (généralementsize_t), indiquant le nombre d'éléments que l'espace de stockage actuellement alloué du conteneur peut contenir.
  • Effet: Renvoie un entier non négatif représentant l'espace mémoire alloué par le conteneur.
  • Remarque： capacity()Renvoie la capacité, pas le nombre d'éléments. Pour le nombre d'éléments, utilisezsize()Obtenir.

Exemple

Maîtrisons à fond à travers une série d'exemplescapacityUtilisation.

Exemple 1 : Utilisation de base - affichage de la capacité

Exemple

#include <iostream>
#include <vector>

int main() {
    // Vecteur vide
    std::vector<int> emptyVec;
    std::cout << "Vecteur vide - taille : " << emptyVec.size()
              << ", capacité : " << emptyVec.capacity() << std::endl;

    // Vecteur avec des éléments
    std::vector<int> numbers = {1, 2, 3, 4, 5};
    std::cout << "vecteur de 5 éléments - taille : " << numbers.size()
              << ", capacité : " << numbers.capacity() << std::endl;

    return 0;
}

Résultat attendu :

空 vector - size: 0, capacity: 0
5 元素 vector - size: 5, capacity: 5

Analyse du code :

  1. du vecteur videcapacity()est 0.
  2. Un vecteur de 5 élémentscapacity()Est au moins 5 (peut être plus grande, selon l'implémentation).

Exemple 2 : La relation entre la taille et la capacité

ComprendresizeetcapacityLa différence est la base pour optimiser l'utilisation des vecteurs.

Exemple

#include <iostream>
#include <vector>

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

    // Ajouter progressivement des éléments et observer les changements de capacité
    std::cout << "Modifications de la taille et de la capacité lors de l'ajout d'éléments :" << std::endl;

    for(int i = 0; i < 15; ++i) {
        v.push_back(i);
        std::cout << "Après avoir ajouté " << (i + 1) << " éléments - taille : "
                  << v.size() << ", capacité : " << v.capacity() << std::endl;
    }

    return 0;
}

Résultat attendu (sortie typique) :

添加元素过程中 size 和 capacity 的变化:
添加 1 个元素后 - size: 1, capacity: 1
添加 2 个元素后 - size: 2, capacity: 2
添加 3 个元素后 - size: 3, capacity: 4
添加 4 个元素后 - size: 4, capacity: 4
添加 5 个元素后 - size: 5, capacity: 8
添加 6 个元素后 - size: 6, capacity: 8
添加 7 个元素后 - size: 7, capacity: 8
添加 8 个元素后 - size: 8, capacity: 8
添加 9 个元素后 - size: 9, capacity: 16
添加 10 个元素后 - size: 10, capacity: 16
添加 11 个元素后 - size: 11, capacity: 16
添加 12 个元素后 - size: 12, capacity: 16
添加 13 个元素后 - size: 13, capacity: 16
添加 14 个元素后 - size: 14, capacity: 16
添加 15 个元素后 - size: 15, capacity: 16

Analyse du code :

  • La capacité d'un vecteur croît exponentiellement (généralement d'un facteur 2).
  • Lorsque la capacité est insuffisante, le vecteur alloue un espace mémoire plus grand (généralement le double de la capacité actuelle).
  • Cette stratégie vise à réduire le nombre de réallocations mémoire et à améliorer les performances.

Exemple 3 : Utilisation de reserve pour préallouer la capacité

UtilisationreserveVous pouvez préallouer une capacité suffisante pour éviter les réallocations mémoire fréquentes.

Exemple

#include <iostream>
#include <vector>

int main() {
    // Préallouer la capacité pour 1000 éléments
    std::vector<int> v;
    v.reserve(1000);

    std::cout << "Après reserve(1000) - taille : " << v.size()
              << ", capacité : " << v.capacity() << std::endl;

    // Ajouter 100 éléments
    for(int i = 0; i < 100; ++i) {
        v.push_back(i);
    }

    std::cout << "Après ajout de 100 éléments - taille : " << v.size()
              << ", capacité : " << v.capacity() << std::endl;

    return 0;
}

Résultat attendu :

reserve(1000) 后 - size: 0, capacity: 1000
添加 100 个元素后 - size: 100, capacity: 1000

Analyse du code :

  • reserve(1000)Espace mémoire préalloué pouvant contenir 1000 éléments.
  • Après avoir ajouté 100 éléments,capacityElle est toujours de 1000, et aucune réallocation de mémoire n'a eu lieu.
  • Cela peut améliorer considérablement les performances, surtout lorsqu'il faut ajouter un grand nombre d'éléments.

Exemple 4 : shrink_to_fit libère la capacité excédentaire

Introduit en C++11shrink_to_fitméthode, qui peut ajuster la capacité pour qu'elle soit identique à size.

Exemple

#include <iostream>
#include <vector>

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

    // Ajouter 5 éléments
    for(int i = 0; i < 5; ++i) {
        v.push_back(i);
    }

    std::cout << "État initial - taille : " << v.size()
              << ", capacité : " << v.capacity() << std::endl;

    // Réserver plus d'espace
    v.reserve(100);
    std::cout << "Après reserve(100) - taille : " << v.size()
              << ", capacité : " << v.capacity() << std::endl;

    // Réduire à la taille appropriée
    v.shrink_to_fit();
    std::cout << "Après shrink_to_fit() - taille : " << v.size()
              << ", capacité : " << v.capacity() << std::endl;

    return 0;
}

Résultat attendu :

初始状态 - size: 5, capacity: 5
reserve(100) 后 - size: 5, capacity: 100
shrink_to_fit() 后 - size: 5, capacity: 5

Analyse du code :

  • shrink_to_fit()Demande au conteneur de réduire la capacité à la même valeur que size.
  • Cela peut libérer de la mémoire qui n'est plus nécessaire.
  • Remarque : Ce n'est pas obligatoire ; la capacité réelle dépend de l'implémentation.

Exemple 5 : Application pratique de la capacité

ApprendrecapacityCela peut aider à optimiser l'utilisation de la mémoire.

Exemple

#include <iostream>
#include <vector>

void printStatus(const std::string& operation,
                 const std::vector<int>& v) {
    std::cout << operation << " - taille : " << v.size()
              << ", capacité : " << v.capacity() << std::endl;
}

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

    printStatus("État initial", data);

    // Si nous savons que nous devons stocker 1000 éléments, nous pouvons pré-allouer
    const size_t estimatedSize = 1000;
    data.reserve(estimatedSize);

    printStatus("Après reserve(1000)", data);

    // Simuler le chargement des données
    for(size_t i = 0; i < 1000; ++i) {
        data.push_back(static_cast<int>(i));
    }

    printStatus("Après l'ajout de 1000 éléments", data);

    // Vérifier si une augmentation de capacité est nécessaire
    if(data.capacity() < estimatedSize) {
        std::cout << "Attention : capacité insuffisante !" << std::endl;
    } else {
        std::cout << "Capacité suffisante, nombre d'allocations mémoire minimisé" << std::endl;
    }

    return 0;
}

Résultat attendu :

初始状态 - size: 0, capacity: 0
reserve(1000) 后 - size: 0, capacity: 1000
添加 1000 个元素后 - size: 1000, capacity: 1000
容量充足，内存分配次数最少化

Analyse du code :

  • Pré-estimez la capacité requise et utilisezreservepeut éviter de multiples allocations mémoire.
  • Cela est particulièrement utile pour les scénarios impliquant de grandes quantités de données.

Classe conteneur C++ <vector>

autres extensions