Ключевые слова C++ — это зарезервированные языкомспециальные слова, которые нельзя использовать в качестве имён переменных, имён функций и т. д. Они управляют поведением, типами и потоком выполнения программ.

1. Основные типы данных (наиболее часто используемые)

Ключевое слово Значение (для начинающих) Пример / Описание Примечания
bool Логический тип, только true / false bool ok = true; Основа проверки условий
char Один символ (обычно 1 байт) char c = 'A'; Используйте одинарные кавычки
wchar_t Широкий символ (часто используется для поддержки китайского и т. п.) wchar_t wc = L'中'; 2 или 4 байта, зависит от платформы
char8_t Символ UTF-8 (новое в C++20) char8_t c8 = u8'好'; Современное программирование с Unicode
char16_t Символ UTF-16 (C++11)
char32_t Символ UTF-32 (C++11)
int Целое число (обычно 4 байта) int age = 18; Наиболее часто используемый целочисленный тип
short Короткое целое число (обычно 2 байта) short s = 1000; Используйте для экономии памяти
long Длинное целое число (не менее 4 байт, обычно 8 байт) long l = 1234567890L; Добавьте суффикс L
long long Длинное целое число (не менее 8 байт, формализовано в C++11) long long big = 1LL<<60; Работа с большими числами
float Число с плавающей запятой одинарной точности float f = 3.14f; Добавьте суффикс f
double Число с плавающей запятой двойной точности (тип с плавающей запятой по умолчанию) double pi = 3.1415926535; Более высокая точность
void Отсутствие типа (функции, не возвращающие значение, обобщённые указатели и т. д.) void func(); Обычно используется в объявлениях функций
unsigned Беззнаковый (в сочетании с int/long и т. д.) unsigned int id = 4000000000u; Больший диапазон, но не может представлять отрицательные числа

2. Время жизни переменной/объекта и хранение (хранение и длительность)

Ключевое слово Значение (для начинающих) Пример / Обычное использование Современная рекомендация
auto Пусть компилятор автоматически выводит тип (самое важное применение после C++11) auto x = 3.14; → double Настоятельно рекомендуетсячаще всего используется при написании кода
const Константа, не может быть изменена const int MAX = 100; Безопаснее, чем #define, имеет проверку типов
static Статическое хранилище (общее в пределах файла, общее для членов класса, сохраняет значение внутри функции) static int count = 0; Статические члены класса требуют инициализации вне класса
extern Объявляйте переменные/функции, определённые в другом месте (межфайловое использование) extern int globalVar; Часто используется в многофайловых проектах
thread_local Каждый поток имеет свою собственную копию (C++11) Многопоточное программирование
регистр Рекомендуется размещать в регистре (современные компиляторы в основном игнорируют это) Практически не используется, устарело
mutable Позволяет константной функции-члену изменять этот член Особый сценарий внутри класса

3. Классы и основы объектно-ориентированного программирования (основы ООП)

Ключевое слово Значение (для начинающих) Пример / Описание Важность
класс Определить класс (по умолчанию private) class Student { ... }; ★★★★★
struct Определить struct (по умолчанию public, совместим с C) struct Point { int x,y; }; ★★★★
public Открытые члены, доступны всем
private Закрытые члены, доступны только этому классу и друзьям
protected Защищённые члены, доступные этому классу + производным классам + друзьям
this Указатель на текущий объект this->age = 18; Часто используется для различения параметров с одинаковым именем
friend Friend (разрешает доступ к private/protected) friend class Utils; Используется редко; применяйте с осторожностью, так как нарушает инкапсуляцию
virtual Виртуальная функция (реализует полиморфизм) virtual void draw() = 0; Основа полиморфизма
override Явно объявить, что это override (C++11, рекомендуется добавлять) void draw() override; Предотвращает опечатки
final Запретить наследование / запретить переопределение (C++11) class My final {} Ясность проектного замысла
explicit Запретить неявное преобразование (чаще всего с конструкторами с одним аргументом) explicit MyClass(int x); Предотвращает случайные преобразования

4. Управление памятью и указатели

Ключевое слово Значение (для начинающих) Пример / Описание Современная рекомендация
новый Динамически выделять память (возвращает указатель) int* p = new int(5); Старайтесь использовать умные указатели
удаление Освобождайте память, выделенную с помощью new delete p; delete[] arr; Используйте парами, чтобы избежать утечек памяти
nullptr Константа нулевого указателя (C++11, рекомендуемая замена NULL) int* ptr = nullptr; Настоятельно рекомендуется

5. Приведение типов (4 приведения, по убыванию безопасности)

