⚙️Справочник по C++

Справочник, с МНОЖЕСТВОМ команд, в gitbook присутствует поиск, так что пользуйтесь на здоровье

Пример программы

#include <iostream>
#include <locale.h>
using namespace std;

int main() {
    int a, b, c;
    setlocale(LC_ALL, "");
    cout << "Введите значение a: ";
    cin >> a;

    cout << "Введите значение b: ";
    cin >> b;

    c = a + b;

    cout << "Результат сложения: " << c << endl;

    return 0;
}

1. Команда: #include

Определение: Директива #include используется для подключения внешних библиотек или заголовочных файлов в программу.

Пример кода:

#include <iostream> // Подключаем библиотеку для ввода/вывода

int main() {
    cout << "Пример команды #include" << endl;
    return 0;
}

Вывод:

Пример команды #include

---

2. Команда: int main

Определение: int main — это точка входа в программу. С этого места начинается выполнение программы.

Пример кода:

#include <iostream>

int main() {
    cout << "Пример команды int main" << endl;
    return 0;
}

Вывод:

Пример команды int main

---

3. Команда: cout

Определение: cout — это объект для вывода данных в стандартный поток вывода (обычно на экран).

Пример кода:

#include <iostream>

int main() {
    cout << "Пример команды cout" << endl;
    return 0;
}

Вывод:

Пример команды cout

---

4. Команда: cin

Определение: cin — это объект для ввода данных из стандартного потока ввода (обычно с клавиатуры).

Пример кода:

#include <iostream>

int main() {
    int число;
    cout << "Введите число: ";
    cin >> число;
    cout << "Вы ввели: " << число << endl;
    return 0;
}

Вывод:

Введите число: 10
Вы ввели: 10

---

5. Команда: return

Определение: return — используется для выхода из функции и, если необходимо, возвращает значение (обычно используется в функции main для возврата к операционной системе).

Пример кода:

#include <iostream>

int main() {
    cout << "Пример команды return" << endl;
    return 0; // Завершает выполнение программы
}

Вывод:

Пример команды return

---

6. Команда: if

Определение: if — это условная конструкция, которая выполняет код, если условие истинно.

Пример кода:

#include <iostream>

int main() {
    int число = 5;
    if (число > 0) {
        cout << "Число положительное" << endl;
    }
    return 0;
}

Вывод:

Число положительное

---

7. Команда: else

Определение: else — используется в паре с if и выполняет код, если условие в if ложно.

Пример кода:

#include <iostream>

int main() {
    int число = -5;
    if (число > 0) {
        cout << "Число положительное" << endl;
    } else {
        cout << "Число отрицательное" << endl;
    }
    return 0;
}

Вывод:

Число отрицательное

---

8. Команда: else if

Определение: else if — используется для проверки нескольких условий в цепочке. Если первое условие ложно, проверяется следующее.

Пример кода:

#include <iostream>

int main() {
    int число = 0;
    if (число > 0) {
        cout << "Число положительное" << endl;
    } else if (число < 0) {
        cout << "Число отрицательное" << endl;
    } else {
        cout << "Число равно нулю" << endl;
    }
    return 0;
}

Вывод:

Число равно нулю

---

9. Команда: switch

Определение: switch — это конструкция, которая используется для многократных проверок выражения. Вместо нескольких if-else можно использовать switch.

Пример кода:

#include <iostream>

int main() {
    int день = 3;
    switch (день) {
        case 1:
            cout << "Понедельник" << endl;
            break;
        case 2:
            cout << "Вторник" << endl;
            break;
        case 3:
            cout << "Среда" << endl;
            break;
        default:
            cout << "Неизвестный день" << endl;
    }
    return 0;
}

Вывод:

Среда

---

10. Команда: for

Определение: for — это цикл с заранее заданным числом повторений.

Пример кода:

#include <iostream>

int main() {
    for (int i = 1; i <= 5; i++) {
        cout << "Итерация " << i << endl;
    }
    return 0;
}

Вывод:

Итерация 1
Итерация 2
Итерация 3
Итерация 4
Итерация 5

---

11. Команда: while

