C++-Schlüsselwörter sind sprachlich reserviertespezielle Wörter, die nicht als Variablennamen, Funktionsnamen usw. verwendet werden können. Sie steuern das Verhalten, die Typen und den Ablauf von Programmen.

1. Grundlegende Datentypen (am häufigsten verwendet)

Schlüsselwort Bedeutung (für Anfänger) Beispiel / Beschreibung Hinweise
bool Boolescher Typ, nur true / false bool ok = true; Kern der Bedingungsprüfung
char Einzelzeichen (normalerweise 1 Byte) char c = 'A'; Einfache Anführungszeichen verwenden
wchar_t Breitzeichen (oft verwendet, um Chinesisch usw. zu unterstützen) wchar_t wc = L'中'; 2 oder 4 Bytes, plattformabhängig
char8_t UTF-8-Zeichen (neu in C++20) char8_t c8 = u8'好'; Moderne Unicode-Programmierung
char16_t UTF-16-Zeichen (C++11)
char32_t UTF-32-Zeichen (C++11)
int Ganzzahl (normalerweise 4 Bytes) int age = 18; Am häufigsten verwendeter Ganzzahltyp
short Kurze Ganzzahl (normalerweise 2 Bytes) short s = 1000; Verwenden, wenn Speicherplatz gespart werden soll
long Lange Ganzzahl (mindestens 4 Bytes, häufig 8 Bytes) long l = 1234567890L; L-Suffix hinzufügen
long long Längere Ganzzahl (mindestens 8 Bytes, in C++11 formalisiert) long long big = 1LL<<60; Große Zahlen verarbeiten
float Gleitkommazahl mit einfacher Genauigkeit float f = 3.14f; f-Suffix anhängen
double Gleitkommazahl mit doppelter Genauigkeit (Standard-Gleitkommatyp) double pi = 3.1415926535; Höhere Genauigkeit
void Kein Typ (Funktionen ohne Rückgabewert, generische Zeiger usw.) void func(); Häufig in Funktionsdeklarationen verwendet
unsigned Unsigned (kombiniert mit int/long usw.) unsigned int id = 4000000000u; Größerer Wertebereich, kann aber keine negativen Zahlen darstellen

2. Lebensdauer und Speicherung von Variablen/Objekten (Speicherung & Dauer)

Schlüsselwort Bedeutung (für Anfänger) Beispiel / Häufige Verwendung Moderne Empfehlung
auto Den Compiler den Typ automatisch ableiten lassen (die wichtigste Verwendung nach C++11) auto x = 3.14; → double Sehr empfohlenam häufigsten beim Schreiben von Code verwendet
const Konstante, kann nicht geändert werden const int MAX = 100; Sicherer als #define, besitzt Typprüfung
static Statische Speicherung (innerhalb einer Datei geteilt, unter Klassenmembern geteilt, behält den Wert innerhalb einer Funktion) static int count = 0; Statische Klassenmember müssen außerhalb der Klasse initialisiert werden
extern Deklariert Variablen/Funktionen, die anderswo definiert sind (dateiübergreifende Verwendung) extern int globalVar; Häufig in Multidatei-Projekten verwendet
thread_local Jeder Thread hat seine eigene Kopie (C++11) Multithread-Programmierung
Register Empfohlen, in einem Register abzulegen (moderne Compiler ignorieren dies im Grunde) Im Grunde nicht verwendet, veraltet
mutable Ermöglicht einer const-Member-Funktion, dieses Member zu ändern Spezielles Szenario innerhalb einer Klasse

3. Klassen und Kern der objektorientierten Programmierung (OOP-Grundlagen)