Ключевое слово Значение (для начинающих) Безопасность Рекомендуемые случаи использования
static_cast Преобразование во время компиляции (связанные типы, числовые преобразования и т. д.) Высокая Чаще всего используется в повседневной работе
const_cast Добавление/удаление const или volatile Средняя Используется редко, опасно
dynamic_cast Безопасное во время выполнения понижающее приведение (полиморфные классы) Высокая Проверка типов в иерархиях наследования
reinterpret_cast Низкоуровневая, опасная переинтерпретация битового шаблона (произвольное преобразование между указателями) Низкая Используется редко (например, взаимодействие с аппаратным обеспечением)

6. Управление потоком выполнения (самое базовое)

Ключевое слово Значение (для начинающих) Пример
if / else Условное ветвление (выполнить, если условие истинно, иначе выполнить другую часть) int a = 8; if (a > 10) { cout << "大于10"; } else { cout << "不大于10"; }
switch Многоветвевой выбор (поддерживает только типы integer/enum/char) int score = 9; switch (score) { case 9: cout << "优秀"; break; default: cout << "普通"; }
case / default Метки ветвления в switch (case соответствует значению, default соответствует всем несовпавшим случаям) char ch = 'a'; switch (ch) { case 'a': cout << "字母A"; break; default: cout << "其他字符"; }
for Цикл с подсчётом/диапазоном (подходит для сценариев с известным числом итераций) for (int i=0; i<10; i++) { cout << i; }(цикл с подсчётом)
vector<int> v={1,2,3}; for (int num : v) { cout << num; }(цикл по диапазону)
while Сначала проверка, затем выполнение (неизвестное количество итераций; цикл выполняется только пока условие истинно) int i=1; while (i<=5) { cout << i; i++; }
do Выполнить хотя бы один раз, затем проверить (неизвестное количество итераций; гарантирует первое выполнение) int i=1; do { cout << i; i++; } while (i<=5);
break Прервать текущий цикл/ветвь switch (немедленно завершается, последующее содержимое не выполняется) for (int i=0; i<10; i++) { if (i==5) break; cout << i; }(выход из цикла)
switch (score) { case 9: break; }(выход из ветви switch)
continue Пропустить оставшуюся часть текущей итерации цикла и перейти непосредственно к следующей итерации for (int i=0; i<10; i++) { if (i%2==0) continue; cout << i; }(выводить только нечётные числа)
return Вернуть результат функции (для функций с возвращаемым значением) или завершить void-функцию досрочно int add(int a, int b) { return a + b; }(вернуть результат функции)
void print() { if (1) return; cout << "此行不会执行"; }(завершить void-функцию досрочно)

7. Обработка исключений (по-прежнему распространена в современном C++, но не является первым выбором)

try / catch / throw

8. Шаблоны и современное обобщённое программирование (средний/продвинутый)

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

9. Другие важные, но реже используемые ключевые слова

  • constexpr(C++11): константы/функции времени компиляции
  • inlineПредлагает встраивание функций (часто используется в определениях в заголовочных файлах в современном C++)
  • enumПеречисление (современная рекомендация: enum class)
  • namespace / usingУправление пространствами имён
  • sizeofПолучить размер типа/объекта в байтах
  • typeidИнформация о типе во время выполнения (используется редко)
  • asmВстроенный ассемблер (используется редко)
  • gotoПереход (категорически не рекомендуется, нарушает структуру)
  • exportЭкспорт шаблонов до C++20 (сейчас практически бесполезен)

Примеры

1. auto (Автоматический вывод типа)

Пусть компилятор выведет тип за вас, делая код более кратким и менее подверженным ошибкам.

Примеры

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

int main() {
    auto a = 42;                // выводится как int
    auto b = 3.14;              // Выводится как double
    auto c = "hello";           // Выводится как const char*
    auto d = std::string("world"); // Выводится как std::string
    auto vec = std::vector{1, 2, 3}; // Выводится как std::vector<int>

    std::cout << a << " " << b << " " << c << " " << d << "\n";
    for (auto x : vec) {        // auto обычно используется в циклах for по диапазону
        std::cout << x << " ";
    }
    std::cout << "\n";
}

Вывод:

42 3.14 hello world
1 2 3

2. const (Константа)

Защитите переменные от случайного изменения, пишите более безопасный код.

Примеры

#include <iostream>

int main() {
    const int MAX = 100;     // Должна быть инициализирована, не может быть изменена
    // MAX = 200; // Ошибка! Невозможно изменить

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

    int x = 10;
    const int* p = &x;       // Содержимое, на которое указывает указатель, нельзя изменить
    // *p = 20; // Ошибка!
    x = 30;                  // Но сам x можно изменить
    std::cout << *p << "\n";
}
圆周率 ≈ 3.14159
30