Определение: while — это цикл, который выполняется, пока условие истинно.

Пример кода:

#include <iostream>

int main() {
    int i = 1;
    while (i <= 5) {
        cout << "Итерация " << i << endl;
        i++;
    }
    return 0;
}

Вывод:

Итерация 1
Итерация 2
Итерация 3
Итерация 4
Итерация 5

---

12. Команда: do while

Определение: do while — это цикл, который выполняет код хотя бы один раз, а затем проверяет условие.

Пример кода:

#include <iostream>

int main() {
    int i = 1;
    do {
        cout << "Итерация " << i << endl;
        i++;
    } while (i <= 5);
    return 0;
}

Вывод:

Итерация 1
Итерация 2
Итерация 3
Итерация 4
Итерация 5

---

13. Команда: break

Определение: break используется для выхода из цикла или switch-блока.

Пример кода:

#include <iostream>

int main() {
    for (int i = 1; i <= 10; i++) {
        if (i == 5) {
            break; // Выход из цикла при i = 5
        }
        cout << i << " ";
    }
    return 0;
}

Вывод:

1 2 3 4

---

14. Команда: continue

Определение: continue пропускает оставшуюся часть тела цикла и переходит к следующей итерации.

Пример кода:

#include <iostream>

int main() {
    for (int i = 1; i <= 5; i++) {
        if (i == 3) {
            continue; // Пропускает итерацию, когда i = 3
        }
        cout << i << " ";
    }
    return 0;
}

Вывод:

1 2 4 5

15. Команда: const

Определение: const используется для объявления констант, то есть значений, которые не могут быть изменены после их инициализации.

Пример кода:

#include <iostream>

int main() {
    const int максимальное_значение = 100;
    cout << "Максимальное значение: " << максимальное_значение << endl;
    // максимальное_значение = 200; // Ошибка! Константу нельзя изменить
    return 0;
}

Вывод:

Максимальное значение: 100

---

16. Команда: typedef

Определение: typedef используется для создания псевдонимов типов данных, чтобы сделать код более удобочитаемым.

Пример кода:

#include <iostream>

typedef unsigned int uint; // Создаем псевдоним для типа unsigned int

int main() {
    uint число = 42;
    cout << "Число: " << число << endl;
    return 0;
}

Вывод:

Число: 42

---

17. Команда: unsigned

Определение: unsigned используется для объявления переменных, которые не могут принимать отрицательные значения.

Пример кода:

#include <iostream>

int main() {
    unsigned int число = 10;
    cout << "Число: " << число << endl;
    // unsigned int отрицательное_число = -1; // Ошибка! Нельзя присвоить отрицательное значение
    return 0;
}

Вывод:

Число: 10

---

18. Команда: long long

Определение: long long используется для объявления переменной типа с очень большим диапазоном значений.

Пример кода:

#include <iostream>

int main() {
    long long большое_число = 10000000000;
    cout << "Большое число: " << большое_число << endl;
    return 0;
}

Вывод:

Большое число: 10000000000

---

19. Команда: sizeof

Определение: sizeof — оператор, который возвращает размер переменной или типа данных в байтах.

Пример кода:

#include <iostream>

int main() {
    int число = 5;
    cout << "Размер типа int: " << sizeof(int) << " байт" << endl;
    cout << "Размер переменной число: " << sizeof(число) << " байт" << endl;
    return 0;
}

Вывод:

Размер типа int: 4 байт
Размер переменной число: 4 байт

---

20. Команда: #define

Определение: #define — директива препроцессора, которая используется для создания макросов. Это позволяет задавать константы или простые функции, которые заменяются на соответствующие значения в коде до его компиляции.

Пример кода:

#include <iostream>

#define PI 3.14159

int main() {
    cout << "Значение PI: " << PI << endl;
    return 0;
}

Вывод:

Значение PI: 3.14159

---

21. Команда: && (Логическое И)

Определение: && — оператор логического И, который возвращает true, если оба операнда истинны.

Пример кода:

#include <iostream>