Schlüsselwort Bedeutung (für Anfänger) Beispiel / Beschreibung Bedeutung
class Definiert eine Klasse (standardmäßig private) class Student { ... }; ★★★★★
struct Definiert ein struct (standardmäßig public, kompatibel mit C) struct Point { int x,y; }; ★★★★
public Public-Member, auf die jeder zugreifen kann
private Private Member, auf die nur diese Klasse und Friends zugreifen können
protected Protected Member, auf die diese Klasse + abgeleitete Klassen + Friends zugreifen können
this Zeiger auf das aktuelle Objekt this->age = 18; Wird oft verwendet, um Parameter mit demselben Namen zu unterscheiden
friend Friend (ermöglicht Zugriff auf private/protected) friend class Utils; Wird selten verwendet; mit Vorsicht einsetzen, da es die Kapselung durchbricht
virtual Virtuelle Funktion (implementiert Polymorphismus) virtual void draw() = 0; Kern des Polymorphismus
override Explizit deklarieren, dass dies ein override ist (C++11, empfohlen hinzuzufügen) void draw() override; Verhindert Tippfehler
final Vererbung verbieten / Überschreiben verbieten (C++11) class My final {} Klare Designabsicht
explicit Implizite Konvertierung verbieten (am häufigsten bei Konstruktoren mit einem Argument) explicit MyClass(int x); Verhindert versehentliche Konvertierungen

4. Speicherverwaltung und Zeiger

Schlüsselwort Bedeutung (für Anfänger) Beispiel / Beschreibung Moderne Empfehlung
new Speicher dynamisch reservieren (gibt einen Zeiger zurück) int* p = new int(5); Versuchen Sie, Smart Pointer zu verwenden
Löschen Mit new zugewiesenen Speicher freigeben delete p; delete[] arr; Paarweise verwenden, um Speicherlecks zu vermeiden
nullptr Nullzeiger-Konstante (C++11, empfohlener Ersatz für NULL) int* ptr = nullptr; Sehr zu empfehlen

5. Typumwandlung (4 Casts, abnehmende Sicherheit)

Schlüsselwort Bedeutung (für Anfänger) Sicherheit Empfohlene Anwendungsfälle
static_cast Compile-Time-Konvertierung (verwandte Typen, numerische Konvertierungen, usw.) Hoch Am häufigsten im Arbeitsalltag verwendet
const_cast const oder volatile hinzufügen/entfernen Mittel Selten verwendet, gefährlich
dynamic_cast Laufzeitsicheres Downcasting (polymorphe Klassen) Hoch Typprüfung in Vererbungshierarchien
reinterpret_cast Low-Level- und gefährliche Bitmuster-Neuinterpretation (beliebige Konvertierung zwischen Zeigern) Niedrig Selten verwendet (z. B. Hardware-Interaktion)

6. Kontrollfluss (Grundlegendstes)

Schlüsselwort Bedeutung (für Anfänger) Beispiel
if / else Bedingte Anweisung (ausführen, wenn die Bedingung erfüllt ist, andernfalls einen anderen Teil ausführen) int a = 8; if (a > 10) { cout << "大于10"; } else { cout << "不大于10"; }
switch Mehrfachverzweigung (unterstützt nur Integer-/Enum-/Char-Typen) int score = 9; switch (score) { case 9: cout << "优秀"; break; default: cout << "普通"; }
case / default Verzweigungsmarkierungen in switch (case passt auf einen Wert, default passt auf alle nicht übereinstimmenden Fälle) char ch = 'a'; switch (ch) { case 'a': cout << "字母A"; break; default: cout << "其他字符"; }
for Zähl-/Bereichsschleife (geeignet für Szenarien mit bekannter Anzahl von Iterationen) for (int i=0; i<10; i++) { cout << i; }(Zählschleife)
vector<int> v={1,2,3}; for (int num : v) { cout << num; }(Range-Schleife)
while Erst prüfen, dann ausführen (unbekannte Anzahl von Iterationen; Schleife nur, solange die Bedingung erfüllt ist) int i=1; while (i<=5) { cout << i; i++; }
do Mindestens einmal ausführen, dann prüfen (unbekannte Anzahl von Iterationen; stellt die erste Ausführung sicher) int i=1; do { cout << i; i++; } while (i<=5);
break Aus der aktuellen Schleife bzw. dem switch-Zweig ausbrechen (beendet sofort, führt nachfolgenden Inhalt nicht aus) for (int i=0; i<10; i++) { if (i==5) break; cout << i; }(aus der Schleife ausbrechen)
switch (score) { case 9: break; }(aus dem switch-Zweig ausbrechen)
continue Den restlichen Teil der aktuellen Schleifeniteration überspringen und direkt zur nächsten Iteration übergehen for (int i=0; i<10; i++) { if (i%2==0) continue; cout << i; }(nur ungerade Zahlen ausgeben)
return Das Funktionsergebnis zurückgeben (bei Funktionen mit Rückgabewert) oder eine void-Funktion vorzeitig beenden int add(int a, int b) { return a + b; }(das Funktionsergebnis zurückgeben)
void print() { if (1) return; cout << "此行不会执行"; }(eine void-Funktion vorzeitig beenden)

