Les mots-clés C++ sont réservés par le langagemots spéciauxqui ne peuvent pas être utilisés comme noms de variables, noms de fonctions, etc. Ils contrôlent le comportement, les types et le flux des programmes.

1. Types de données de base (les plus couramment utilisés)

Kata kunci Signification (pour débutants) Exemple / Description Notes
bool Type booléen, uniquement true / false bool ok = true; Cœur du jugement conditionnel
char Caractère unique (généralement 1 byte) char c = 'A'; Utiliser des guillemets simples
wchar_t Caractère étendu (souvent utilisé pour prendre en charge le chinois, etc.) wchar_t wc = L'中'; 2 ou 4 bytes, dépendant de la plateforme
char8_t Caractère UTF-8 (nouveau dans C++20) char8_t c8 = u8'好'; Programmation Unicode moderne
char16_t Caractère UTF-16 (C++11)
char32_t Caractère UTF-32 (C++11)
int Entier (généralement 4 bytes) int age = 18; Type entier le plus couramment utilisé
short Entier court (généralement 2 bytes) short s = 1000; À utiliser pour économiser de l'espace
long Entier long (au moins 4 bytes, généralement 8 bytes) long l = 1234567890L; Ajouter le suffixe L
long long Entier plus long (au moins 8 octets, formalisé en C++11) long long big = 1LL<<60; Gérer les grands nombres
float Nombre à virgule flottante en simple précision float f = 3.14f; Ajouter le suffixe f
double Nombre à virgule flottante en double précision (type à virgule flottante par défaut) double pi = 3.1415926535; Précision supérieure
void Aucun type (fonctions ne renvoyant aucune valeur, pointeurs génériques, etc.) void func(); Couramment utilisé dans les déclarations de fonctions
unsigned Non signé (combiné avec int/long, etc.) unsigned int id = 4000000000u; Plage plus large, mais ne peut pas représenter de nombres négatifs

2. Durée de vie et stockage des variables/objets (stockage et durée)