int main() {
    bool условие1 = true;
    bool условие2 = false;

    if (условие1 && условие2) {
        cout << "Оба условия истинны" << endl;
    } else {
        cout << "Одно или оба условия ложны" << endl;
    }
    return 0;
}

Вывод:

Одно или оба условия ложны

---

22. Команда: || (Логическое ИЛИ)

Определение: || — оператор логического ИЛИ, который возвращает true, если хотя бы один из операндов истинен.

Пример кода:

#include <iostream>

int main() {
    bool условие1 = true;
    bool условие2 = false;

    if (условие1 || условие2) {
        cout << "Хотя бы одно условие истинно" << endl;
    } else {
        cout << "Оба условия ложны" << endl;
    }
    return 0;
}

Вывод:

Хотя бы одно условие истинно

---

23. Команда: ! (Логическое НЕ)

Определение: ! — оператор логического НЕ, который инвертирует значение условия (делает его противоположным).

Пример кода:

#include <iostream>

int main() {
    bool условие = true;

    if (!условие) {
        cout << "Условие ложное" << endl;
    } else {
        cout << "Условие истинное" << endl;
    }
    return 0;
}

Вывод:

Условие истинное

---

24. Команда: == (Оператор равенства)

Определение: == — оператор сравнения, который проверяет, равны ли два значения.

Пример кода:

#include <iostream>

int main() {
    int a = 5;
    int b = 5;

    if (a == b) {
        cout << "a равно b" << endl;
    } else {
        cout << "a не равно b" << endl;
    }
    return 0;
}

Вывод:

a равно b

---

25. Команда: != (Оператор неравенства)

Определение: != — оператор сравнения, который проверяет, не равны ли два значения.

Пример кода:

#include <iostream>

int main() {
    int a = 5;
    int b = 10;

    if (a != b) {
        cout << "a не равно b" << endl;
    } else {
        cout << "a равно b" << endl;
    }
    return 0;
}

Вывод:

a не равно b

---

26. Команда: > (Оператор больше)

Определение: > — оператор сравнения, который проверяет, больше ли первое значение второго.

Пример кода:

#include <iostream>

int main() {
    int a = 5;
    int b = 3;

    if (a > b) {
        cout << "a больше b" << endl;
    } else {
        cout << "a не больше b" << endl;
    }
    return 0;
}

Вывод:

a больше b

27. Команда: < (Оператор меньше)

Определение: < — оператор сравнения, который проверяет, меньше ли первое значение второго.

Пример кода:

#include <iostream>

int main() {
    int a = 3;
    int b = 5;

    if (a < b) {
        cout << "a меньше b" << endl;
    } else {
        cout << "a не меньше b" << endl;
    }
    return 0;
}

Вывод:

a меньше b

---

28. Команда: >= (Оператор больше или равно)

Определение: >= — оператор сравнения, который проверяет, больше ли или равно первое значение второму.

Пример кода:

#include <iostream>

int main() {
    int a = 5;
    int b = 5;

    if (a >= b) {
        cout << "a больше или равно b" << endl;
    } else {
        cout << "a не больше и не равно b" << endl;
    }
    return 0;
}

Вывод:

a больше или равно b

---

29. Команда: <= (Оператор меньше или равно)

Определение: <= — оператор сравнения, который проверяет, меньше ли или равно первое значение второму.

Пример кода:

#include <iostream>

int main() {
    int a = 4;
    int b = 5;

    if (a <= b) {
        cout << "a меньше или равно b" << endl;
    } else {
        cout << "a не меньше и не равно b" << endl;
    }
    return 0;
}

Вывод:

a меньше или равно b

---

30. Команда: [] (Массивы)

Определение: [] — используется для работы с массивами. Массив в C++ — это структура данных, которая позволяет хранить несколько элементов одного типа.

Пример кода:

#include <iostream>

int main() {
    int массив[5] = {1, 2, 3, 4, 5};
    cout << "Первый элемент массива: " << массив[0] << endl;
    cout << "Третий элемент массива: " << массив[2] << endl;
    return 0;
}

Вывод:

Первый элемент массива: 1
Третий элемент массива: 3

---

31. Команда: & (Адрес переменной)

