Aide-mémoire C++
Dernière mise à jour
Hello World et structure d'un programme
L'exécution démarre à main, qui renvoie un int.
| Élément | Code |
|---|---|
| Inclure un en-tête | #include <iostream> |
| Point d'entrée | int main() { ... } |
| Afficher une ligne | std::cout << "Hello, World!" << std::endl; |
| Lire une saisie | std::cin >> x; |
| Utiliser l'espace de noms std | using namespace std; |
| Renvoyer un succès | return 0; |
| Commentaires | // line et /* block */ |
Types de données
| Type | Description |
|---|---|
int | Entier (généralement 32 bits) |
long / long long | Entiers plus larges |
float / double | Nombres à virgule flottante |
char | Octet / caractère unique |
bool | true ou false |
std::string | Texte dynamique de <string> |
auto | Le compilateur infère le type |
std::size_t | Type non signé pour les tailles et les indices |
Variables et références
Les références sont des alias ; les pointeurs contiennent des adresses.
| Opération | Syntaxe |
|---|---|
| Déclarer et initialiser | int x = 5; |
| Initialisation par accolades | int x{5}; |
| Constante | const double PI = 3.14159; |
| Constante de compilation | constexpr int N = 10; |
| Référence (alias) | int &r = x; |
| Pointeur | int *p = &x; |
| Déréférencer un pointeur | *p = 10; |
| Inférence de type | auto y = 3.14; |
Contrôle de flux
| Instruction | Syntaxe |
|---|---|
| If / else | if (x > 0) { ... } else { ... } |
| Switch | switch (n) { case 1: ...; break; default: ...; } |
| Boucle while | while (i < n) { ... } |
| Boucle do-while | do { ... } while (i < n); |
| Boucle for | for (int i = 0; i < n; i++) { ... } |
| For basé sur une plage | for (auto x : vec) { ... } |
| For basé sur une plage par référence | for (auto &x : vec) { ... } |
| Break / continue | break; sort d'une boucle, continue; passe à l'itération suivante |
Fonctions
| Opération | Syntaxe |
|---|---|
| Définir une fonction | int add(int a, int b) { return a + b; } |
| Sans valeur de retour | void greet() { ... } |
| Arguments par défaut | int pow(int b, int e = 2) { ... } |
| Passage par référence | void inc(int &x) { x++; } |
| Référence const (sans copie) | void print(const std::string &s) { ... } |
| Surcharge | int max(int a, int b); et double max(double a, double b); |
| Lambda | auto f = [](int x) { return x * 2; }; |
| Lambda avec capture | auto g = [n](int x) { return x + n; }; |
Classes et POO
| Opération | Syntaxe |
|---|---|
| Définir une classe | class Dog { ... }; |
| Spécificateurs d'accès | public:, private:, protected: |
| Variable membre | std::string name; |
| Constructeur | Dog(std::string n) : name(n) {} |
| Destructeur | ~Dog() { ... } |
| Fonction membre | void bark() { ... } |
| Créer un objet | Dog d("Rex"); |
| Héritage | class Puppy : public Dog { ... }; |
| Fonction virtuelle | virtual void speak(); |
Conteneurs STL
Conteneurs courants de la bibliothèque standard.
| Conteneur | Usage et exemple |
|---|---|
std::vector<int> | Tableau dynamique : v.push_back(1); v.size(); |
std::string | Texte : s += "!"; s.length(); |
std::array<int, 3> | Tableau de taille fixe avec info de bornes |
std::map<K, V> | Clé-valeur triée : m["a"] = 1; |
std::unordered_map<K, V> | Table de hachage (recherche plus rapide, sans ordre) |
std::set<T> | Valeurs uniques triées : s.insert(5); |
std::pair<A, B> | Deux valeurs : make_pair(1, "x") |
std::queue / std::stack | Adaptateurs file FIFO / pile LIFO |
Algorithmes et itérateurs STL
De <algorithm> ; la plupart prennent une plage d'itérateurs begin/end.
| Opération | Syntaxe |
|---|---|
| Itérateurs begin / end | v.begin(), v.end() |
| Trier | std::sort(v.begin(), v.end()); |
| Trier en décroissant | std::sort(v.begin(), v.end(), std::greater<int>()); |
| Trouver une valeur | auto it = std::find(v.begin(), v.end(), 5); |
| Compter les correspondances | std::count(v.begin(), v.end(), 5); |
| Élément min / max | std::max_element(v.begin(), v.end()); |
| Sommer une plage | std::accumulate(v.begin(), v.end(), 0); |
| Transformer chaque élément | std::transform(v.begin(), v.end(), v.begin(), fn); |
Pointeurs intelligents et C++ moderne
Préférez les pointeurs intelligents aux new/delete bruts pour un nettoyage automatique.
| Fonctionnalité | Syntaxe |
|---|---|
| Propriété unique | auto p = std::make_unique<Dog>("Rex"); |
| Propriété partagée | auto p = std::make_shared<Dog>("Rex"); |
| Référence non propriétaire | std::weak_ptr<Dog> w = p; |
| Sémantique de déplacement | auto v2 = std::move(v1); |
| Nullptr | int *p = nullptr; |
| Liaisons structurées | auto [key, val] = *it; |
| Valeur optionnelle | std::optional<int> maybe; |
| Templates | template <typename T> T add(T a, T b) { return a + b; } |
La syntaxe C++, les conteneurs STL et les fonctionnalités modernes que vous utilisez le plus, sur une seule page. Cet aide-mémoire C++ est une référence rapide pour écrire du C++ - les types de données, les références, les classes, les conteneurs et algorithmes de la bibliothèque standard, ainsi que les pointeurs intelligents qui remplacent les new/delete bruts.
Tout ce qui figure ici est du C++ standard (C++11 et ultérieur) et se compile avec g++ ou clang++. Copiez ce dont vous avez besoin, ou essayez n'importe quel extrait en direct dans le playground C++ - aucun compilateur à installer.
FAQ de l'aide-mémoire C++
Cet aide-mémoire C++ est-il gratuit ?
Oui. Cet aide-mémoire C++ est entièrement gratuit, sans inscription. Mettez-le en favori et revenez dès que vous devez retrouver une syntaxe, un conteneur STL ou un pointeur intelligent.
Quelle est la différence entre un pointeur et une référence en C++ ?
Un pointeur est une variable qui contient une adresse ; il peut être nul, réaffecté pour pointer ailleurs, et vous le déréférencez avec
*p. Une référence (int &r = x) est un alias d'une variable existante - elle doit être liée à la déclaration, ne peut jamais être nulle ni reliée, et s'utilise comme la variable elle-même. Utilisez les références pour des paramètres passés par référence plus propres, et les pointeurs lorsque vous avez besoin d'une indirection optionnelle ou réaffectable.Dois-je utiliser new/delete ou des pointeurs intelligents ?
Préférez les pointeurs intelligents.
std::unique_ptr et std::shared_ptr (via make_unique/make_shared) libèrent leur mémoire automatiquement lorsqu'ils sortent de portée, ce qui évite les fuites et les doubles libérations liées aux new/delete manuels. Ne recourez aux new/delete bruts que dans du code bas niveau ayant une raison spécifique.Puis-je m'entraîner à C++ en ligne ?
Oui. Ouvrez le playground C++ pour compiler et exécuter n'importe quel extrait de cet aide-mémoire dans votre navigateur - aucun compilateur à installer. Quand vous voulez de la structure, le cours C++ interactif gratuit de Coddy vous emmène des variables et des boucles jusqu'aux classes et à la STL, étape par étape.
Cet aide-mémoire convient-il aux débutants ?
Oui. Il est organisé des briques de base les plus courantes (types, contrôle de flux, fonctions) jusqu'aux plus avancées (la STL et les pointeurs intelligents), pour que vous puissiez utiliser les premières sections dès le premier jour et progresser vers le reste.
Ressources connexes
Plus d'aide-mémoires