Kata kunci Signification (pour débutants) Exemple / Utilisation courante Recommandation moderne
auto Laisser le compilateur déduire automatiquement le type (l'utilisation la plus importante après C++11) auto x = 3.14; → double Fortement recommandéle plus couramment utilisé lors de l'écriture de code
const Constante, ne peut pas être modifiée const int MAX = 100; Plus sûr que #define, dispose d'une vérification de type
static Stockage statique (partagé au sein d'un fichier, partagé entre les membres d'une classe, conserve sa valeur au sein d'une fonction) static int count = 0; Les membres statiques de classe doivent être initialisés en dehors de la classe
extern Déclarer des variables/fonctions définies ailleurs (utilisation entre fichiers) extern int globalVar; Couramment utilisé dans les projets multi-fichiers
thread_local Chaque thread possède sa propre copie (C++11) Programmation multithread
registre Suggéré de placer dans un registre (les compilateurs modernes ignorent pratiquement cela) Pratiquement pas utilisé, obsolète
mutable Permet à une fonction membre const de modifier ce membre Scénario spécial à l'intérieur d'une classe

3. Classes et programmation orientée objet fondamentale (bases de la POO)

Kata kunci Signification (pour débutants) Exemple / Description Importance
classe Définir une classe (privé par défaut) class Student { ... }; ★★★★★
struct Définir une struct (public par défaut, compatible avec C) struct Point { int x,y; }; ★★★★
public Membres publics, tout le monde peut y accéder
private Membres privés, seuls cette classe et les amis peuvent y accéder
protected Membres protégés, accessibles par cette classe + classes dérivées + amis
this Pointeur vers l'objet courant this->age = 18; Souvent utilisé pour distinguer des paramètres de même nom
friend Friend (permet l'accès à private/protected) friend class Utils; Rarement utilisé ; à utiliser avec prudence car cela brise l'encapsulation
virtual Fonction virtuelle (implémente le polymorphisme) virtual void draw() = 0; Cœur du polymorphisme
override Déclare explicitement qu'il s'agit d'un override (C++11, recommandé d'ajouter) void draw() override; Évite les fautes de frappe
final Interdire l'héritage / interdire la redéfinition (C++11) class My final {} Intention de conception claire
explicit Interdire la conversion implicite (le plus courant avec les constructeurs à un seul argument) explicit MyClass(int x); Évite les conversions accidentelles

4. Gestion de la mémoire et des pointeurs

Kata kunci Signification (pour débutants) Exemple / Description Recommandation moderne
nouveau Allouer dynamiquement de la mémoire (renvoie un pointeur) int* p = new int(5); Essayez d'utiliser des pointeurs intelligents
effacement Libérer la mémoire allouée par new delete p; delete[] arr; Utiliser par paires pour éviter les fuites de mémoire
nullptr Constante de pointeur nul (C++11, remplacement recommandé pour NULL) int* ptr = nullptr; Fortement recommandé

5. Conversion de type (4 casts, sécurité)

Kata kunci Signification (pour débutants) Sécurité Cas d'utilisation recommandés
static_cast Conversion à la compilation (types apparentés, conversions numériques, etc.) Élevée Le plus couramment utilisé au quotidien
const_cast Ajouter/retirer const ou volatile Moyenne Rarement utilisé, dangereux
dynamic_cast Downcasting sûr à l'exécution (classes polymorphes) Élevée Vérification de type dans les hiérarchies d'héritage
reinterpret_cast Réinterprétation de motif binaire de bas niveau et dangereuse (conversion arbitraire entre pointeurs) Faible Rarement utilisé (par ex., interaction avec le matériel)

6. Flux de contrôle (le plus basique)

Kata kunci Signification (pour débutants) Exemple
if / else Jugement conditionnel (exécuter si la condition est remplie, sinon exécuter une autre partie) int a = 8; if (a > 10) { cout << "大于10"; } else { cout << "不大于10"; }
switch Sélection multi-branches (ne prend en charge que les types entier/enum/char) int score = 9; switch (score) { case 9: cout << "优秀"; break; default: cout << "普通"; }
case / default Étiquettes de branche dans switch (case correspond à une valeur, default correspond à tous les cas non correspondants) char ch = 'a'; switch (ch) { case 'a': cout << "字母A"; break; default: cout << "其他字符"; }
for Boucle de comptage/plage (adaptée aux scénarios avec un nombre d'itérations connu) for (int i=0; i<10; i++) { cout << i; }(boucle de comptage)
vector<int> v={1,2,3}; for (int num : v) { cout << num; }(boucle range)
while Vérifier d'abord, puis exécuter (nombre d'itérations inconnu ; boucle uniquement tant que la condition est vraie) int i=1; while (i<=5) { cout << i; i++; }
do Exécuter au moins une fois, puis vérifier (nombre d'itérations inconnu ; garantit la première exécution) int i=1; do { cout << i; i++; } while (i<=5);
break Sortir de la boucle actuelle ou de la branche switch (termine immédiatement, n'exécute pas le contenu suivant) for (int i=0; i<10; i++) { if (i==5) break; cout << i; }(sortir de la boucle)
switch (score) { case 9: break; }(sortir de la branche switch)
continue Ignorer la partie restante de l'itération de boucle en cours et passer directement à l'itération suivante for (int i=0; i<10; i++) { if (i%2==0) continue; cout << i; }(afficher uniquement les nombres impairs)
return Renvoyer le résultat de la fonction (pour les fonctions avec une valeur de retour) ou terminer prématurément une fonction void int add(int a, int b) { return a + b; }(renvoyer le résultat de la fonction)
void print() { if (1) return; cout << "此行不会执行"; }(terminer prématurément une fonction void)

7. Gestion des exceptions (encore courante en C++ moderne, mais pas le premier choix)

try / catch / throw

8. Modèles et programmation générique moderne (Intermédiaire/Avancé)

template, typename, concept (C++20), requires (C++20)

9. Autres mots-clés importants mais moins fréquemment utilisés

  • constexpr(C++11) : constantes/fonctions à la compilation
  • inlineSuggère l'inlining de fonction (souvent utilisé dans les définitions de fichiers d'en-tête en C++ moderne)
  • enumÉnumération (recommandation moderne : enum class)
  • namespace / usingGestion des espaces de noms
  • sizeofObtenir la taille en octets d'un type/d'un objet
  • typeidInformations de type à l'exécution (rarement utilisées)
  • asmAssembleur en ligne (rarement utilisé)
  • gotoSaut (fortement déconseillé, rompt la structure)
  • exportExport de template avant C++20 (pratiquement inutile maintenant)

Exemples

1. auto (Déduction automatique de type)

Laissez le compilateur écrire le type pour vous, ce qui rend le code plus concis et moins sujet aux erreurs.

Exemples

#include <iostream>
#include <vector>
#include <string>

int main() {
    auto a = 42;                // déduit comme int
    auto b = 3.14;              // Déduit comme double
    auto c = "hello";           // Déduit comme const char*
    auto d = std::string("world"); // Déduit comme std::string
    auto vec = std::vector{1, 2, 3}; // Déduit comme std::vector<int>

    std::cout << a << " " << b << " " << c << " " << d << "\n";
    for (auto x : vec) {        // auto est couramment utilisé dans les boucles for basées sur des plages
        std::cout << x << " ";
    }
    std::cout << "\n";
}

Sortie :

42 3.14 hello world
1 2 3

2. const (Constante)

Protégez les variables contre les modifications accidentelles, écrivez du code plus sûr.

Exemples

#include <iostream>

int main() {
    const int MAX = 100;     // Doit être initialisée, ne peut pas être modifiée
    // MAX = 200; // Erreur ! Impossible de le modifier

    const double PI = 3.14159;
    std::cout << "π ≈ " << PI << "\n";

    int x = 10;
    const int* p = &x;       // Le contenu pointé par le pointeur ne peut pas être modifié
    // *p = 20; // Erreur !
    x = 30;                  // Mais x lui-même peut être modifié
    std::cout << *p << "\n";
}
圆周率 ≈ 3.14159
30

3. static (statique)

Faire "vivre plus longtemps" les variables, couramment utilisé pour le comptage et le partage de données.

Exemples

#include <iostream>

void counter() {
    static int count = 0;   // Initialisé une seule fois, non détruit lorsque la fonction se termine
    count++;
    std::cout << "Appel " << count << " fois"\n";
}

int main() {
    counter();   // 1
    counter();   // 2
    counter();   // 3
}

Sortie :

第 1 次调用
第 2 次调用
第 3 次调用

4. nullptr (Pointeur nul moderne)

Plus sûr et plus clair que NULL, évitant la confusion de type.

Exemples

#include <iostream>

int main() {
    int* p1 = NULL;       // Ancien style (non recommandé)
    int* p2 = nullptr;    // Approche recommandée en C++ moderne

    if (p2 == nullptr) {
        std::cout << "p2 est un pointeur nul\n";
    }

    // nullptr ne peut être affecté qu'à des pointeurs, pas à des entiers
    // int x = nullptr; // Erreur !
}

Sortie :

p2 是空指针

5. Boucle for basée sur une plage (for(auto : ) boucle range-for)

La méthode la plus simple et la plus sûre pour itérer sur des conteneurs.

Exemples

#include <iostream>
#include <vector>

int main() {
    std::vector<int> scores {85, 92, 78, 95};

    // Approche traditionnelle
    for (size_t i = 0; i < scores.size(); ++i) {
        std::cout << scores[i] << " ";
    }
    std::cout << "\n";

    // Approche moderne (recommandée)
    for (auto score : scores) {
        std::cout << score << " ";
    }
    std::cout << "\n";

    // Si vous devez modifier des éléments, utilisez une référence
    for (auto& score : scores) {
        score += 5;
    }
    for (auto score : scores) {
        std::cout << score << " ";
    }
}

Sortie :

85 92 78 95 
85 92 78 95 
90 97 83 100

6. explicit (Interdire la conversion implicite)

Empêche les bogues causés par des conversions de type accidentelles ; l'ajout d'explicit est plus rigoureux.

Exemples

#include <iostream>

class Distance {
private:
    double meters;
public:
    // explicit Distance(double m) : meters(m) {} // L'ajout d'explicit est plus sûr
    Distance(double m) : meters(m) {}               // Sans cela, une conversion implicite se produit

    double get() const { return meters; }
};

void print(double d) {
    std::cout << "Distance: " << d << " meters\n";
}

int main() {
    Distance d = 500;          // Si le constructeur n'est pas explicit, ceci est autorisé
    print(d);                  // Convertit implicitement Distance → double
    // print(500); // Si explicit est ajouté, cette ligne produira une erreur
}

Sortie (sans explicit) :

距离: 500 米

7. override (Redéfinir explicitement les fonctions virtuelles)

Écrire override permet au compilateur de vérifier si vous avez réellement redéfini une fonction virtuelle.

Exemples

#include <iostream>

class Animal {
public:
    virtual void speak() const {
        std::cout << "Some animal sound\n";
    }
};

class Dog : public Animal {
public:
    void speak() const override {          // L'ajout de override est le plus sûr
        std::cout << "Woof woof woof!\n";
    }
};

int main() {
    Animal* pet = new Dog();
    pet->speak();
    delete pet;
}

Sortie :

Woof woof woof!

8. constexpr (Calcul à la compilation)

Effectuez les calculs à la compilation, ce qui rend les programmes plus rapides et plus sûrs.

Exemples

#include <iostream>

constexpr int factorial(int n) {
    return (n <= 1) ? 1 : n * factorial(n - 1);
}

int main() {
    constexpr int f5 = factorial(5);   // Calculé à 120 au moment de la compilation
    std::cout << "5! = " << f5 << "\n";

    int x = 6;
    // constexpr int f6 = factorial(x); // Erreur ! x n'est pas une constante
    std::cout << "6! = " << factorial(x) << "\n"; // Le calcul à l'exécution fonctionne aussi
}

Sortie :

5! = 120
6! = 720

9. using (espace de noms + alias de type)

using simplifie les espaces de noms et crée des alias de type lisibles.

Exemples

#include <iostream>
#include <vector>

// typedef traditionnel
typedef std::vector<int> IntVec;

// using moderne (plus flexible, peut être templaté)
using StringVec = std::vector<std::string>;

int main() {
    using std::cout;           // Importer uniquement cout
    using std::endl;

    IntVec v1 {1, 2, 3};
    StringVec v2 {"Apple", "Banana"};

    cout << v1.size() << " " << v2.size() << endl;
}

Sortie :

3 2

10. enum class (Énumération fortement typée)

Plus sûr qu'un enum simple, il ne se mélangera pas accidentellement avec des entiers.

Exemples

#include <iostream>

enum class Color { Red, Green, Blue };   // Fortement typé, ne se convertira pas implicitement en int

int main() {
    Color c = Color::Green;

    // if (c == 1) {} // Erreur ! Impossible de comparer directement avec un int
    if (c == Color::Green) {
        std::cout << "est vert\n";
    }

    // Doit être explicitement converti en int
    std::cout << "Valeur sous-jacente : " << static_cast<int>(c) << "\n";
}

Sortie :

是绿色
底层值: 1