Определение: & используется для получения адреса переменной в памяти (оператор взятия адреса).

Пример кода:

#include <iostream>

int main() {
    int число = 10;
    cout << "Адрес переменной число: " << &число << endl;
    return 0;
}

Вывод:

Адрес переменной число: 0x7ffde41b075c (адрес может варьироваться)

---

32. Команда: * (Указатель)

Определение: * используется для работы с указателями. Указатель — это переменная, которая хранит адрес другой переменной.

Пример кода:

#include <iostream>

int main() {
    int число = 10;
    int* указатель = &число; // Указатель на число

    cout << "Значение переменной через указатель: " << *указатель << endl;
    return 0;
}

Вывод:

Значение переменной через указатель: 10

---

33. Команда: -> (Доступ через указатель)

Определение: -> используется для доступа к членам структуры или класса через указатель.

Пример кода:

#include <iostream>

struct Человек {
    std::string имя;
    int возраст;
};

int main() {
    Человек* человек = new Человек{"Иван", 30};
    cout << "Имя: " << человек->имя << ", Возраст: " << человек->возраст << endl;
    delete человек;
    return 0;
}

Вывод:

Имя: Иван, Возраст: 30

---

34. Команда: new (Динамическое выделение памяти)

Определение: new используется для динамического выделения памяти в программе.

Пример кода:

#include <iostream>

int main() {
    int* число = new int; // Выделяем память для одного целого числа
    *число = 100; // Присваиваем значение
    cout << "Значение: " << *число << endl;
    delete число; // Освобождаем память
    return 0;
}

Вывод:

Значение: 100

---

35. Команда: delete (Освобождение памяти)

Определение: delete используется для освобождения памяти, выделенной с помощью оператора new.

Пример кода:

#include <iostream>

int main() {
    int* число = new int(5); // Выделяем память и инициализируем переменную
    cout << "Значение: " << *число << endl;
    delete число; // Освобождаем память
    return 0;
}

Вывод:

Значение: 5

---

36. Команда: #ifdef и #endif

Определение: #ifdef и #endif — директивы препроцессора, которые позволяют условно компилировать часть кода в зависимости от того, определена ли конкретная макроконстанта.

Пример кода:

#include <iostream>

#define DEBUG // Определим макрос DEBUG

int main() {
#ifdef DEBUG
    cout << "Режим отладки включен!" << endl;
#endif
    return 0;
}

Вывод:

Режим отладки включен!

---

37. Команда: #ifndef и #define

Определение: #ifndef и #define используются для предотвращения множественного включения заголовочных файлов в программу.

Пример кода:

#include <iostream>

#ifndef MY_HEADER // Проверка, если MY_HEADER не определен
#define MY_HEADER // Определение MY_HEADER

void функция() {
    cout << "Функция выполнена!" << endl;
}

#endif

int main() {
    функция();
    return 0;
}

Вывод:

Функция выполнена!

---

38. Команда: this

Определение: this — указатель на текущий объект внутри метода класса.

Пример кода:

#include <iostream>

class Человек {
public:
    std::string имя;

    void вывести_имя() {
        cout << "Имя: " << this->имя << endl; // Использование указателя this
    }
};

int main() {
    Человек человек;
    человек.имя = "Иван";
    человек.вывести_имя();
    return 0;
}

Вывод:

Имя: Иван

---

39. Команда: friend

Определение: friend позволяет одной функции или классу иметь доступ к приватным и защищенным членам другого класса.

Пример кода:

#include <iostream>

class Пример {
private:
    int число;

public:
    Пример() : число(10) {}

    friend void вывести_число(Пример& obj); // Дружеская функция
};

void вывести_число(Пример& obj) {
    cout << "Число: " << obj.число << endl; // Доступ к приватному члену
}

int main() {
    Пример obj;
    вывести_число(obj);
    return 0;
}

Вывод:

Число: 10

---

40. Команда: virtual

Определение: virtual — используется для создания виртуальных функций в базовых классах, которые могут быть переопределены в производных классах.

Пример кода:

#include <iostream>

class Базовый {
public:
    virtual void вывести() {
        cout << "Базовый класс" << endl;
    }
};