7. Ausnahmebehandlung (Im modernen C++ noch üblich, aber nicht die erste Wahl)

try / catch / throw

8. Templates und moderne generische Programmierung (Mittelstufe/Fortgeschritten)

template、typename、concept（C++20）、requires（C++20）

9. Weitere wichtige, aber seltener verwendete Schlüsselwörter

  • constexpr(C++11): Konstanten/Funktionen zur Compile-Zeit
  • inlineEmpfiehlt Funktions-Inlining (wird in modernem C++ oft bei Definitionen in Header-Dateien verwendet)
  • enumAufzählung (moderne Empfehlung: enum class)
  • namespace / usingNamespace-Verwaltung
  • sizeofErmittelt die Byte-Größe eines Typs/Objekts
  • typeidLaufzeit-Typinformation (selten verwendet)
  • asmInline-Assembler (selten verwendet)
  • gotoSprung (stark nicht empfohlen, bricht die Struktur)
  • exportTemplate-Export vor C++20 (mittlerweile praktisch nutzlos)

Beispiele

1. auto (Automatische Typableitung)

Lass den Compiler den Typ für dich schreiben, wodurch der Code prägnanter und weniger fehleranfällig wird.

Beispiele

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

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

    std::cout << a << " " << b << " " << c << " " << d << "\n";
    for (auto x : vec) {        // auto wird häufig in bereichsbasierten for-Schleifen verwendet
        std::cout << x << " ";
    }
    std::cout << "\n";
}

Ausgabe:

42 3.14 hello world
1 2 3

2. const (Konstante)

Schütze Variablen vor versehentlicher Änderung, schreibe sichereren Code.

Beispiele

#include <iostream>

int main() {
    const int MAX = 100;     // Muss initialisiert werden, kann nicht geändert werden
    // MAX = 200; // Fehler! Kann nicht geändert werden

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

    int x = 10;
    const int* p = &x;       // Der Inhalt, auf den der Zeiger zeigt, kann nicht geändert werden
    // *p = 20; // Fehler!
    x = 30;                  // Aber x selbst kann geändert werden
    std::cout << *p << "\n";
}
圆周率 ≈ 3.14159
30

3. static (Statisch)

Lassen Sie Variablen "länger leben", häufig zum Zählen und Teilen von Daten verwendet.

Beispiele

#include <iostream>

void counter() {
    static int count = 0;   // Wird nur einmal initialisiert, nicht zerstört, wenn die Funktion endet
    count++;
    std::cout << "Aufruf " << count << " Mal"\n";
}

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

Ausgabe:

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

4. nullptr (Moderner Nullzeiger)

Sicherer und klarer als NULL, wodurch Typverwechslungen vermieden werden.

Beispiele

#include <iostream>

int main() {
    int* p1 = NULL;       // Alter Stil (nicht empfohlen)
    int* p2 = nullptr;    // Empfohlener moderner C++-Ansatz

    if (p2 == nullptr) {
        std::cout << "p2 ist ein Nullzeiger\n";
    }

    // nullptr kann nur Zeigern zugewiesen werden, nicht Ganzzahlen
    // int x = nullptr; // Fehler!
}

