C++ est un langage puissant mais complexe, et même les développeurs expérimentés peuvent tomber dans certains pièges. Voici 10 erreurs courantes en C++ et des conseils pour les éviter.
1. Oublier de libérer la mémoire dynamique
❌ Erreur
L’oubli d’un delete ou delete[] après un new entraîne une fuite mémoire.
cppCopierModifierint* ptr = new int(10);
// Oubli de delete -> fuite mémoire
✅ Solution
Utilise std::unique_ptr ou std::shared_ptr au lieu de new et delete.
cppCopierModifier#include <memory>
std::unique_ptr<int> ptr = std::make_unique<int>(10);
2. Accéder à une mémoire libérée (Dangling Pointer)
❌ Erreur
cppCopierModifierint* ptr = new int(5);
delete ptr;
std::cout << *ptr; // Comportement indéfini
✅ Solution
Toujours remettre le pointeur à nullptr après delete.
cppCopierModifierdelete ptr;
ptr = nullptr;
3. Déréférencer un pointeur nul
❌ Erreur
cppCopierModifierint* ptr = nullptr;
std::cout << *ptr; // Segmentation fault
✅ Solution
Toujours vérifier si le pointeur est valide avant de l’utiliser.
cppCopierModifierif (ptr) {
std::cout << *ptr;
}
4. Erreur d’indexation d’un tableau
❌ Erreur
cppCopierModifierint arr[5] = {1, 2, 3, 4, 5};
std::cout << arr[5]; // Dépassement de tableau
✅ Solution
Toujours s’assurer que l’index est dans les limites du tableau.
cppCopierModifierif (index >= 0 && index < 5) {
std::cout << arr[index];
}
Utilise std::vector qui gère la vérification des limites avec .at().
5. Mauvaise gestion des références et copies d’objets
❌ Erreur
cppCopierModifierstd::string s1 = "Hello";
std::string& s2 = s1; // OK
std::string& s3 = "World"; // ERREUR : référence sur une constante temporaire
✅ Solution
Utilise const std::string& pour éviter des copies inutiles et accepter les temporaires.
cppCopierModifiervoid print(const std::string& str) {
std::cout << str;
}
6. Utilisation incorrecte des opérateurs == et =
❌ Erreur
cppCopierModifierint a = 5;
if (a = 10) { // ERREUR : affectation au lieu de comparaison
std::cout << "Toujours vrai!";
}
✅ Solution
Utilise == pour comparer et = pour affecter.
cppCopierModifierif (a == 10) {
std::cout << "Correct!";
}
7. Mauvaise gestion des exceptions
❌ Erreur
cppCopierModifierthrow "Erreur"; // Mauvaise pratique : utiliser une chaîne brute
✅ Solution
Toujours utiliser std::exception ou des classes dérivées.
cppCopierModifier#include <stdexcept>
throw std::runtime_error("Erreur détectée");
8. Dépendance circulaire dans les fichiers d’en-tête
❌ Erreur
cppCopierModifier// fichierA.h
#include "fichierB.h"
// fichierB.h
#include "fichierA.h" // Boucle infinie
✅ Solution
Utilise les gardes d’inclusion (#ifndef) ou #pragma once.
cppCopierModifier#ifndef FICHIER_H
#define FICHIER_H
// Code
#endif
9. Mauvaise utilisation de std::endl
❌ Erreur
cppCopierModifierstd::cout << "Hello" << std::endl; // Vide le buffer inutilement
✅ Solution
Utilise "\n" sauf si un flush est nécessaire.
cppCopierModifierstd::cout << "Hello\n";
10. Mauvaise utilisation des boucles for avec auto
❌ Erreur
cppCopierModifierstd::vector<int> vec = {1, 2, 3};
for (auto x : vec) {
x *= 2; // Ne modifie PAS les éléments du tableau
}
✅ Solution
Utilise auto& pour modifier les éléments.
cppCopierModifierfor (auto& x : vec) {
x *= 2;
}
Conclusion
Éviter ces erreurs permet d’améliorer la fiabilité et la performance de ton code en C++. 🚀 Prends l’habitude d’utiliser les pointeurs intelligents, les containers STL et la gestion stricte des exceptions pour éviter les pièges classiques.