class Производный : public Базовый {
public:
    void вывести() override {
        cout << "Производный класс" << endl;
    }
};

int main() {
    Базовый* объект = new Производный();
    объект->вывести(); // Виртуальная функция вызовет метод производного класса
    delete объект;
    return 0;
}

Вывод:

Производный класс

---

41. Команда: override

Определение: override используется для явного указания, что метод переопределяет виртуальную функцию в производном классе.

Пример кода:

#include <iostream>

class Базовый {
public:
    virtual void вывести() {
        cout << "Базовый класс" << endl;
    }
};

class Производный : public Базовый {
public:
    void вывести() override {
        cout << "Производный класс" << endl;
    }
};

int main() {
    Базовый* объект = new Производный();
    объект->вывести(); // Виртуальная функция вызовет метод производного класса
    delete объект;
    return 0;
}

Вывод:

Производный класс

---

42. Команда: static

Определение: static используется для создания статических переменных или методов, которые сохраняют свое состояние между вызовами функций или экземплярами классов.

Пример кода:

#include <iostream>

class Счётчик {
private:
    static int счётчик; // Статическая переменная

public:
    Счётчик() {
        счётчик++;
    }

    static void вывести() {
        cout << "Количество объектов: " << счётчик << endl;
    }
};

int Счётчик::счётчик = 0; // Инициализация статической переменной

int main() {
    Счётчик obj1;
    Счётчик obj2;
    Счётчик::вывести(); // Вызов статического метода
    return 0;
}

Вывод:

Количество объектов: 2

---

43. Команда: enum

Определение: enum — перечисление, которое используется для создания набора именованных целочисленных констант.

Пример кода:

#include <iostream>

enum ДеньНедели { Понедельник = 1, Вторник, Среда, Четверг, Пятница, Суббота, Воскресенье };

int main() {
    ДеньНедели сегодня = Понедельник;
    cout << "Сегодня: " << сегодня << endl; // Понедельник = 1
    return 0;
}

Вывод:

Сегодня: 1

---

44. Команда: struct

Определение: struct — ключевое слово для объявления структуры, которая позволяет объединить разные типы данных в одну единицу.

Пример кода:

#include <iostream>

struct Человек {
    std::string имя;
    int возраст;
};

int main() {
    Человек человек = {"Иван", 25};
    cout << "Имя: " << человек.имя << ", Возраст: " << человек.возраст << endl;
    return 0;
}

Вывод:

Имя: Иван, Возраст: 25

---

45. Команда: class

Определение: class используется для объявления класса. Классы в C++ служат для описания объектов, содержащих как данные, так и функции для работы с ними.

Пример кода:

#include <iostream>

class Круг {
private:
    double радиус;

public:
    Круг(double r) : радиус(r) {}

    double площадь() {
        return 3.14159 * радиус * радиус;
    }
};

int main() {
    Круг круг(5);
    cout << "Площадь круга: " << круг.площадь() << endl;
    return 0;
}

Вывод:

Площадь круга: 78.53975

---

46. Команда: public, private, protected

Определение: public, private и protected — спецификаторы доступа, которые определяют видимость и доступность членов класса.

• public: члены класса доступны извне.

• private: члены класса недоступны извне.

• protected: члены класса доступны только в производных классах.

Пример кода:

#include <iostream>

class Класс {
public:
    int публичный_член;

private:
    int приватный_член;

protected:
    int защищённый_член;
};

int main() {
    Класс объект;
    объект.публичный_член = 10;
    cout << "Публичный член: " << объект.публичный_член << endl;

    // объект.приватный_член = 5; // Ошибка! Приватные члены недоступны
    // объект.защищённый_член = 3; // Ошибка! Защищённые члены недоступны

    return 0;
}

Вывод:

Публичный член: 10

---

47. Команда: operator

Определение: operator используется для перегрузки операторов в C++, чтобы изменить их поведение для объектов пользовательских типов данных.

Пример кода:

#include <iostream>

class Комплекс {
private:
    int реальная_часть;
    int мнимая_часть;

public:
    Комплекс(int x, int y) : реальная_часть(x), мнимая_часть(y) {}

