C++ <vector> fonction reserve
reserveest utilisé dans vector pourPréallouer la mémoireune fonction importante qui peut considérablement améliorer les performances d'ajout d'éléments.
reserveest une fonction membre de la classe conteneur, utilisée pourRéserver un espace de stockage pour au moins n élémentsCela ne change pas la taille du conteneur, mais il préalloue suffisamment de mémoire pour éviter des réallocations fréquentes lorsque des éléments sont ajoutés par la suite.
reserveest une fonction clé pour optimiser les performances de vector, particulièrement adaptée aux scénarios où un grand nombre d'éléments doivent être ajoutés.
Définitions de mots: reservesignifie "reserve", c'est-à-dire pré-réserver suffisamment d'espace.
Syntaxe de base et paramètres
reserveest une fonction membre de la classe conteneur, et vous devez spécifier le nombre d'éléments à réserver.
Format de syntaxe
void reserve(size_type n);
Description des paramètres
- Paramètre:
n- Type :
size_type(type entier non signé, généralementsize_t) - Description : Le nombre minimum d'éléments que vous souhaitez réserver. Le conteneur allouera au moins suffisamment de mémoire pour contenir n éléments.
- Type :
Description de la fonction
- Valeur de retour:
void(Aucune valeur de retour). - EffetLe conteneur réallouera de la mémoire afin que sa capacité soit au moins n. La taille du conteneur
size()ne changera pas, et restera le nombre original d'éléments. - NoteSi n est inférieur à la capacité actuelle,
reservecela ne fera rien. Si n est supérieur à la capacité actuelle, la mémoire sera réallouée.
Exemple
Maîtrisons parfaitement [cela] à travers une série d'exemples.reserveUtilisation.
Exemple 1 : Utilisation de base - préallocation d'espace
Exemple
#include <vector>
int main() {
// Créer un vecteur vide
std::vector<int> numbers;
std::cout << "État initial - taille : " << numbers.size()
<< ", capacité : " << numbers.capacity() << std::endl;
// Réserver de l'espace pour 100 éléments
numbers.reserve(100);
std::cout << "Après reserve(100) - taille : " << numbers.size()
<< ", capacité : " << numbers.capacity() << std::endl;
// Ajouter des éléments
for(int i = 0; i < 10; ++i) {
numbers.push_back(i);
}
std::cout << "Après l'ajout de 10 éléments - taille : " << numbers.size()
<< ", capacité : " << numbers.capacity() << std::endl;
return 0;
}
Sortie attendue :
初始状态 - size: 0, capacity: 0 reserve(100) 后 - size: 0, capacity: 100 添加 10 个元素后 - size: 10, capacity: 100
Analyse du code :
reserve(100)Un espace mémoire capable de contenir 100 éléments a été préalloué.size()est toujours 0, car aucun élément n'a encore été ajouté.- Après l'ajout de 10 éléments, la capacité est toujours de 100, et aucune réallocation de mémoire n'a eu lieu.
Exemple 2 : Utilisation de reserve pour optimiser l'ajout de grandes quantités de données
Pour les scénarios où un grand nombre d'éléments doivent être ajoutés, utiliser [reserve] à l'avancereservepeut considérablement améliorer les performances.
Exemple
#include <vector>
#include <chrono>
int main() {
const int N = 100000;
// Sans utiliser reserve
std::vector<int> v1;
auto start1 = std::chrono::high_resolution_clock::now();
for(int i = 0; i < N; ++i) {
v1.push_back(i);
}
auto end1 = std::chrono::high_resolution_clock::now();
auto duration1 = std::chrono::duration_cast<std::chrono::microseconds>(end1 - start1);
// Utilisation de reserve
std::vector<int> v2;
v2.reserve(N);
auto start2 = std::chrono::high_resolution_clock::now();
for(int i = 0; i < N; ++i) {
v2.push_back(i);
}
auto end2 = std::chrono::high_resolution_clock::now();
auto duration2 = std::chrono::duration_cast<std::chrono::microseconds>(end2 - start2);
std::cout << "Temps écoulé sans reserve : " << duration1.count() << " microsecondes" << std::endl;
std::cout << "Temps pris avec reserve : " << duration2.count() << " microsecondes" << std::endl;
std::cout << "Amélioration des performances : " << (double)duration1.count() / duration2.count() << "x" << std::endl;
return 0;
}
Analyse du code :
- Lors de l'ajout de 100,000 éléments, en utilisant [reserve] à l'avance
reservepeut réduire considérablement le nombre de réallocations de mémoire. - Cela peut apporter des améliorations de performance notables lors du traitement de grandes quantités de données.
Exemple 3 : La bonne façon d'utiliser reserve
Pour utiliser pleinementreservevous devez estimer la capacité requise à l'avance.
Exemple
#include <vector>
int main() {
// Supposons que nous voulions stocker des données pour 1000 utilisateurs
struct User {
std::string name;
int age;
};
std::vector<User> users;
users.reserve(1000); // préallouer de l'espace
// Simuler le chargement des données utilisateur
for(int i = 0; i < 1000; ++i) {
User u;
u.name = "User" + std::to_string(i);
u.age = 20 + (i % 50);
users.push_back(u);
}
std::cout << "Nombre d'utilisateurs : " << users.size() << std::endl;
std::cout << "Capacité : " << users.capacity() << std::endl;
return 0;
}
Analyse du code :
- Pour le chargement de données de taille connue, l'utilisation de [reserve] à l'avance
reserveest la meilleure pratique. - Cela évite de multiples réallocations de mémoire et améliore l'efficacité.
Exemple 4 : Éviter les appels inutiles à reserve
reserveIl doit être utilisé en fonction des besoins réels ; une allocation excessive gaspille de la mémoire.
Exemple
<vector>
int main() {
// Mauvaise approche : préallocation excessive
std::vector<int> v1;
v1.reserve(1000000); // Seuls 10 éléments sont nécessaires, mais nous avons préalloué de l'espace pour 1 million !
for(int i = 0; i < 10; ++i) {
v1.push_back(i);
}
std::cout << "Seulement 10 éléments nécessaires - taille : " << v1.size()
<< ", capacité : " << v1.capacity() << std::endl;
// Approche correcte : préallouer selon les besoins
std::vector<int> v2;
v2.reserve(10);
for(int i = 0; i < 10; ++i) {
v2.push_back(i);
}
std::cout << Il faut 10 éléments - taille : << v2.size()
<< ", capacité : " << v2.capacity() << std::endl;
return 0;
}
Analyse du code :
- Une préallocation excessive gaspille de l'espace mémoire.
- doit être défini en fonction du nombre réel d'éléments nécessaires.
reservedu paramètre.
Exemple 5 : reserve et vérification de la capacité
Vous pouvez vérifier si la capacité est suffisante avant d'ajouter des éléments.
Exemple
#include <vector>
void addElements(std::vector<int>& v, int count) {
// Si la capacité actuelle est insuffisante, réservez suffisamment d'espace
if(v.capacity() < v.size() + count) {
v.reserve(v.size() + count);
}
// Ajouter des éléments
for(int i = 0; i < count; ++i) {
v.push_back(v.size());
}
}
int main() {
std::vector<int> data;
std::cout << "taille initiale : " << data.size()
<< ", capacité : " << data.capacity() << std::endl;
addElements(data, 50);
std::cout << Après ajout de 50 - taille : << data.size()
<< ", capacité : " << data.capacity() << std::endl;
addElements(data, 50);
std::cout << Après avoir ajouté 50 de plus - taille : << data.size()
<< ", capacité : " << data.capacity() << std::endl;
return 0;
}
Analyse du code :
- Vous pouvez vérifier et réserver dynamiquement la capacité dans une fonction.
- Cela garantit qu'aucune réallocation de mémoire ne se produit lors de l'ajout d'éléments.
autres extensions