Ausgabe:

p2 是空指针

5. Bereichsbasierte for-Schleife (for(auto : ) Range-for-Schleife)

Die einfachste und sicherste Möglichkeit, über Container zu iterieren.

Beispiele

#include <iostream>
#include <vector>

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

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

    // Moderner Ansatz (empfohlen)
    for (auto score : scores) {
        std::cout << score << " ";
    }
    std::cout << "\n";

    // Wenn Sie Elemente ändern müssen, verwenden Sie eine Referenz
    for (auto& score : scores) {
        score += 5;
    }
    for (auto score : scores) {
        std::cout << score << " ";
    }
}

Ausgabe:

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

6. explicit (Implizite Konvertierung verhindern)

Verhindert Fehler durch versehentliche Typkonvertierungen; das Hinzufügen von explicit ist strenger.

Beispiele

#include <iostream>

class Distance {
private:
    double meters;
public:
    // explicit Distance(double m) : meters(m) {} // Das Hinzufügen von explicit ist sicherer
    Distance(double m) : meters(m) {}               // Ohne dies erfolgt eine implizite Konvertierung

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

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

int main() {
    Distance d = 500;          // Wenn der Konstruktor nicht explicit ist, ist dies erlaubt
    print(d);                  // Konvertiert Distance implizit → double
    // print(500); // Wenn explicit hinzugefügt wird, verursacht diese Zeile einen Fehler
}

Ausgabe (ohne explicit):

距离: 500 米

7. override (Virtuelle Funktionen explizit überschreiben)

Das Schreiben von override ermöglicht es dem Compiler zu prüfen, ob du tatsächlich eine virtuelle Funktion überschrieben hast.

Beispiele

#include <iostream>

class Animal {
public:
    virtual void speak() const {
        std::cout << "Ein Tiergeräusch\n";
    }
};

class Dog : public Animal {
public:
    void speak() const override {          // Das Hinzufügen von override ist am sichersten
        std::cout << "Wau wau wau!\n";
    }
};

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

Ausgabe:

Woof woof woof!

8. constexpr (Berechnung zur Compile-Zeit)

Berechnungen zur Compile-Zeit durchführen, wodurch Programme schneller und sicherer werden.

Beispiele

#include <iostream>

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

int main() {
    constexpr int f5 = factorial(5);   // Zur Kompilierzeit als 120 berechnet
    std::cout << "5! = " << f5 << "\n";

    int x = 6;
    // constexpr int f6 = factorial(x); // Fehler! x ist keine Konstante
    std::cout << "6! = " << factorial(x) << "\n"; // Berechnung zur Laufzeit funktioniert ebenfalls
}

Ausgabe:

5! = 120
6! = 720

9. using (Namensraum + Typalias)

using vereinfacht Namensräume und erstellt lesbare Typaliase.

Beispiele

#include <iostream>
#include <vector>

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

// Modernes using (flexibler, kann als Template verwendet werden)
using StringVec = std::vector<std::string>;

int main() {
    using std::cout;           // Nur cout importieren
    using std::endl;

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

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

Ausgabe:

3 2

10. enum class (stark typisierte Enumeration)

Sicherer als ein einfaches enum, wird nicht versehentlich mit Ganzzahlen vermischt.

Beispiele

#include <iostream>

enum class Color { Red, Green, Blue };   // Stark typisiert, wird nicht implizit in int konvertiert

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

    // if (c == 1) {} // Fehler! Kann nicht direkt mit int verglichen werden
    if (c == Color::Green) {
        std::cout << "ist grün\n";
    }

    // Muss explizit in int konvertiert werden
    std::cout << "Zugrunde liegender Wert: " << static_cast<int>(c) << "\n";
}

Ausgabe:

是绿色
底层值: 1