    Комплекс operator + (const Комплекс& другой) {
        return Комплекс(реальная_часть + другой.реальная_часть, мнимая_часть + другой.мнимая_часть);
    }

    void вывести() {
        cout << реальная_часть << " + " << мнимая_часть << "i" << endl;
    }
};

int main() {
    Комплекс num1(1, 2), num2(3, 4);
    Комплекс result = num1 + num2;
    result.вывести();
    return 0;
}

Вывод:

4 + 6i

---

48. Команда: virtual и override

Определение: virtual используется в базовом классе для объявления виртуальной функции, а override в производном классе для переопределения этой функции.

Пример кода:

#include <iostream>

class Базовый {
public:
    virtual void вывести() {
        cout << "Базовый класс" << endl;
    }
};

class Производный : public Базовый {
public:
    void вывести() override {
        cout << "Производный класс" << endl;
    }
};

int main() {
    Базовый* объект = new Производный();
    объект->вывести(); // Виртуальная функция вызовет метод производного класса
    delete объект;
    return 0;
}

Вывод:

Производный класс

---

49. Команда: try, catch, throw

Определение: try, catch, throw — это механизмы обработки исключений. throw используется для выброса исключений, try — для попытки выполнения кода, а catch — для перехвата исключений.

Пример кода:

#include <iostream>

void разделить(int a, int b) {
    if (b == 0) {
        throw std::invalid_argument("Деление на ноль!");
    }
    cout << "Результат: " << a / b << endl;
}

int main() {
    try {
        разделить(10, 0);
    } catch (const std::invalid_argument& e) {
        cout << "Ошибка: " << e.what() << endl;
    }
    return 0;
}

Вывод:

Ошибка: Деление на ноль!

---

50. Команда: namespace

Определение: namespace используется для организации кода в пространства имен, что позволяет избегать конфликтов имен между различными частями программы.

Пример кода:

#include <iostream>

namespace Математика {
    int сложить(int a, int b) {
        return a + b;
    }
}

int main() {
    cout << "Результат сложения: " << Математика::сложить(3, 4) << endl;
    return 0;
}

Вывод:

Результат сложения: 7

---

51. Команда: mutable

Определение: mutable позволяет изменять переменную внутри константных методов, т.е. она будет изменяема, даже если объект класса является константным.

Пример кода:

#include <iostream>

class Пример {
private:
    mutable int число;  // mutable переменная
public:
    Пример(int x) : число(x) {}

    void изменить() const {
        число = 20;  // Можно изменить даже в константном методе
    }

    void вывести() const {
        cout << "Число: " << число << endl;
    }
};

int main() {
    Пример obj(10);
    obj.вывести();  // Число: 10
    obj.изменить(); // Изменили переменную в константном методе
    obj.вывести();  // Число: 20
    return 0;
}

Вывод:

Число: 10  
Число: 20

---

52. Команда: template

Определение: template используется для создания обобщенных функций или классов, которые могут работать с любыми типами данных.

Пример кода:

#include <iostream>

template <typename T>
T сложить(T a, T b) {
    return a + b;
}

int main() {
    cout << "Результат сложения целых чисел: " << сложить(3, 4) << endl;
    cout << "Результат сложения с плавающей точкой: " << сложить(3.5, 4.2) << endl;
    return 0;
}

Вывод:

Результат сложения целых чисел: 7
Результат сложения с плавающей точкой: 7.7

---

53. Команда: typedef / using

Определение: typedef или using позволяют создать псевдоним для типов данных, улучшая читаемость кода.

Пример кода:

#include <iostream>

typedef unsigned long long целое_число; // Создание псевдонима

int main() {
    целое_число число = 1000000000; // Используем псевдоним
    cout << "Число: " << число << endl;
    return 0;
}

Вывод:

Число: 1000000000

---

54. Команда: const

Определение: const используется для объявления констант, значение которых нельзя изменить после их инициализации.

Пример кода:

#include <iostream>

