From e40fa018978932d5c95fd9c45f1c1dfad63f2b80 Mon Sep 17 00:00:00 2001 From: Ivan Khokhlov Date: Sat, 15 Nov 2025 09:32:08 +0000 Subject: [PATCH 1/2] feat add course plan --- doc/README.md | 84 ++++++++++++++- doc/lesson_01.md | 94 +++++++++++++++++ doc/lesson_02.md | 140 +++++++++++++++++++++++++ doc/lesson_03.md | 94 +++++++++++++++++ doc/lesson_04.md | 202 +++++++++++++++++++++++++++++++++++ doc/lesson_05.md | 209 +++++++++++++++++++++++++++++++++++++ doc/lesson_06.md | 97 +++++++++++++++++ doc/lesson_07.md | 242 ++++++++++++++++++++++++++++++++++++++++++ doc/lesson_08.md | 216 ++++++++++++++++++++++++++++++++++++++ doc/lesson_09.md | 108 +++++++++++++++++++ doc/lesson_10.md | 266 +++++++++++++++++++++++++++++++++++++++++++++++ doc/lesson_11.md | 135 ++++++++++++++++++++++++ 12 files changed, 1886 insertions(+), 1 deletion(-) create mode 100644 doc/lesson_01.md create mode 100644 doc/lesson_02.md create mode 100644 doc/lesson_03.md create mode 100644 doc/lesson_04.md create mode 100644 doc/lesson_05.md create mode 100644 doc/lesson_06.md create mode 100644 doc/lesson_07.md create mode 100644 doc/lesson_08.md create mode 100644 doc/lesson_09.md create mode 100644 doc/lesson_10.md create mode 100644 doc/lesson_11.md diff --git a/doc/README.md b/doc/README.md index 1f8fb8a..df3441f 100644 --- a/doc/README.md +++ b/doc/README.md @@ -1 +1,83 @@ -# Теория +# Документация курса по C++ + +Добро пожаловать в документацию курса по программированию на C++! + +## Структура курса + +Курс состоит из **11 занятий**, каждое занятие длится **2 пары** (4 академических часа). Из них примерно **1/3 (4 занятия)** - практические занятия. + +### Теоретические занятия + +1. [Занятие 1: Введение в C++](lesson_01.md) - 2 пары +2. [Занятие 2: Базовые типы данных и переменные](lesson_02.md) - 2 пары +3. [Занятие 4: Функции и указатели](lesson_04.md) - 2 пары +4. [Занятие 5: Массивы и строки](lesson_05.md) - 2 пары +5. [Занятие 7: Управление потоком выполнения](lesson_07.md) - 2 пары +6. [Занятие 8: Динамическая память](lesson_08.md) - 2 пары +7. [Занятие 10: Структуры и классы](lesson_10.md) - 2 пары + +### Практические занятия + +1. [Занятие 3: Практика 1 - Работа с переменными и типами данных](lesson_03.md) - 2 пары +2. [Занятие 6: Практика 2 - Функции и массивы](lesson_06.md) - 2 пары +3. [Занятие 9: Практика 3 - Алгоритмы и структуры данных](lesson_09.md) - 2 пары +4. [Занятие 11: Практика 4 - Объектно-ориентированное программирование](lesson_11.md) - 2 пары + +## Программа курса + +### Блок 1: Основы C++ (Занятия 1-5) +- Введение в язык (2 пары) +- Типы данных и переменные (2 пары) +- **Практика 1** (2 пары) +- Функции и указатели (2 пары) +- Массивы и строки (2 пары) + +### Блок 2: Управление и память (Занятия 6-9) +- **Практика 2** (2 пары) +- Управление потоком выполнения (2 пары) +- Динамическая память (2 пары) +- **Практика 3** (2 пары) + +### Блок 3: Объектно-ориентированное программирование (Занятия 10-11) +- Структуры и классы (2 пары) +- **Практика 4** (2 пары) + +## Структура занятий + +Каждое занятие состоит из **2 пар** (4 академических часа): +- **Пара 1** - первая часть материала +- **Пара 2** - вторая часть материала и практика + +## Как пользоваться документацией + +1. Изучайте теоретические занятия последовательно +2. Каждое занятие рассчитано на 2 пары - планируйте время соответственно +3. После каждого блока выполняйте практическое занятие +4. Решайте домашние задания из каждого урока +5. Используйте дополнительные материалы для углубленного изучения + +## Дополнительные ресурсы + +- [cppreference.com](https://en.cppreference.com/) - справочник по C++ +- [C++ Core Guidelines](https://isocpp.github.io/CppCoreGuidelines/) - рекомендации по написанию кода +- [Learn C++](https://www.learncpp.com/) - интерактивный учебник + +## Форматирование кода + +Весь код в курсе должен быть отформатирован с помощью `clang-format` со стилем Google. + +```bash +clang-format -i --style=Google *.cpp *.h +``` + +## Структура проекта + +- `task_XX/` - домашние задания +- `sandbox/` - примеры и шаблоны +- `additional_tasks/` - дополнительные задачи +- `lib/` - общие утилиты +- `doc/` - документация курса + +## Лицензия + +См. файл [LICENSE](../LICENSE) в корне проекта. diff --git a/doc/lesson_01.md b/doc/lesson_01.md new file mode 100644 index 0000000..c571e2a --- /dev/null +++ b/doc/lesson_01.md @@ -0,0 +1,94 @@ +# Занятие 1: Введение в C++ + +**Длительность:** 2 пары (4 академических часа) + +## Цели занятия +- Познакомиться с языком C++ и его историей +- Понять основные отличия C++ от других языков программирования +- Настроить среду разработки +- Написать первую программу на C++ + +--- + +## Пара 1: Основы C++ + +### Теоретический материал + +### Что такое C++? +C++ — это компилируемый язык программирования общего назначения, созданный Бьярном Страуструпом как расширение языка C. + +### Основные особенности C++ +- Объектно-ориентированное программирование +- Шаблоны (templates) +- Управление памятью +- Производительность +- Многопарадигменность + +### Первая программа + +```cpp +#include + +int main() { + std::cout << "Hello, World!" << std::endl; + return 0; +} +``` + +### Компиляция и запуск +```bash +g++ -o program main.cpp +./program +``` + +--- + +## Пара 2: Первая программа и компиляция + +### Практическая работа + +#### Установка среды разработки +- Установка компилятора (GCC/Clang) +- Настройка IDE (VS Code, CLion, или другой) +- Проверка установки: `g++ --version` + +#### Первая программа +```cpp +#include + +int main() { + std::cout << "Hello, World!" << std::endl; + std::cout << "Меня зовут [Ваше имя]" << std::endl; + return 0; +} +``` + +#### Компиляция и запуск +```bash +# Компиляция +g++ -o hello hello.cpp + +# Запуск +./hello + +# Компиляция с предупреждениями +g++ -Wall -Wextra -o hello hello.cpp +``` + +#### Структура программы на C++ +- Директивы препроцессора (`#include`) +- Функция `main()` - точка входа +- Пространства имен (`std::`) +- Операторы ввода/вывода (`std::cout`, `std::cin`) + +### Домашнее задание +- Настроить среду разработки (компилятор, IDE) +- Написать программу, которая выводит ваше имя и группу +- Изучить базовые типы данных в C++ +- Написать программу, которая запрашивает имя пользователя и выводит приветствие + +### Дополнительные материалы +- [cppreference.com](https://en.cppreference.com/) +- Документация по компилятору GCC/Clang +- Основы работы с командной строкой + diff --git a/doc/lesson_02.md b/doc/lesson_02.md new file mode 100644 index 0000000..9fff28f --- /dev/null +++ b/doc/lesson_02.md @@ -0,0 +1,140 @@ +# Занятие 2: Базовые типы данных и переменные + +**Длительность:** 2 пары (4 академических часа) + +## Цели занятия +- Изучить основные типы данных в C++ +- Понять разницу между различными типами +- Научиться объявлять и инициализировать переменные +- Познакомиться с константами + +--- + +## Пара 1: Типы данных + +### Теоретический материал + +### Основные типы данных + +#### Целочисленные типы +- `int` - целое число (обычно 32 бита) +- `short` - короткое целое (обычно 16 бит) +- `long` - длинное целое (обычно 32 или 64 бита) +- `long long` - очень длинное целое (обычно 64 бита) +- `char` - символ (обычно 8 бит) + +#### Типы с плавающей точкой +- `float` - число с плавающей точкой одинарной точности +- `double` - число с плавающей точкой двойной точности +- `long double` - расширенная точность + +#### Логический тип +- `bool` - логическое значение (true/false) + +### Объявление и инициализация переменных + +```cpp +int x; // Объявление +int y = 10; // Инициализация +int z{20}; // Uniform initialization (C++11) +auto a = 5; // Автоматическое определение типа +``` + +### Константы + +```cpp +const int MAX_SIZE = 100; +constexpr int BUFFER_SIZE = 256; // Константа времени компиляции +``` + +### Размеры типов +```cpp +#include +#include + +std::cout << "Size of int: " << sizeof(int) << " bytes" << std::endl; +std::cout << "Max int value: " << std::numeric_limits::max() << std::endl; +``` + +--- + +## Пара 2: Переменные и константы + +### Теоретический материал + +#### Объявление и инициализация переменных + +```cpp +// Различные способы инициализации +int a; // Неинициализированная переменная (не рекомендуется) +int b = 10; // Копирующая инициализация +int c(20); // Прямая инициализация +int d{30}; // Uniform initialization (C++11, рекомендуется) +int e = {40}; // Uniform initialization с = + +// Автоматическое определение типа +auto x = 5; // int +auto y = 3.14; // double +auto z = 'A'; // char +``` + +#### Константы + +```cpp +// const - константа времени выполнения +const int MAX_SIZE = 100; +const double PI = 3.14159; + +// constexpr - константа времени компиляции (C++11) +constexpr int BUFFER_SIZE = 256; +constexpr int SQUARE(int x) { return x * x; } +constexpr int area = SQUARE(10); // Вычисляется на этапе компиляции +``` + +#### Модификаторы типов + +```cpp +// signed и unsigned +signed int si = -10; // Может быть отрицательным +unsigned int ui = 10; // Только положительные значения + +// short и long +short s = 100; +long l = 1000000L; +long long ll = 1000000000LL; + +// const и volatile +const int read_only = 42; +volatile int sensor_value; // Может изменяться извне +``` + +#### Практические примеры + +```cpp +#include +#include + +int main() { + // Размеры типов + std::cout << "Size of int: " << sizeof(int) << " bytes" << std::endl; + std::cout << "Size of double: " << sizeof(double) << " bytes" << std::endl; + + // Предельные значения + std::cout << "Max int: " << std::numeric_limits::max() << std::endl; + std::cout << "Min int: " << std::numeric_limits::min() << std::endl; + + return 0; +} +``` + +### Домашнее задание +- Изучить размеры различных типов данных на вашей системе +- Написать программу, демонстрирующую переполнение переменных +- Познакомиться с модификаторами `signed` и `unsigned` +- Создать программу для конвертации между различными целочисленными типами + +### Дополнительные материалы +- Стандарт C++: типы данных +- Проблемы переполнения и неопределенного поведения +- Выравнивание данных в памяти + diff --git a/doc/lesson_03.md b/doc/lesson_03.md new file mode 100644 index 0000000..9ef2d70 --- /dev/null +++ b/doc/lesson_03.md @@ -0,0 +1,94 @@ +# Занятие 3: Практика 1 - Работа с переменными и типами данных + +**Длительность:** 2 пары (4 академических часа) + +## Цели занятия +- Закрепить знания о типах данных +- Научиться решать практические задачи +- Потренироваться в написании простых программ + +--- + +## Пара 1: Базовые задачи + +### Практические задания + +### Задание 1: Калькулятор базовых операций +Напишите программу, которая: +- Принимает два числа от пользователя +- Выполняет операции: сложение, вычитание, умножение, деление +- Выводит результаты с правильными типами данных + +### Задание 2: Конвертер единиц измерения +Создайте программу для конвертации: +- Температуры (Цельсий ↔ Фаренгейт) +- Длины (метры ↔ футы) +- Массы (килограммы ↔ фунты) + +### Задание 3: Анализ чисел +Напишите программу, которая: +- Принимает число от пользователя +- Определяет, является ли оно четным/нечетным +- Определяет знак числа (положительное/отрицательное/ноль) +- Вычисляет абсолютное значение + +### Задание 4: Работа с символами +Создайте программу, которая: +- Принимает символ от пользователя +- Определяет, является ли он буквой, цифрой или специальным символом +- Если это буква, определяет регистр (верхний/нижний) +- Выводит ASCII код символа + +## Рекомендации +- Используйте правильные типы данных для каждой задачи +- Обрабатывайте возможные ошибки (деление на ноль, переполнение) +- Комментируйте свой код +- Форматируйте вывод для читаемости + +--- + +## Пара 2: Продвинутые задачи + +### Практические задания + +#### Задание 5: Калькулятор с проверкой типов +Создайте программу, которая: +- Принимает два числа разных типов (int и double) +- Выполняет все арифметические операции +- Демонстрирует потерю точности при преобразовании типов +- Выводит результаты с указанием типов + +#### Задание 6: Анализ диапазонов +Напишите программу, которая: +- Запрашивает у пользователя тип данных (char, int, long, float, double) +- Выводит минимальное и максимальное значение для этого типа +- Показывает размер типа в байтах +- Демонстрирует переполнение для выбранного типа + +#### Задание 7: Работа с константами +Создайте программу, использующую: +- `const` переменные для хранения конфигурации +- `constexpr` для вычислений на этапе компиляции +- Демонстрацию разницы между `const` и `constexpr` + +#### Задание 8: Система единиц измерения +Реализуйте программу для работы с единицами измерения: +- Хранение значений в различных единицах (метры, километры, мили) +- Конвертация между единицами +- Использование правильных типов данных (float/double) +- Обработка точности вычислений + +### Рекомендации +- Используйте правильные типы данных для каждой задачи +- Обрабатывайте возможные ошибки (деление на ноль, переполнение) +- Комментируйте свой код +- Форматируйте вывод для читаемости +- Проверяйте граничные случаи + +### Критерии оценки +- Корректность работы программы +- Правильное использование типов данных +- Обработка граничных случаев +- Читаемость кода +- Правильная работа с константами + diff --git a/doc/lesson_04.md b/doc/lesson_04.md new file mode 100644 index 0000000..4b21e6c --- /dev/null +++ b/doc/lesson_04.md @@ -0,0 +1,202 @@ +# Занятие 4: Функции и указатели + +**Длительность:** 2 пары (4 академических часа) + +## Цели занятия +- Изучить синтаксис объявления и определения функций +- Понять механизм передачи параметров +- Освоить работу с указателями +- Изучить ссылки (references) + +--- + +## Пара 1: Функции + +### Теоретический материал + +### Объявление и определение функций + +```cpp +// Объявление (прототип) +int add(int a, int b); + +// Определение +int add(int a, int b) { + return a + b; +} +``` + +### Передача параметров + +#### По значению +```cpp +void modify(int x) { + x = 100; // Не изменяет оригинальную переменную +} +``` + +#### По указателю +```cpp +void modify(int* x) { + *x = 100; // Изменяет оригинальную переменную +} + +int value = 10; +modify(&value); // value теперь равен 100 +``` + +#### По ссылке +```cpp +void modify(int& x) { + x = 100; // Изменяет оригинальную переменную +} + +int value = 10; +modify(value); // value теперь равен 100 +``` + +### Указатели + +```cpp +int x = 10; +int* ptr = &x; // ptr указывает на x +int value = *ptr; // Разыменование: value = 10 +*ptr = 20; // x теперь равен 20 +``` + +### Ссылки + +```cpp +int x = 10; +int& ref = x; // ref - это псевдоним для x +ref = 20; // x теперь равен 20 +``` + +### Разница между указателями и ссылками +- Указатель может быть `nullptr`, ссылка - нет +- Указатель можно переназначить, ссылку - нет +- Указатель требует явного разыменования, ссылка - нет + +--- + +## Пара 2: Указатели и ссылки + +### Теоретический материал + +#### Работа с указателями + +```cpp +int x = 10; +int* ptr = &x; // ptr хранит адрес x +int value = *ptr; // Разыменование: получаем значение +*ptr = 20; // Изменяем значение через указатель + +// Указатель на указатель +int** pptr = &ptr; +int val = **pptr; // Двойное разыменование +``` + +#### Арифметика указателей + +```cpp +int arr[5] = {1, 2, 3, 4, 5}; +int* p = arr; // p указывает на arr[0] +p++; // p теперь указывает на arr[1] +p += 2; // p теперь указывает на arr[3] +int diff = p - arr; // Разница в индексах: 3 +``` + +#### Указатель nullptr + +```cpp +int* ptr = nullptr; // Современный способ (C++11) +// int* ptr = NULL; // Устаревший способ + +if (ptr != nullptr) { + *ptr = 10; +} +``` + +#### Ссылки (references) + +```cpp +int x = 10; +int& ref = x; // ref - это псевдоним для x +ref = 20; // x теперь равен 20 + +// Ссылка не может быть переназначена +int y = 30; +// ref = y; // Это присваивание, а не переназначение +// int& ref2; // ОШИБКА! Ссылка должна быть инициализирована +``` + +#### Ссылки как параметры функций + +```cpp +void swap(int& a, int& b) { + int temp = a; + a = b; + b = temp; +} + +int x = 10, y = 20; +swap(x, y); // x = 20, y = 10 +``` + +#### Константные ссылки + +```cpp +void print(const int& value) { + // value нельзя изменить + std::cout << value << std::endl; +} + +// Эффективно для больших объектов +void process(const std::string& str) { + // str передается по ссылке, но не копируется +} +``` + +### Практические примеры + +```cpp +// Функция обмена значений +void swap(int* a, int* b) { + int temp = *a; + *a = *b; + *b = temp; +} + +// Или через ссылки +void swap(int& a, int& b) { + int temp = a; + a = b; + b = temp; +} + +// Функция возвращающая указатель +int* findMax(int arr[], int size) { + if (size == 0) return nullptr; + + int* max = arr; + for (int i = 1; i < size; ++i) { + if (arr[i] > *max) { + max = arr + i; + } + } + return max; +} +``` + +### Домашнее задание +- Реализовать функцию для обмена значений двух переменных (через указатели и ссылки) +- Написать функцию, которая принимает массив и его размер, возвращает указатель на максимальный элемент +- Изучить разницу между передачей по значению, указателю и ссылке +- Создать функцию, которая принимает указатель на функцию как параметр + +### Дополнительные материалы +- Указатели на функции +- Функции с переменным числом аргументов +- Перегрузка функций +- Умные указатели (введение) + diff --git a/doc/lesson_05.md b/doc/lesson_05.md new file mode 100644 index 0000000..f4bb9a5 --- /dev/null +++ b/doc/lesson_05.md @@ -0,0 +1,209 @@ +# Занятие 5: Массивы и строки + +**Длительность:** 2 пары (4 академических часа) + +## Цели занятия +- Изучить работу с массивами +- Понять разницу между массивами и указателями +- Освоить работу со строками C-style +- Познакомиться с std::string + +--- + +## Пара 1: Массивы + +### Теоретический материал + +### Массивы + +#### Объявление и инициализация +```cpp +int arr[5]; // Объявление массива из 5 элементов +int arr2[5] = {1, 2, 3, 4, 5}; // Инициализация +int arr3[] = {1, 2, 3}; // Автоматический размер +``` + +#### Доступ к элементам +```cpp +arr[0] = 10; // Первый элемент +int x = arr[2]; // Третий элемент +int size = sizeof(arr) / sizeof(arr[0]); // Размер массива +``` + +#### Передача массива в функцию +```cpp +void printArray(int arr[], int size) { + for (int i = 0; i < size; ++i) { + std::cout << arr[i] << " "; + } +} + +// Или с указателем +void printArray(int* arr, int size) { + // ... +} +``` + +### Строки C-style + +```cpp +char str1[] = "Hello"; // Массив символов +char str2[10] = "World"; // С фиксированным размером +const char* str3 = "C++"; // Указатель на строковый литерал + +// Функции для работы со строками +#include +strlen(str1); // Длина строки +strcpy(dest, src); // Копирование +strcat(dest, src); // Конкатенация +strcmp(str1, str2); // Сравнение +``` + +### std::string (C++) + +```cpp +#include + +std::string str = "Hello"; +str += " World"; // Конкатенация +int len = str.length(); // Длина +str[0] = 'h'; // Доступ к символам +std::string substr = str.substr(0, 5); // Подстрока +``` + +--- + +## Пара 2: Строки + +### Теоретический материал + +#### Строки C-style (продолжение) + +```cpp +#include + +char str1[20] = "Hello"; +char str2[20] = "World"; + +// Сравнение +if (strcmp(str1, str2) == 0) { + // Строки равны +} else if (strcmp(str1, str2) < 0) { + // str1 меньше str2 +} + +// Безопасное копирование +char dest[20]; +strncpy(dest, str1, sizeof(dest) - 1); +dest[sizeof(dest) - 1] = '\0'; // Гарантируем нулевой терминатор + +// Безопасная конкатенация +strncat(dest, str2, sizeof(dest) - strlen(dest) - 1); +``` + +#### std::string (C++) + +```cpp +#include +#include + +std::string str = "Hello"; +str += " World"; // Конкатенация +str.append("!"); // Добавление в конец + +// Размер и емкость +int len = str.length(); // или str.size() +int cap = str.capacity(); + +// Доступ к символам +char c = str[0]; // Без проверки границ +char c2 = str.at(0); // С проверкой границ + +// Поиск +size_t pos = str.find("World"); // Поиск подстроки +if (pos != std::string::npos) { + std::cout << "Найдено на позиции " << pos << std::endl; +} + +// Подстрока +std::string substr = str.substr(0, 5); // "Hello" + +// Замена +str.replace(0, 5, "Hi"); // Замена "Hello" на "Hi" + +// Вставка +str.insert(2, "XX"); // Вставка в позицию 2 + +// Удаление +str.erase(0, 2); // Удаление первых 2 символов +``` + +#### Преобразование между C-string и std::string + +```cpp +// Из C-string в std::string +const char* cstr = "Hello"; +std::string str(cstr); + +// Из std::string в C-string +const char* ptr = str.c_str(); // Не изменяйте строку после этого! +char* data = str.data(); // C++17 + +// Копирование в буфер +char buffer[100]; +str.copy(buffer, sizeof(buffer) - 1); +buffer[sizeof(buffer) - 1] = '\0'; +``` + +#### Строковые потоки + +```cpp +#include + +// Преобразование числа в строку +int num = 42; +std::stringstream ss; +ss << num; +std::string str = ss.str(); + +// Или в C++11 +std::string str2 = std::to_string(num); + +// Преобразование строки в число +std::string numStr = "123"; +int value = std::stoi(numStr); // string to int +double d = std::stod("3.14"); // string to double +``` + +### Практические примеры + +```cpp +// Функция для работы с C-string +void processString(char* str) { + int len = strlen(str); + for (int i = 0; i < len; ++i) { + if (str[i] >= 'a' && str[i] <= 'z') { + str[i] = str[i] - 'a' + 'A'; // Преобразование в верхний регистр + } + } +} + +// Функция для работы с std::string +std::string reverseString(const std::string& str) { + return std::string(str.rbegin(), str.rend()); +} +``` + +### Домашнее задание +- Реализовать функцию поиска максимума в массиве +- Написать функцию для инверсии массива +- Создать программу для работы со строками (подсчет слов, поиск подстроки) +- Реализовать функции для преобразования между различными форматами строк +- Написать программу для работы с многострочным текстом + +### Дополнительные материалы +- Многомерные массивы +- Динамические массивы +- Строковые потоки (stringstream) +- Регулярные выражения (regex, C++11) + diff --git a/doc/lesson_06.md b/doc/lesson_06.md new file mode 100644 index 0000000..3b47884 --- /dev/null +++ b/doc/lesson_06.md @@ -0,0 +1,97 @@ +# Занятие 6: Практика 2 - Функции и массивы + +**Длительность:** 2 пары (4 академических часа) + +## Цели занятия +- Закрепить навыки работы с функциями +- Практиковаться в работе с массивами +- Решать задачи на алгоритмы + +--- + +## Пара 1: Базовые задачи + +### Практические задания + +### Задание 1: Поиск максимума +Создайте функцию, которая принимает указатель на массив целых чисел и его размер, и возвращает максимальное значение в массиве. + +**Файл:** `task_02` + +### Задание 2: Инверсия массива +Создайте функцию, которая принимает указатель на массив целых чисел и его размер, и инвертирует порядок его элементов (первый элемент становится последним, второй предпоследним и т.д.). + +**Файл:** `task_03` + +### Задание 3: Сдвиг элементов +Создайте функцию, которая принимает указатель на массив целых чисел, его размер, и целое число N. Функция должна сдвинуть все элементы массива на N позиций вправо, чтобы первые элементы стали последними. Элементы, которые "выталкиваются" из массива, должны появиться с левой стороны. + +**Файл:** `task_04` + +### Задание 4: Поиск медианы +Напишите функцию, которая возвращает медиану из 3 чисел. + +**Файл:** `task_01` + +### Задание 5: Работа со строками +Создайте программу, которая: +- Принимает строку от пользователя +- Подсчитывает количество слов +- Находит самое длинное слово +- Переворачивает строку + +## Рекомендации +- Используйте правильные типы параметров (указатели/ссылки) +- Проверяйте граничные случаи (пустой массив, nullptr) +- Пишите тесты для ваших функций +- Документируйте функции + +--- + +## Пара 2: Продвинутые задачи + +### Практические задания + +#### Задание 6: Функции для работы со строками +Создайте набор функций для работы со строками: +- Функция подсчета количества слов в строке +- Функция поиска самого длинного слова +- Функция переворота строки +- Функция проверки, является ли строка палиндромом +- Функция удаления всех пробелов из строки + +#### Задание 7: Многомерные массивы +Реализуйте функции для работы с двумерными массивами: +- Функция заполнения матрицы случайными числами +- Функция вывода матрицы +- Функция транспонирования матрицы +- Функция поиска максимального элемента и его координат + +#### Задание 8: Массивы структур +Создайте структуру `Student` и функции для работы с массивом студентов: +- Структура: имя, возраст, средний балл +- Функция поиска студента с максимальным баллом +- Функция сортировки студентов по баллу +- Функция подсчета студентов с баллом выше заданного + +#### Задание 9: Указатели на функции +Используйте указатели на функции для: +- Создания функции сортировки, которая принимает функцию сравнения +- Реализации функции `map` для применения функции к каждому элементу массива +- Создания функции фильтрации массива по условию + +### Рекомендации +- Используйте правильные типы параметров (указатели/ссылки) +- Проверяйте граничные случаи (пустой массив, nullptr) +- Пишите тесты для ваших функций +- Документируйте функции +- Используйте const где возможно + +### Критерии оценки +- Корректность реализации алгоритмов +- Правильная работа с памятью +- Обработка ошибок +- Наличие тестов +- Эффективность алгоритмов +- Качество кода и документация + diff --git a/doc/lesson_07.md b/doc/lesson_07.md new file mode 100644 index 0000000..d5e32d5 --- /dev/null +++ b/doc/lesson_07.md @@ -0,0 +1,242 @@ +# Занятие 7: Управление потоком выполнения + +**Длительность:** 2 пары (4 академических часа) + +## Цели занятия +- Изучить условные операторы +- Освоить циклы (for, while, do-while) +- Понять операторы break и continue +- Изучить switch-case + +--- + +## Пара 1: Условные операторы и switch + +### Теоретический материал + +### Условные операторы + +#### if-else +```cpp +if (condition) { + // код +} else if (another_condition) { + // код +} else { + // код +} +``` + +#### Тернарный оператор +```cpp +int max = (a > b) ? a : b; +``` + +#### switch-case +```cpp +switch (value) { + case 1: + // код + break; + case 2: + case 3: + // код для 2 и 3 + break; + default: + // код по умолчанию +} +``` + +### Циклы + +#### for +```cpp +for (int i = 0; i < 10; ++i) { + std::cout << i << std::endl; +} + +// Range-based for (C++11) +int arr[] = {1, 2, 3, 4, 5}; +for (int x : arr) { + std::cout << x << std::endl; +} +``` + +#### while +```cpp +while (condition) { + // код +} +``` + +#### do-while +```cpp +do { + // код выполнится хотя бы один раз +} while (condition); +``` + +### Операторы управления циклом + +```cpp +for (int i = 0; i < 10; ++i) { + if (i == 5) { + continue; // Пропустить оставшуюся часть итерации + } + if (i == 8) { + break; // Выйти из цикла + } + std::cout << i << std::endl; +} +``` + +### Вложенные циклы +```cpp +for (int i = 0; i < 3; ++i) { + for (int j = 0; j < 3; ++j) { + std::cout << i << "," << j << " "; + } + std::cout << std::endl; +} +``` + +--- + +## Пара 2: Циклы + +### Теоретический материал + +#### Цикл for (продолжение) + +```cpp +// Цикл с несколькими переменными +for (int i = 0, j = 10; i < 10; ++i, --j) { + std::cout << i << " " << j << std::endl; +} + +// Цикл без инициализации +int i = 0; +for (; i < 10; ++i) { + // ... +} + +// Бесконечный цикл +for (;;) { + // код + if (condition) break; +} +``` + +#### Range-based for (C++11) + +```cpp +// Для массивов +int arr[] = {1, 2, 3, 4, 5}; +for (int x : arr) { + std::cout << x << " "; +} + +// Для std::string +std::string str = "Hello"; +for (char c : str) { + std::cout << c << " "; +} + +// С ссылкой (для изменения) +for (int& x : arr) { + x *= 2; // Удваиваем каждый элемент +} + +// С auto +for (auto& x : arr) { + std::cout << x << " "; +} +``` + +#### Вложенные циклы и примеры + +```cpp +// Таблица умножения +for (int i = 1; i <= 10; ++i) { + for (int j = 1; j <= 10; ++j) { + std::cout << i * j << "\t"; + } + std::cout << std::endl; +} + +// Поиск в двумерном массиве +bool found = false; +for (int i = 0; i < rows && !found; ++i) { + for (int j = 0; j < cols; ++j) { + if (matrix[i][j] == target) { + found = true; + break; // Выход из внутреннего цикла + } + } +} +``` + +#### Практические паттерны + +```cpp +// Подсчет элементов +int count = 0; +for (int i = 0; i < size; ++i) { + if (arr[i] > threshold) { + count++; + } +} + +// Поиск максимума +int max = arr[0]; +for (int i = 1; i < size; ++i) { + if (arr[i] > max) { + max = arr[i]; + } +} + +// Сумма элементов +int sum = 0; +for (int i = 0; i < size; ++i) { + sum += arr[i]; +} +``` + +### Практические примеры + +```cpp +// Меню с использованием switch +int choice; +do { + std::cout << "1. Опция 1\n2. Опция 2\n3. Выход\n"; + std::cin >> choice; + + switch (choice) { + case 1: + // Действие 1 + break; + case 2: + // Действие 2 + break; + case 3: + std::cout << "Выход..." << std::endl; + break; + default: + std::cout << "Неверный выбор!" << std::endl; + } +} while (choice != 3); +``` + +### Домашнее задание +- Реализовать различные алгоритмы с использованием циклов (поиск, сортировка, фильтрация) +- Написать программу с вложенными циклами (вывод паттернов, работа с матрицами) +- Использовать switch для создания интерактивного меню +- Создать программу-калькулятор с циклом и меню операций +- Реализовать игру "Угадай число" с использованием циклов + +### Дополнительные материалы +- Оптимизация циклов +- Бесконечные циклы и их использование +- Метки и goto (не рекомендуется) +- Идиомы C++ для работы с коллекциями + diff --git a/doc/lesson_08.md b/doc/lesson_08.md new file mode 100644 index 0000000..605852a --- /dev/null +++ b/doc/lesson_08.md @@ -0,0 +1,216 @@ +# Занятие 8: Динамическая память + +**Длительность:** 2 пары (4 академических часа) + +## Цели занятия +- Изучить работу с динамической памятью +- Понять операторы new и delete +- Освоить работу с динамическими массивами +- Изучить утечки памяти и как их избегать + +--- + +## Пара 1: Операторы new и delete + +### Теоретический материал + +### Операторы new и delete + +#### Выделение памяти для одного объекта +```cpp +int* ptr = new int; // Выделение памяти +*ptr = 42; // Использование +delete ptr; // Освобождение памяти +ptr = nullptr; // Хорошая практика +``` + +#### Выделение памяти для массива +```cpp +int* arr = new int[10]; // Массив из 10 элементов +// Использование массива +delete[] arr; // Освобождение памяти для массива +arr = nullptr; +``` + +### Инициализация при выделении памяти +```cpp +int* ptr = new int(42); // Инициализация значением +int* arr = new int[5]{1,2,3,4,5}; // Инициализация массива (C++11) +``` + +### Проблемы с динамической памятью + +#### Утечка памяти +```cpp +void leak() { + int* ptr = new int[100]; + // Забыли вызвать delete[] + // Память утекла! +} +``` + +#### Двойное освобождение +```cpp +int* ptr = new int; +delete ptr; +delete ptr; // ОШИБКА! Двойное освобождение +``` + +#### Использование после освобождения +```cpp +int* ptr = new int; +delete ptr; +*ptr = 10; // ОШИБКА! Использование после освобождения +``` + +### Умные указатели (C++11, краткое введение) +```cpp +#include + +std::unique_ptr ptr = std::make_unique(42); +// Память автоматически освободится при выходе из области видимости +``` + +--- + +## Пара 2: Работа с динамическими массивами и отладка + +### Теоретический материал + +#### Динамические массивы + +```cpp +// Выделение памяти для массива +int size = 10; +int* arr = new int[size]; + +// Инициализация +int* arr2 = new int[size]{1, 2, 3}; // Остальные элементы = 0 + +// Использование +for (int i = 0; i < size; ++i) { + arr[i] = i * 2; +} + +// Освобождение памяти +delete[] arr; +arr = nullptr; // Хорошая практика +``` + +#### Изменение размера массива + +```cpp +// Создание нового массива большего размера +int* oldArr = new int[5]; +// ... заполнение oldArr ... + +int newSize = 10; +int* newArr = new int[newSize]; + +// Копирование данных +for (int i = 0; i < 5; ++i) { + newArr[i] = oldArr[i]; +} + +// Освобождение старого массива +delete[] oldArr; +oldArr = newArr; +``` + +#### Двумерные динамические массивы + +```cpp +int rows = 3, cols = 4; + +// Способ 1: Массив указателей +int** matrix = new int*[rows]; +for (int i = 0; i < rows; ++i) { + matrix[i] = new int[cols]; +} + +// Использование +matrix[0][0] = 10; + +// Освобождение +for (int i = 0; i < rows; ++i) { + delete[] matrix[i]; +} +delete[] matrix; + +// Способ 2: Один массив (более эффективно) +int* matrix2 = new int[rows * cols]; +// Доступ: matrix2[i * cols + j] = value; +delete[] matrix2; +``` + +#### Проверка выделения памяти + +```cpp +int* ptr = new (std::nothrow) int[1000]; +if (ptr == nullptr) { + std::cerr << "Не удалось выделить память!" << std::endl; + return; +} +// Использование ptr +delete[] ptr; +``` + +#### Отладка утечек памяти + +```cpp +// Использование valgrind +// valgrind --leak-check=full ./program + +// Использование AddressSanitizer (компиляция) +// g++ -fsanitize=address -g program.cpp +``` + +### Практические примеры + +```cpp +// Функция создания динамического массива +int* createArray(int size) { + int* arr = new int[size]; + return arr; +} + +// Функция удаления массива +void deleteArray(int* arr) { + delete[] arr; +} + +// Класс для управления динамическим массивом +class DynamicArray { +private: + int* data; + int size; + +public: + DynamicArray(int s) : size(s) { + data = new int[size]; + } + + ~DynamicArray() { + delete[] data; + } + + // Запрет копирования (пока) + DynamicArray(const DynamicArray&) = delete; + DynamicArray& operator=(const DynamicArray&) = delete; +}; +``` + +### Домашнее задание +- Реализовать динамический массив с функциями добавления/удаления элементов +- Написать программу, которая работает с динамической памятью без утечек +- Изучить инструменты для обнаружения утечек памяти (valgrind, AddressSanitizer) +- Создать класс для управления динамическим массивом +- Реализовать функции для работы с динамическими матрицами + +### Дополнительные материалы +- Умные указатели (unique_ptr, shared_ptr, weak_ptr) +- RAII (Resource Acquisition Is Initialization) +- Инструменты для отладки памяти +- Placement new +- Аллокаторы памяти + diff --git a/doc/lesson_09.md b/doc/lesson_09.md new file mode 100644 index 0000000..966c6c6 --- /dev/null +++ b/doc/lesson_09.md @@ -0,0 +1,108 @@ +# Занятие 9: Практика 3 - Алгоритмы и структуры данных + +**Длительность:** 2 пары (4 академических часа) + +## Цели занятия +- Реализовать базовые алгоритмы +- Работать с динамической памятью +- Решать задачи на массивы и строки + +--- + +## Пара 1: Алгоритмы сортировки и поиска + +### Практические задания + +### Задание 1: Динамический массив +Реализуйте класс или набор функций для работы с динамическим массивом: +- Создание массива заданного размера +- Добавление элемента в конец +- Удаление элемента по индексу +- Вставка элемента по индексу +- Поиск элемента +- Освобождение памяти + +### Задание 2: Сортировка +Реализуйте функции сортировки: +- Пузырьковая сортировка +- Сортировка выбором +- Быстрая сортировка (опционально) + +### Задание 3: Поиск +Реализуйте алгоритмы поиска: +- Линейный поиск +- Бинарный поиск (для отсортированного массива) + +### Задание 4: Работа со строками +Создайте программу для: +- Подсчета частоты символов в строке +- Удаления дубликатов символов +- Проверки, является ли строка палиндромом +- Поиска подстроки в строке + +### Задание 5: Матрицы +Реализуйте функции для работы с матрицами: +- Создание матрицы (динамическое выделение памяти) +- Транспонирование +- Умножение матриц +- Освобождение памяти + +## Рекомендации +- Всегда проверяйте выделение памяти (new может вернуть nullptr в старых стандартах) +- Используйте delete[] для массивов, delete для одиночных объектов +- Проверяйте граничные случаи +- Пишите тесты для всех функций +- Используйте valgrind для проверки утечек памяти + +--- + +## Пара 2: Динамические структуры данных + +### Практические задания + +#### Задание 6: Динамический стек +Реализуйте класс `Stack` для работы со стеком: +- Динамическое выделение памяти +- Методы: `push()`, `pop()`, `top()`, `isEmpty()`, `size()` +- Автоматическое увеличение размера при необходимости +- Конструктор, деструктор, конструктор копирования +- Оператор присваивания + +#### Задание 7: Динамическая очередь +Создайте класс `Queue`: +- Кольцевой буфер для эффективности +- Методы: `enqueue()`, `dequeue()`, `front()`, `isEmpty()`, `size()` +- Автоматическое расширение при переполнении +- Правильное управление памятью + +#### Задание 8: Динамический список +Реализуйте простой односвязный список: +- Структура `Node` для хранения данных и указателя +- Методы: `insert()`, `remove()`, `find()`, `size()` +- Правильное освобождение памяти +- Итерация по списку + +#### Задание 9: Работа с матрицами +Реализуйте класс `Matrix` для работы с динамическими матрицами: +- Выделение и освобождение памяти +- Конструкторы (по умолчанию, с параметрами, копирования) +- Методы: `get()`, `set()`, `transpose()`, `multiply()` +- Операторы `[]` для доступа к строкам +- Деструктор для освобождения памяти + +### Рекомендации +- Всегда проверяйте выделение памяти +- Используйте delete[] для массивов, delete для одиночных объектов +- Проверяйте граничные случаи +- Пишите тесты для всех функций +- Используйте valgrind для проверки утечек памяти +- Думайте об эффективности алгоритмов + +### Критерии оценки +- Корректность алгоритмов +- Отсутствие утечек памяти +- Обработка ошибок +- Эффективность алгоритмов +- Качество кода и документация +- Правильная работа конструкторов и деструкторов + diff --git a/doc/lesson_10.md b/doc/lesson_10.md new file mode 100644 index 0000000..3993465 --- /dev/null +++ b/doc/lesson_10.md @@ -0,0 +1,266 @@ +# Занятие 10: Структуры и классы + +**Длительность:** 2 пары (4 академических часа) + +## Цели занятия +- Изучить структуры (struct) и объединения (union) +- Понять перечисления (enum) +- Освоить основы классов и объектов +- Изучить конструкторы и деструкторы + +--- + +## Пара 1: Структуры, объединения и перечисления + +### Теоретический материал + +### Структуры (struct) + +#### Объявление и использование +```cpp +struct Point { + int x; + int y; +}; + +Point p; +p.x = 10; +p.y = 20; + +// Инициализация +Point p2 = {5, 15}; +Point p3{3, 7}; // Uniform initialization (C++11) +``` + +#### Структуры с функциями +```cpp +struct Rectangle { + int width; + int height; + + int area() { + return width * height; + } + + void setSize(int w, int h) { + width = w; + height = h; + } +}; + +Rectangle rect; +rect.setSize(10, 20); +int a = rect.area(); +``` + +#### Указатели на структуры +```cpp +Point* ptr = &p; +ptr->x = 100; // Доступ через указатель +(*ptr).y = 200; // Альтернативный синтаксис +``` + +### Объединения (union) +```cpp +union Data { + int i; + float f; + char c; +}; + +Data d; +d.i = 42; +// Теперь можно использовать d.f или d.c +// Но только одно значение актуально в каждый момент +``` + +### Перечисления (enum) +```cpp +enum Color { + RED, + GREEN, + BLUE +}; + +Color c = RED; + +// Enum class (C++11, типобезопасный) +enum class Status { + OK, + ERROR, + PENDING +}; + +Status s = Status::OK; +``` + +### Вложенные структуры +```cpp +struct Address { + std::string street; + std::string city; + int zipCode; +}; + +struct Person { + std::string name; + int age; + Address address; +}; +``` + +--- + +## Пара 2: Классы и объекты + +### Теоретический материал + +#### Классы vs Структуры + +В C++ классы и структуры почти идентичны. Разница только в модификаторе доступа по умолчанию: +- `struct` - по умолчанию `public` +- `class` - по умолчанию `private` + +#### Базовый класс + +```cpp +class Rectangle { +private: + int width; + int height; + +public: + // Конструктор + Rectangle(int w, int h) : width(w), height(h) {} + + // Методы + int getArea() const { + return width * height; + } + + void setWidth(int w) { + width = w; + } + + void setHeight(int h) { + height = h; + } + + int getWidth() const { return width; } + int getHeight() const { return height; } +}; +``` + +#### Конструкторы + +```cpp +class Point { + int x, y; + +public: + // Конструктор по умолчанию + Point() : x(0), y(0) {} + + // Конструктор с параметрами + Point(int x, int y) : x(x), y(y) {} + + // Конструктор копирования + Point(const Point& other) : x(other.x), y(other.y) {} + + // Делегирующий конструктор (C++11) + Point(int value) : Point(value, value) {} +}; +``` + +#### Деструктор + +```cpp +class Resource { + int* data; + int size; + +public: + Resource(int s) : size(s) { + data = new int[size]; + } + + // Деструктор + ~Resource() { + delete[] data; + std::cout << "Ресурс освобожден" << std::endl; + } +}; +``` + +#### Модификаторы доступа +- `private` - доступ только внутри класса +- `protected` - доступ внутри класса и в наследниках +- `public` - публичный доступ + +#### Константные методы +```cpp +class MyClass { + int value; +public: + int getValue() const { // Не изменяет объект + return value; + } + + void setValue(int v) { // Может изменять объект + value = v; + } +}; +``` + +#### Инициализация членов класса + +```cpp +class Example { + int a; + int b; + const int c; + +public: + // Список инициализации + Example(int x, int y) : a(x), b(y), c(100) { + // Тело конструктора + } +}; +``` + +### Практические примеры + +```cpp +// Класс для работы с комплексными числами +class Complex { +private: + double real; + double imag; + +public: + Complex(double r = 0.0, double i = 0.0) : real(r), imag(i) {} + + Complex add(const Complex& other) const { + return Complex(real + other.real, imag + other.imag); + } + + void print() const { + std::cout << real << " + " << imag << "i" << std::endl; + } +}; +``` + +### Домашнее задание +- Создать структуру для представления студента с функциями +- Реализовать класс для работы с комплексными числами +- Создать класс `BankAccount` с методами пополнения и снятия +- Использовать перечисления для статусов +- Работать с массивами объектов + +### Дополнительные материалы +- Размер структур и выравнивание (alignment) +- Битовые поля +- Анонимные структуры и объединения +- Правило трех (Rule of Three) +- Статические члены класса + diff --git a/doc/lesson_11.md b/doc/lesson_11.md new file mode 100644 index 0000000..1baada9 --- /dev/null +++ b/doc/lesson_11.md @@ -0,0 +1,135 @@ +# Занятие 11: Практика 4 - Объектно-ориентированное программирование + +**Длительность:** 2 пары (4 академических часа) + +## Цели занятия +- Создавать классы для решения практических задач +- Использовать конструкторы и деструкторы +- Применять принципы инкапсуляции +- Работать с объектами и наследованием + +--- + +## Пара 1: Классы и инкапсуляция + +### Практические задания + +#### Задание 1: Класс "Студент" +Создайте класс `Student` со следующими возможностями: +- Хранение имени, фамилии, возраста +- Хранение оценок (динамический массив) +- Методы для добавления оценки +- Метод для вычисления среднего балла +- Конструкторы (по умолчанию, с параметрами, копирования) +- Деструктор +- Метод для вывода информации о студенте + +#### Задание 2: Класс "Банковский счет" +Реализуйте класс `BankAccount`: +- Хранение номера счета и баланса +- Методы для пополнения и снятия средств +- Проверка баланса +- Защита от отрицательного баланса +- Логирование операций +- Конструкторы и деструктор + +#### Задание 3: Класс "Вектор" +Создайте класс `Vector` для работы с математическими векторами: +- Хранение координат (x, y, z) +- Конструкторы (по умолчанию, с параметрами, копирования) +- Методы для вычисления длины вектора +- Методы для нормализации вектора +- Операции сложения и вычитания векторов (как методы) +- Скалярное произведение + +--- + +## Пара 2: Наследование и полиморфизм + +### Теоретический материал (кратко) + +#### Наследование + +```cpp +// Базовый класс +class Shape { +protected: + int x, y; +public: + Shape(int x, int y) : x(x), y(y) {} + virtual void draw() { + std::cout << "Drawing shape" << std::endl; + } + virtual ~Shape() {} +}; + +// Производный класс +class Circle : public Shape { + int radius; +public: + Circle(int x, int y, int r) : Shape(x, y), radius(r) {} + + void draw() override { + std::cout << "Drawing circle at (" << x << ", " << y + << ") with radius " << radius << std::endl; + } +}; +``` + +#### Виртуальные функции + +```cpp +Shape* shape = new Circle(10, 20, 5); +shape->draw(); // Вызовется Circle::draw() благодаря virtual +delete shape; // Вызовется правильный деструктор +``` + +### Практические задания + +#### Задание 4: Иерархия фигур +Создайте иерархию классов для геометрических фигур: +- Базовый класс `Shape` с виртуальными методами: + - `area()` - вычисление площади + - `perimeter()` - вычисление периметра + - `draw()` - вывод информации о фигуре +- Производные классы: + - `Circle` (радиус) + - `Rectangle` (ширина, высота) + - `Triangle` (три стороны) +- Создайте массив указателей на `Shape` и продемонстрируйте полиморфизм + +#### Задание 5: Система сотрудников +Реализуйте систему для управления сотрудниками компании: +- Базовый класс `Employee`: + - Имя, ID, зарплата + - Виртуальный метод `calculateSalary()` + - Виртуальный метод `getInfo()` +- Производные классы: + - `Manager` (бонус) + - `Developer` (часы работы, ставка) + - `SalesPerson` (процент от продаж) +- Создайте функцию для вывода информации о всех сотрудниках + +#### Задание 6: Перегрузка операторов +Для класса `Vector` из задания 3: +- Перегрузите операторы `+`, `-`, `*` (скалярное произведение) +- Перегрузите операторы `+=`, `-=` +- Перегрузите операторы ввода/вывода `<<` и `>>` +- Перегрузите оператор `[]` для доступа к координатам + +### Рекомендации +- Всегда используйте виртуальный деструктор в базовом классе +- Используйте `override` для явного указания переопределения +- Применяйте `const` где возможно +- Думайте о расширяемости системы +- Используйте умные указатели для управления памятью (если изучены) +- Правильно освобождайте память в деструкторах + +### Критерии оценки +- Правильная иерархия классов +- Корректное использование виртуальных функций +- Демонстрация полиморфизма +- Отсутствие утечек памяти +- Качество дизайна и архитектуры +- Правильная работа конструкторов и деструкторов +- Корректная перегрузка операторов From 3ba0b16764eb14ba7f9578e54066684f255b1ecd Mon Sep 17 00:00:00 2001 From: Ivan Khokhlov Date: Sat, 15 Nov 2025 09:38:16 +0000 Subject: [PATCH 2/2] add additional materials --- doc/README.md | 101 ++++++++++++++++++++++++++++++++++++++++++++++++-- 1 file changed, 97 insertions(+), 4 deletions(-) diff --git a/doc/README.md b/doc/README.md index df3441f..4d3585e 100644 --- a/doc/README.md +++ b/doc/README.md @@ -56,11 +56,104 @@ 4. Решайте домашние задания из каждого урока 5. Используйте дополнительные материалы для углубленного изучения -## Дополнительные ресурсы +## Дополнительные материалы -- [cppreference.com](https://en.cppreference.com/) - справочник по C++ -- [C++ Core Guidelines](https://isocpp.github.io/CppCoreGuidelines/) - рекомендации по написанию кода -- [Learn C++](https://www.learncpp.com/) - интерактивный учебник +### Онлайн-ресурсы и документация + +#### Справочники и документация +- [cppreference.com](https://en.cppreference.com/) - полный справочник по C++ стандартной библиотеке +- [C++ Reference](https://www.cplusplus.com/reference/) - альтернативный справочник с примерами +- [cppreference.com (русская версия)](https://ru.cppreference.com/) - русскоязычная версия справочника +- [C++ Standards](https://isocpp.org/std/the-standard) - официальные стандарты C++ + +#### Учебные материалы +- [Learn C++](https://www.learncpp.com/) - интерактивный учебник с примерами +- [C++ Tutorial](https://www.tutorialspoint.com/cplusplus/) - пошаговые уроки +- [C++ Language Tutorial](http://www.cplusplus.com/doc/tutorial/) - базовый туториал +- [GeeksforGeeks C++](https://www.geeksforgeeks.org/c-plus-plus/) - статьи и примеры кода + +#### Рекомендации и best practices +- [C++ Core Guidelines](https://isocpp.github.io/CppCoreGuidelines/) - рекомендации по написанию кода от создателей C++ +- [Google C++ Style Guide](https://google.github.io/styleguide/cppguide.html) - стиль кодирования Google +- [C++ Best Practices](https://github.com/cpp-best-practices/cppbestpractices) - коллекция лучших практик + +### Инструменты разработки + +#### Компиляторы +- [GCC (GNU Compiler Collection)](https://gcc.gnu.org/) - свободный компилятор +- [Clang](https://clang.llvm.org/) - компилятор на базе LLVM +- [Microsoft Visual C++](https://visualstudio.microsoft.com/vs/features/cplusplus/) - компилятор от Microsoft + +#### IDE и редакторы +- [Visual Studio Code](https://code.visualstudio.com/) - легковесный редактор с поддержкой C++ + +#### Инструменты отладки и анализа +- [Valgrind](https://valgrind.org/) - инструмент для обнаружения утечек памяти +- [AddressSanitizer](https://github.com/google/sanitizers/wiki/AddressSanitizer) - обнаружение ошибок памяти +- [GDB](https://www.gnu.org/software/gdb/) - отладчик GNU +- [cppcheck](http://cppcheck.sourceforge.net/) - статический анализатор кода + +#### Системы сборки +- [CMake](https://cmake.org/) - кроссплатформенная система сборки +- [Make](https://www.gnu.org/software/make/) - классическая система сборки +- [Ninja](https://ninja-build.org/) - быстрая система сборки + +### Книги + +#### Для начинающих +- "Язык программирования C++" - Бьярн Страуструп +- "C++ Primer" - Стэнли Липпман, Жози Лажойе, Барбара Му +- "Программирование: принципы и практика с использованием C++" - Бьярн Страуструп + +#### Продвинутые темы +- "Эффективный и современный C++" - Скотт Мейерс +- "C++ Concurrency in Action" - Энтони Уильямс (многопоточность) +- "The C++ Programming Language" - Бьярн Страуструп (полное руководство) + +### Видео-курсы и лекции + +- [C++ Programming Course](https://www.youtube.com/results?search_query=c%2B%2B+programming+course) - различные курсы на YouTube +- [CppCon](https://www.youtube.com/user/CppCon) - конференция по C++ с записями докладов +- [C++ Weekly](https://www.youtube.com/c/lefticus1) - еженедельные видео о C++ + +### Сообщества и форумы + +- [Stack Overflow](https://stackoverflow.com/questions/tagged/c%2B%2B) - вопросы и ответы по C++ +- [Reddit r/cpp](https://www.reddit.com/r/cpp/) - сообщество на Reddit +- [C++ Forum](https://cplusplus.com/forum/) - форум для обсуждения C++ +- [Habr C++](https://habr.com/ru/hub/cpp/) - статьи на русском языке + +### Практика и задачи + +- [LeetCode](https://leetcode.com/) - задачи по алгоритмам и структурам данных +- [HackerRank C++](https://www.hackerrank.com/domains/cpp) - задачи по программированию +- [Codeforces](https://codeforces.com/) - соревнования по программированию +- [Project Euler](https://projecteuler.net/) - математические задачи для программирования + +### Полезные библиотеки + +- [Boost](https://www.boost.org/) - набор библиотек для C++ +- [STL](https://en.cppreference.com/w/cpp/header) - стандартная библиотека шаблонов +- [Qt](https://www.qt.io/) - фреймворк для разработки приложений +- [SFML](https://www.sfml-dev.org/) - библиотека для мультимедиа и игр + +### Онлайн-компиляторы + +- [Compiler Explorer](https://godbolt.org/) - интерактивный компилятор с анализом кода +- [OnlineGDB](https://www.onlinegdb.com/online_c++_compiler) - онлайн компилятор с отладчиком +- [Repl.it](https://replit.com/languages/cpp) - онлайн IDE для C++ + +### Дополнительные темы для изучения + +#### После базового курса +- Шаблоны (templates) и метапрограммирование +- STL контейнеры и алгоритмы +- Умные указатели (smart pointers) +- Многопоточность (threading) +- Лямбда-выражения и функциональное программирование +- Move-семантика и rvalue references +- RAII и управление ресурсами +- Исключения (exceptions) и обработка ошибок ## Форматирование кода