Les boucles for basées sur la plage sont une fonctionnalité puissante en C++ qui simplifie l'itération sur les conteneurs et les collections. Ce tutoriel explore les techniques fondamentales et les meilleures pratiques pour utiliser les boucles for basées sur la plage, aidant les développeurs à écrire un code plus concis et lisible dans la programmation C++ moderne.
for basées sur la plagefor basées sur la plageLes boucles for basées sur la plage, introduites en C++11, offrent une manière plus concise et lisible d'itérer sur les conteneurs et les tableaux. Elles simplifient la syntaxe des boucles traditionnelles et rendent le code plus intuitif.
La syntaxe de base d'une boucle for basée sur la plage est simple :
for (element_type element : container) {
// Corps de la boucle
}#include <iostream>
#include <vector>
int main() {
std::vector<int> numbers = {1, 2, 3, 4, 5};
// Itération sur le vecteur
for (int num : numbers) {
std::cout << num << " ";
}
return 0;
}Les boucles for basées sur la plage prennent en charge plusieurs modes d'itération :
| Mode | Description | Exemple |
|---|---|---|
| Par valeur | Crée une copie de chaque élément | for (int num : numbers) |
| Par référence | Permet la modification des éléments originaux | for (int& num : numbers) |
| Par référence constante | Empêche la modification | for (const int& num : numbers) |
#include <iostream>
#include <array>
#include <map>
int main() {
// Itération sur un tableau
std::array<std::string, 3> fruits = {"pomme", "banane", "cerise"};
for (const std::string& fruit : fruits) {
std::cout << fruit << " ";
}
// Itération sur une map
std::map<std::string, int> ages = {
{"Alice", 30},
{"Bob", 25}
};
for (const auto& [name, age] : ages) {
std::cout << name << " a " << age << " ans\n";
}
return 0;
}Les boucles for basées sur la plage offrent une approche moderne et propre de l'itération en C++, réduisant le code répétitif et améliorant la lisibilité. LabEx recommande de maîtriser cette fonctionnalité pour un code plus efficace et expressif.
for basées sur la plage#include <iostream>
#include <vector>
int main() {
std::vector<int> numbers = {1, 2, 3, 4, 5, 6, 7, 8, 9, 10};
// Filtrer les nombres pairs
for (int num : numbers) {
if (num % 2 == 0) {
std::cout << num << " ";
}
}
return 0;
}#include <iostream>
#include <vector>
int main() {
std::vector<int> numbers = {1, 2, 3, 4, 5};
// Calculer le carré de chaque nombre
for (int& num : numbers) {
num = num * num;
}
// Afficher les nombres transformés
for (int num : numbers) {
std::cout << num << " ";
}
return 0;
}#include <iostream>
#include <vector>
int main() {
std::vector<std::vector<int>> matrix = {
{1, 2, 3},
{4, 5, 6},
{7, 8, 9}
};
// Itérer sur un vecteur 2D
for (const auto& row : matrix) {
for (int num : row) {
std::cout << num << " ";
}
std::cout << std::endl;
}
return 0;
}#include <iostream>
#include <vector>
int main() {
std::vector<std::string> fruits = {"pomme", "banane", "cerise"};
// Itérer avec l'index
for (size_t i = 0; i < fruits.size(); ++i) {
std::cout << "Index " << i << " : " << fruits[i] << std::endl;
}
return 0;
}| Cas d'utilisation | Description | Exemple |
|---|---|---|
| Traitement de données | Transformer ou filtrer des collections | Calculer le carré des nombres |
| Configuration | Itérer sur les paramètres de configuration | Lecture des paramètres de configuration |
| Initialisation | Remplir des structures de données | Remplissage de tableaux ou de vecteurs |
Les boucles for basées sur la plage fournissent des mécanismes d'itération puissants et flexibles. LabEx recommande de maîtriser ces modèles pour écrire un code C++ plus expressif et efficace.
#include <iostream>
#include <vector>
#include <chrono>
class LargeObject {
public:
std::vector<int> data;
// Constructeur et méthodes volumineux
};
void iterateByValue(std::vector<LargeObject>& objects) {
for (LargeObject obj : objects) { // Coûteux : crée une copie complète
// Traiter l'objet
}
}
void iterateByReference(std::vector<LargeObject>& objects) {
for (const LargeObject& obj : objects) { // Efficacité : aucune copie
// Traiter l'objet
}
}| Type d'itération | Utilisation mémoire | Performance | Recommandé |
|---|---|---|---|
| Par valeur | Élevée | Faible | Non recommandé |
| Par référence | Modérée | Bonne | Recommandé |
| Par référence constante | Faible | Meilleure | Préféré |
#include <iostream>
#include <vector>
#include <utility>
int main() {
std::vector<std::string> words = {"hello", "world"};
// Itération efficace avec déplacement
for (auto&& word : words) {
std::cout << std::move(word) << " ";
}
return 0;
}for basées sur la plage aux boucles basées sur les index.#include <array>
#include <iostream>
int main() {
constexpr std::array<int, 5> numbers = {1, 2, 3, 4, 5};
// Optimisation possible au moment de la compilation
for (const int num : numbers) {
std::cout << num << " ";
}
return 0;
}#include <iostream>
#include <vector>
#include <chrono>
void measureIterationPerformance() {
std::vector<int> large_vector(1000000);
auto start = std::chrono::high_resolution_clock::now();
for (int num : large_vector) {
// Simuler le traitement
volatile int x = num;
}
auto end = std::chrono::high_resolution_clock::now();
auto duration = std::chrono::duration_cast<std::chrono::microseconds>(end - start);
std::cout << "Temps d'itération : " << duration.count() << " microsecondes" << std::endl;
}Des boucles for basées sur la plage efficaces nécessitent une compréhension des implications de la performance. LabEx recommande une considération attentive des stratégies d'itération pour optimiser les performances du code C++.
En maîtrisant les boucles for basées sur la plage en C++, les développeurs peuvent améliorer considérablement la lisibilité et l'efficacité de leur code. Ces boucles offrent une approche claire et intuitive de l'itération sur les conteneurs, réduisant le code redondant et minimisant les erreurs potentielles associées aux structures de boucles traditionnelles.