int main() {
    const int число = 10;
    cout << "Число: " << число << endl;

    // Следующие строки вызовут ошибку компиляции
    // число = 20; // Ошибка: попытка изменения константы

    return 0;
}

Вывод:

Число: 10

---

55. Команда: alignas и alignof

Определение: alignas и alignof используются для работы с выравниванием памяти в C++. alignas позволяет установить выравнивание для переменной, а alignof — получить выравнивание для типа.

Пример кода:

#include <iostream>
#include <cstddef> // Для alignof

alignas(16) int число; // Выравнивание переменной на 16 байт

int main() {
    cout << "Выравнивание типа int: " << alignof(int) << endl;
    cout << "Выравнивание переменной число: " << alignof(decltype(число)) << endl;
    return 0;
}

Вывод:

Выравнивание типа int: 4  
Выравнивание переменной число: 16

---

56. Команда: nullptr

Определение: nullptr — это специальный тип указателя, который используется для явного указания нулевого указателя.

Пример кода:

#include <iostream>

int main() {
    int* указатель = nullptr;  // Инициализация нулевым указателем

    if (указатель == nullptr) {
        cout << "Указатель не указывает на память." << endl;
    }

    return 0;
}

Вывод:

Указатель не указывает на память.

---

57. Команда: decltype

Определение: decltype используется для получения типа переменной или выражения, не вычисляя его.

Пример кода:

#include <iostream>

int main() {
    int число = 5;
    decltype(число) переменная = 10; // Переменная будет того же типа, что и число

    cout << "Переменная: " << переменная << endl;
    return 0;
}

Вывод:

Переменная: 10

---

58. Команда: inline

Определение: inline используется для предложения компилятору вставить код функции напрямую в место вызова, тем самым ускоряя выполнение (но с увеличением размера кода).

Пример кода:

#include <iostream>

inline int квадрат(int x) {
    return x * x;
}

int main() {
    cout << "Квадрат числа 5: " << квадрат(5) << endl;
    return 0;
}

Вывод:

Квадрат числа 5: 25

---

59. Команда: auto

Определение: auto позволяет компилятору автоматически определять тип переменной на основе её инициализатора.

Пример кода:

#include <iostream>

int main() {
    auto число = 10; // Тип переменной auto будет int
    auto дробь = 3.14; // Тип переменной auto будет double

    cout << "Число: " << число << ", Дробь: " << дробь << endl;
    return 0;
}

Вывод:

Число: 10, Дробь: 3.14

---

60. Команда: constexpr

Определение: constexpr указывает, что значение переменной или результат функции должно быть вычислено на этапе компиляции.

Пример кода:

#include <iostream>

constexpr int квадрат(int x) {
    return x * x;
}

int main() {
    constexpr int число = 5;
    cout << "Квадрат числа 5: " << квадрат(число) << endl;
    return 0;
}

Вывод:

Квадрат числа 5: 25

---

61. Команда: explicit

Определение: explicit используется для предотвращения неявных преобразований типов при передаче аргументов в конструкторы.

Пример кода:

#include <iostream>

class Число {
public:
    explicit Число(int x) {
        std::cout << "Конструктор с аргументом: " << x << std::endl;
    }
};

int main() {
    Число число1(10); // Явное использование конструктора
    // Число число2 = 20; // Ошибка: невозможно неявное преобразование

    return 0;
}

Вывод:

Конструктор с аргументом: 10

---

62. Команда: default

Определение: default используется для указания дефолтного конструктора, оператора присваивания или других операций, если они не определены вручную.

Пример кода:

#include <iostream>

class Пример {
public:
    int значение;

    Пример() = default; // Использование дефолтного конструктора
};

int main() {
    Пример obj;
    obj.значение = 10;
    cout << "Значение: " << obj.значение << endl;
    return 0;
}

Вывод:

Значение: 10

---

63. Команда: noexcept

Определение: noexcept указывает, что функция не генерирует исключений.

Пример кода:

#include <iostream>

void функция() noexcept { // Функция не выбрасывает исключений
    std::cout << "Функция без исключений!" << std::endl;
}

int main() {
    функция();
    return 0;
}

Вывод:

Функция без исключений!