3. static (статический)

Заставляют переменные "жить дольше", обычно используются для подсчёта и обмена данными.

Примеры

#include <iostream>

void counter() {
    static int count = 0;   // Инициализируется только один раз, не уничтожается при завершении функции
    count++;
    std::cout << "Вызов " << count << " раз"\n";
}

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

Вывод:

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

4. nullptr (современный нулевой указатель)

Безопаснее и понятнее, чем NULL, избегая путаницы типов.

Примеры

#include <iostream>

int main() {
    int* p1 = NULL;       // Старый стиль (не рекомендуется)
    int* p2 = nullptr;    // Рекомендуемый подход в современном C++

    if (p2 == nullptr) {
        std::cout << "p2 — нулевой указатель\n";
    }

    // nullptr можно присваивать только указателям, а не целым числам
    // int x = nullptr; // Ошибка!
}

Вывод:

p2 是空指针

5. цикл for по диапазону (for(auto : ) цикл range-for)

Самый простой и безопасный способ итерации по контейнерам.

Примеры

#include <iostream>
#include <vector>

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

    // Традиционный подход
    for (size_t i = 0; i < scores.size(); ++i) {
        std::cout << scores[i] << " ";
    }
    std::cout << "\n";

    // Современный подход (рекомендуется)
    for (auto score : scores) {
        std::cout << score << " ";
    }
    std::cout << "\n";

    // Если нужно изменять элементы, используйте ссылку
    for (auto& score : scores) {
        score += 5;
    }
    for (auto score : scores) {
        std::cout << score << " ";
    }
}

Вывод:

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

6. explicit (запрет неявного преобразования)

Предотвращает ошибки, вызванные случайными преобразованиями типов; добавление explicit делает код более строгим.

Примеры

#include <iostream>

class Distance {
private:
    double meters;
public:
    // explicit Distance(double m) : meters(m) {} // Добавление explicit безопаснее
    Distance(double m) : meters(m) {}               // Без него происходит неявное преобразование

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

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

int main() {
    Distance d = 500;          // Если конструктор не explicit, это разрешено
    print(d);                  // Неявно преобразует Distance → double
    // print(print); // Если добавить explicit, эта строка вызовет ошибку
}

Вывод (без explicit):

距离: 500 米

7. override (Явное переопределение виртуальных функций)

Написание override позволяет компилятору проверить, действительно ли вы переопределили виртуальную функцию.

Примеры

#include <iostream>

class Animal {
public:
    virtual void speak() const {
        std::cout << "Какой-то звук животного\n";
    }
};

class Dog : public Animal {
public:
    void speak() const override {          // Добавление override — самый безопасный вариант
        std::cout << "Гав-гав-гав!\n";
    }
};

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

Вывод:

Woof woof woof!

8. constexpr (Вычисления на этапе компиляции)

Выполняйте вычисления на этапе компиляции, делая программы быстрее и безопаснее.

Примеры

#include <iostream>

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

int main() {
    constexpr int f5 = factorial(5);   // Вычисляется как 120 во время компиляции
    std::cout << "5! = " << f5 << "\n";

    int x = 6;
    // constexpr int f6 = factorial(x); // Ошибка! x не является константой
    std::cout << "6! = " << factorial(x) << "\n"; // Вычисление во время выполнения также работает
}

Вывод:

5! = 120
6! = 720

9. using (пространство имён + псевдоним типа)

using упрощает работу с пространствами имён и создаёт удобочитаемые псевдонимы типов.

Примеры

#include <iostream>
#include <vector>

// Традиционный typedef
typedef std::vector<int> IntVec;

// Современный using (более гибкий, может быть шаблонным)
using StringVec = std::vector<std::string>;

int main() {
    using std::cout;           // Импортировать только cout
    using std::endl;

    IntVec v1 {1, 2, 3};
    StringVec v2 {"Яблоко", "Банан"};

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

Вывод:

3 2

10. enum class (Строго типизированное перечисление)

Безопаснее обычного enum, не будет случайно смешиваться с целыми числами.

Примеры

#include <iostream>

enum class Color { Red, Green, Blue };   // Строго типизирован, не будет неявно преобразовываться в int

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

    // if (c == 1) {} // Ошибка! Невозможно напрямую сравнивать с int
    if (c == Color::Green) {
        std::cout << "зелёный\n";
    }

    // Необходимо явно преобразовать в int
    std::cout << "Базовое значение: " << static_cast<int>(c) << "\n";
}

Вывод:

是绿色
底层值: 1