Архитектура консольного приложения на C++: Разработка расширяемого меню с управлением из файла на основе паттернов проектирования и стандартов C++17/20

В эпоху доминирования графических пользовательских интерфейсов (GUI) может показаться, что консольные приложения (CLI) отходят на второй план. Однако, вопреки этому впечатлению, консольные интерфейсы остаются краеугольным камнем для огромного числа задач: от системного администрирования и автоматизации процессов до разработки высокопроизводительных утилит и инструментов. Их легковесность, скорость запуска и минимальные требования к ресурсам делают их незаменимыми в серверной разработке, встраиваемых системах и при создании утилит, требующих высокой степени контроля над выполнением. Актуальность такого рода разработок подкрепляется и тем, что консольные приложения часто служат основой для тестирования логики, предваряя создание более сложных графических оболочек. Это позволяет разработчикам сосредоточиться на функциональности, прежде чем тратить время на создание визуальных элементов.

Целью данной курсовой работы является разработка архитектурно обоснованного консольного приложения на языке C++, функционал которого будет представлен в виде динамически формируемого меню, управляемого из внешнего конфигурационного файла. Это позволит не только продемонстрировать глубокое понимание современных стандартов языка C++ (начиная с C++17), но и применить принципы объектно-ориентированного проектирования и поведенческие паттерны для создания гибкого, расширяемого и легко модифицируемого программного продукта.

Для достижения поставленной цели перед нами стоят следующие задачи:

1. Теоретический анализ: Изучить фундаментальные принципы объектно-ориентированного программирования (ООП) и принципы SOLID, с особым акцентом на Принцип Открытости/Закрытости (OCP).
2. Архитектурное проектирование: Обосновать выбор и детально проработать применение паттернов проектирования Command и State для управления действиями и навигацией в меню, а также рассмотреть адаптацию архитектуры MVC для консольных приложений.
3. Использование современных стандартов C++: Продемонстрировать эффективное применение библиотеки std::filesystem для работы с файловой системой и std::regex для структурированного парсинга данных из файла.
4. Кросс-платформенная реализация: Разработать подход к кросс-платформенному управлению консолью и вводом/выводом, используя ANSI Escape Sequences и слой абстракции для скрытия платформо-специфичных деталей.
5. Анализ производительности: Провести глубокий анализ производительности, используя академические метрики (латентность, джиттер, перцентили) и оценивая влияние компиляторной оптимизации и локальности данных.

Структура работы отражает последовательность решения этих задач: от общих теоретических положений и архитектурных решений к конкретной реализации и детальному анализу производительности. Такой подход позволит создать не просто рабочее приложение, но и проиллюстрировать комплексный, инженерный взгляд на процесс разработки программного обеспечения, что является важным для формирования компетенций современного специалиста.

Теоретические Основы и Принципы Архитектурного Проектирования

В основе создания любой надежной и расширяемой системы лежит не только знание синтаксиса языка, но и глубокое понимание фундаментальных принципов проектирования. Для консольного приложения, особенно с динамической структурой меню, эти принципы становятся критически важными, обеспечивая его гибкость и долговечность.

Объектно-ориентированная парадигма и ее роль в C++

Объектно-ориентированное программирование (ООП) — это парадигма, которая организует программное обеспечение вокруг «объектов» (сущностей), а не «действий» (функций и логики). В C++ ООП является краеугольным камнем, предоставляя мощные механизмы для моделирования реального мира. Четыре столпа ООП — Абстракция, Инкапсуляция, Наследование и Полиморфизм — играют ключевую роль в создании систем меню.

Абстракция позволяет выделить существенные характеристики объекта, скрывая несущественные детали реализации. В контексте меню, абстрактным может быть понятие «пункта меню», который может быть как простым действием, так и подменю, не вдаваясь в детали его конкретной функциональности.

Инкапсуляция объединяет данные (атрибуты) и методы (поведение), работающие с этими данными, в единый объект, скрывая внутреннее состояние от внешнего мира и предоставляя контролируемый доступ к нему через публичный интерфейс. Для пункта меню это означает, что его название, описание и связанное с ним действие будут инкапсулированы внутри класса MenuItem, а внешние пользователи смогут лишь вызывать метод execute() или display(), не зная, как именно они реализованы.

Наследование позволяет создавать новые классы (производные) на основе существующих (базовых), перенимая их свойства и поведение. Это эффективно для создания иерархии меню: например, базовый класс MenuItem может иметь производные классы ActionMenuItem (для выполнения конкретного действия) и SubMenu (для перехода в другое подменю).

Полиморфизм (от греч. «много форм») — это способность объектов разных классов отвечать на одно и то же сообщение (вызов метода) по-разному, в зависимости от их типа. В C++ полиморфизм реализуется, как правило, через иерархию классов, связанных наследованием, и использование виртуальных функций (ключевое слово virtual). Когда метод в базовом классе объявляется virtual, это позволяет вызывать правильную реализацию метода для производного класса через указатель или ссылку на базовый класс. Этот механизм называется поздним связыванием (или динамической диспетчеризацией). Например, если у нас есть указатель на базовый MenuItem*, и мы вызываем item->execute(), то благодаря виртуальной функции execute() будет вызвана та реализация, которая соответствует фактическому типу объекта, на который указывает item (будь то ActionMenuItem или SubMenu). Это критически важно для гибкости меню, позволяя единообразно обрабатывать пункты различных типов, что значительно упрощает расширение функционала.

Принципы SOLID: Фокус на Принципе Открытости/Закрытости (OCP)

Принципы SOLID — это пять фундаментальных принципов объектно-ориентированного проектирования, сформулированные Робертом С. Мартином (Uncle Bob), которые помогают создавать гибкое, расширяемое и легко поддерживаемое программное обеспечение. В контексте системы меню особенно важен Принцип Открытости/Закрытости (Open/Closed Principle, OCP).

OCP гласит: программные сущности (классы, модули, функции) должны быть открыты для расширения, но закрыты для изменений. Это означает, что при добавлении нового функционала не следует модифицировать существующий, уже протестированный код. Вместо этого, новый функционал должен быть добавлен путем расширения системы, например, через создание новых классов или модулей.

Для системы меню это имеет огромное значение. Представим, что у нас есть консольное меню, и нам нужно добавить новый пункт, который выполняет совершенно новое действие. Без OCP нам пришлось бы изменять существующий код, например, вносить изменения в массив или список пунктов меню, а также в логику обработки выбора. Это не только увеличивает риск внесения ошибок в уже работающий код, но и затрудняет тестирование и поддержку. Отсутствие OCP приводит к «эффекту домино», когда одно изменение вызывает каскад других изменений, увеличивая стоимость разработки и сопровождения.

Как обеспечить OCP в C++? Фундаментальность принципов SOLID, и OCP в частности, в контексте C++ достигается за счет использования абстрактных базовых классов и полиморфизма. Абстрактный базовый класс, такой как MenuCommand или MenuItem, определяет общий интерфейс (набор виртуальных функций), но не реализует его полностью. Конкретные действия или пункты меню реализуются в производных классах (FileOpenCommand, ExitCommand).

Конкретная реализация Принципа Открытости/Закрытости в С++ предполагает, что поведение модуля может быть расширено (например, добавлением нового класса, реализующего интерфейс MenuCommand), но его исходный код (.cpp и .h с абстракциями) остается неизменным. Это позволяет добавлять новые пункты меню или изменять их функционал, создавая новые ConcreteCommand классы без модификации класса, управляющего меню, или его Invoker. Таким образом, система меню становится не только гибкой, но и устойчивой к изменениям, что является ключевым для долгосрочной поддержки и развития проекта. Разве не это идеальный подход к созданию масштабируемых систем?

Паттерны Проектирования для Гибкой Структуры Меню

Разработка интерактивных систем, таких как консольное меню, требует тщательного подхода к архитектуре, чтобы обеспечить гибкость, расширяемость и чистоту кода. Паттерны проектирования, особенно поведенческие, предоставляют проверенные решения для разделения ответственности и управления взаимодействием между объектами.

Паттерн Command: Инкапсуляция действия

Паттерн Command (Команда) — это поведенческий паттерн проектирования, который инкапсулирует запрос (действие) как объект, что позволяет параметризовать объекты-получатели (Receiver), откладывать или ставить в очередь выполнение запросов (например, для реализации макросов или истории команд) и поддерживать операции отмены (Undo/Redo). Этот паттерн идеально подходит для системы меню, где каждый пункт представляет собой определенное действие.

Ключевые компоненты паттерна Command:

1. Command Interface (Интерфейс Команды): Абстрактный класс или интерфейс, объявляющий метод для выполнения операции. Обычно это метод execute().

class Command {
public:
    virtual ~Command() = default;
    virtual void execute() = 0;
    // virtual void undo() = 0; // Для поддержки отмены
};

2. ConcreteCommand (Конкретная Команда): Реализует интерфейс Command и связывает действие с объектом Receiver. Обычно хранит ссылку на Receiver и, при необходимости, параметры для вызова метода Receiver‘а.

class OpenFileCommand : public Command {
private:
    FileManager* fileManager; // Receiver
    std::string filename;
public:
    OpenFileCommand(FileManager* fm, const std::string& name)
        : fileManager(fm), filename(name) {}
    void execute() override {
        fileManager->open(filename);
    }
};

3. Receiver (Получатель): Объект, который выполняет фактическую бизнес-логику, связанную с командой. Он знает, как выполнить операцию. В нашем примере это FileManager.

class FileManager {
public:
    void open(const std::string& filename) {
        std::cout << "Opening file: " << filename << std::endl;
        // Логика открытия файла
    }
    // ... другие методы
};

4. Invoker (Инициатор): Объект, который запрашивает выполнение команды. Он хранит объект Command и, когда приходит время, вызывает его метод execute(). В контексте меню, Invoker‘ом может быть сам пункт меню или класс, управляющий выбором.

class MenuItem {
private:
    std::string title;
    std::unique_ptr<Command> command;
public:
    MenuItem(const std::string& t, std::unique_ptr<Command> cmd)
        : title(t), command(std::move(cmd)) {}
    void select() {
        if (command) {
            command->execute();
        }
    }
    const std::string& getTitle() const { return title; }
};

Применение паттерна Command позволяет реализовать историю действий и, как следствие, операцию отмены (Undo) в консольном приложении. Для этого каждая ConcreteCommand должна хранить достаточно информации, чтобы отменить свое действие, и предоставлять метод undo(). Invoker (или специальный менеджер истории) может хранить стек выполненных команд для последовательной отмены.

Паттерн State: Управление навигацией в многоуровневом меню

Для реализации сложной навигации в многоуровневом консольном меню, где переход между подменю представляет собой изменение контекста, идеально подходит паттерн State (Состояние). Этот паттерн позволяет объекту изменять свое поведение при изменении его внутреннего состояния. Внешне объект будет выглядеть так, как будто он изменил свой класс.

Ключевые компоненты паттерна State, применимые для создания конечных автоматов меню:

1. Context (Контекст): Класс, который содержит ссылку на текущее состояние и делегирует ему запросы. В контексте меню, Context‘ом может быть основной класс MenuManager, который управляет текущим активным меню/подменю.

class MenuManager; // Forward declaration

class MenuState {
public:
    virtual ~MenuState() = default;
    virtual void display(MenuManager* context) = 0;
    virtual void handleInput(MenuManager* context, char input) = 0;
};

class MenuManager {
private:
    std::unique_ptr<MenuState> currentState;
public:
    MenuManager(std::unique_ptr<MenuState> initialState)
        : currentState(std::move(initialState)) {}

    void changeState(std::unique_ptr<MenuState> newState) {
        currentState = std::move(newState);
    }

    void displayCurrentMenu() {
        if (currentState) currentState->display(this);
    }

    void processInput(char input) {
        if (currentState) currentState->handleInput(this, input);
    }
};

2. State Interface (Интерфейс Состояния): Абстрактный класс, объявляющий методы для всех действий/событий, которые могут происходить в различных состояниях. В нашем случае это MenuState с методами display() и handleInput().
3. Concrete State (Конкретное Состояние): Реализует логику, специфичную для конкретного подменю, и может инициировать переход Context в другое состояние. Например, MainMenuState, OptionsMenuState, HelpMenuState.

class MainMenuState : public MenuState {
public:
    void display(MenuManager* context) override {
        std::cout << "--- Main Menu ---" << std::endl;
        std::cout << "1. Options" << std::endl;
        std::cout << "2. Exit" << std::endl;
    }

    void handleInput(MenuManager* context, char input) override {
        if (input == '1') {
            context->changeState(std::make_unique<OptionsMenuState>());
        } else if (input == '2') {
            // ... логика выхода
        }
    }
};

Этот паттерн обеспечивает чистую и расширяемую навигацию, позволяя добавлять новые подменю (новые ConcreteState классы) без изменения логики в MenuManager. Каждый ConcreteState сам знает, как он должен отображаться и какие переходы возможны из него, эффективно реализуя конечный автомат (FSM) для меню. Такой подход позволяет легко управлять сложным поведением, избегая громоздких условных конструкций.

Адаптация MVC-архитектуры для Консольного Интерфейса

Архитектурный паттерн Model-View-Controller (MVC) является фундаментальным для разработки пользовательских интерфейсов. Хотя он чаще используется в графических приложениях, его принципы могут быть успешно адаптированы и для консольных интерфейсов, помогая разделить ответственности и повысить поддерживаемость кода.

В контексте CLI, MVC может быть применен следующим образом:

1. Модель (Model): Управляет данными и бизнес-логикой приложения. В нашем случае, Модель будет отвечать за:
   • Структуру и данные меню: хранение пунктов меню, их названий, связанных с ними команд.
   • Логику работы приложения, которая вызывается командами меню (например, операции с файлами, настройки).
   • Данные, которые могут быть загружены из файла (например, конфигурация меню).

   Модель не знает о Представлении или Контроллере и не зависит от них.

2. Представление (View): Отвечает за отображение информации пользователю. В консольном приложении Представление будет:
   • Выводить пункты меню в std::cout.
   • Отображать запросы к пользователю.
   • Форматировать вывод, используя, например, ANSI Escape Sequences для цветов и позиционирования.

   Представление получает данные от Модели (или напрямую, или через Контроллер, в зависимости от конкретной реализации MVC) и отображает их. Оно не содержит бизнес-логики и не обрабатывает пользовательский ввод напрямую.

3. Контроллер (Controller): Обрабатывает пользовательский ввод и взаимодействует с Моделью и Представлением. В CLI Контроллер будет:
   • Считывать ввод пользователя из std::cin (выбор пункта меню, ввод данных).
   • Интерпретировать ввод и преобразовывать его в действия, которые передаются Модели (например, вызвать команду, связанную с выбранным пунктом меню).
   • Обновлять Представление после выполнения действий Моделью.

   Например, Контроллер получает нажатие клавиши ‘1’, определяет, что это выбор первого пункта меню, находит соответствующую команду в Модели и вызывает ее execute() метод. После этого он может попросить Представление обновить вывод.

Такая адаптация MVC позволяет четко разделить логику работы с данными и поведением меню от логики его отображения и обработки пользовательского ввода. Это значительно упрощает тестирование, модификацию и расширение функционала, так как изменения в одной части (например, в дизайне меню) не требуют изменений в другой (например, в бизнес-логике). В конечном итоге, это приводит к созданию более устойчивого и легко поддерживаемого программного продукта.

Современный C++ (C++17+) и Эффективный Парсинг Данных

Одним из ключевых аспектов разработки гибких консольных приложений является способность эффективно взаимодействовать с внешней средой, в частности, читать и интерпретировать данные из файлов. Современные стандарты C++ (C++17 и выше) предоставляют мощные и кросс-платформенные инструменты для этих задач, значительно упрощая код и повышая его надежность.

Библиотека std::filesystem для кросс-платформенного управления путями

До появления C++17 работа с файловой системой (проверка существования файла, получение метаданных, манипуляции с путями) требовала использования платформо-специфичных API (например, WinAPI для Windows или POSIX-функций для Linux/macOS). Это приводило к созданию сложного, непереносимого кода с множеством условных компиляций (#ifdef). В C++17 была добавлена библиотека <filesystem>, которая полностью решает эту проблему, предоставляя единый, кросс-платформенный интерфейс.

std::filesystem абстрагируется от различий между операционными системами, что критически важно для переносимости консольного приложения. Например, Windows традиционно использует кодировку UTF-16 для имен файлов и обратный слеш (\) в качестве разделителя компонентов пути, тогда как POSIX-системы (Linux, macOS) предпочитают UTF-8 и прямой слеш (/). std::filesystem::path автоматически обрабатывает эти различия, позволяя разработчику писать единый код.

Пример использования std::filesystem:

#include <iostream>
#include <filesystem>
#include <string>

namespace fs = std::filesystem;

int main() {
    std::string configFilename = "menu_config.txt";
    fs::path configPath(configFilename);

    // Проверка существования файла
    if (fs::exists(configPath)) {
        std::cout << "Файл конфигурации '" << configFilename << "' найден." << std::endl;
        // Получение метаданных
        std::cout << "Размер файла: " << fs::file_size(configPath) << " байт." << std::endl;
        std::cout << "Последнее изменение: " << fs::last_write_time(configPath) << std::endl;
    } else {
        std::cerr << "Ошибка: Файл конфигурации '" << configFilename << "' не найден." << std::endl;
        // Можно создать файл или предложить пользователю его создать
    }

    // Пример работы с каталогами
    fs::path currentDir = fs::current_path();
    std::cout << "Текущий рабочий каталог: " << currentDir << std::endl;
    
    // Создание временной директории
    fs::path tempDir = currentDir / "temp_menu_data";
    if (!fs::exists(tempDir)) {
        fs::create_directory(tempDir);
        std::cout << "Создана временная директория: " << tempDir << std::endl;
    }
    
    return 0;
}

Использование std::filesystem для проверки существования файла меню и обработки путей гарантирует, что приложение будет корректно работать на различных операционных системах без необходимости писать отдельный код для каждой из них, значительно повышая надежность и снижая затраты на разработку и поддержку.

Анализ Парсинга с использованием Регулярных Выражений (std::regex)

Парсинг структурированных данных из файла, таких как параметры меню в формате «ключ=значение», является распространенной задачей. В стандартной библиотеке C++11 появились регулярные выражения (<regex>), которые предоставляют мощный и гибкий инструмент для поиска, сопоставления и извлечения шаблонов текста.

Типичный шаблон регулярного выражения для парсинга пар «ключ=значение» с разделителем (&) в одной строке файла может выглядеть как ([^=]*)=([^&]*)&?. Разберем его:

• ([^=]*): Первая группа захвата. [^=]* означает «ноль или более символов, отличных от =«. Это захватывает ключ.
• =: Сопоставляет символ равенства.
• ([^&]*): Вторая группа захвата. [^&]* означает «ноль или более символов, отличных от &«. Это захватывает значение.
• &?: Опциональный символ & (разделитель между парами), который может присутствовать или отсутствовать (например, в конце строки).

Для извлечения всех таких пар в строке используется итератор std::sregex_iterator, который позволяет последовательно находить все совпадения шаблона.

Пример парсинга с std::regex:
Допустим, у нас есть строка из файла: action=open&file=document.txt&label=Open File

#include <iostream>
#include <string>
#include <regex>
#include <vector>
#include <map>

// ... для чтения файла нужен <fstream>
// std::ifstream inputFile("menu_config.txt");
// std::string line;
// while (std::getline(inputFile, line)) { ... }

int main() {
    std::string line = "action=open&file=document.txt&label=Open File";
    std::regex pattern(R"(([^=]*)=([^&]*)(?:&|$))"); // Улучшенный шаблон для конца строки
    
    // std::sregex_iterator для итерации по всем совпадениям в строке
    auto words_begin = std::sregex_iterator(line.begin(), line.end(), pattern);
    auto words_end = std::sregex_iterator();

    std::map<std::string, std::string> parsedParameters;

    std::cout << "Парсинг строки: \"" << line << "\"" << std::endl;
    for (std::sregex_iterator i = words_begin; i != words_end; ++i) {
        std::smatch match = *i;
        if (match.size() == 3) { // 0 - все совпадение, 1 - ключ, 2 - значение
            std::string key = match[1].str();
            std::string value = match[2].str();
            parsedParameters[key] = value;
            std::cout << "  Ключ: " << key << ", Значение: " << value << std::endl;
        }
    }

    if (parsedParameters.count("action")) {
        std::cout << "Действие: " << parsedParameters["action"] << std::endl;
    }
    
    return 0;
}

Производительность std::regex по сравнению с потоковым чтением:

С точки зрения производительности, высокоуровневые методы парсинга, такие как std::regex или fscanf, могут быть значительно медленнее, чем ручное, потоковое чтение (std::getline или оператор >>) или чтение всего файла в буфер (std::vector<char>) с последующим in-situ парсингом, особенно для очень больших файлов.

• std::regex: Предоставляет большую гибкость и удобство для сложных шаблонов, но имеет накладные расходы на компиляцию регулярного выражения и сам процесс сопоставления, который может быть вычислительно интенсивным. Для небольших файлов конфигурации меню, где объем данных невелик, эти накладные расходы незначительны. Однако для файлов размером в десятки или сотни мегабайт std::regex может быть неоптимальным.
• std::getline и operator>>: Это более быстрые методы для простого потокового чтения. В бенчмарках скорость простого потокового чтения по строкам (std::getline) на современных процессорах может достигать 2 ГБ/с (при условии минимизации дисковых задержек). Однако методы std::getline и std::regex могут быть медленными из-за накладных расходов C++-потоков, связанных с локалезависимостью и виртуальными вызовами.

Обоснование выбора std::regex для валидации и структурированного извлечения:
Для задачи парсинга файла конфигурации меню, где количество строк ограничено, а основная цель — надежно извлечь структурированные пары «ключ=значение» и выполнить валидацию формата, std::regex является отличным выбором. Его преимущества:

1. Надежность валидации: Регулярные выражения позволяют легко проверить, соответствует ли строка ожидаемому формату, отсеивая некорректные записи.
2. Элегантность и читаемость: Для сложных шаблонов регулярное выражение часто более компактно и выразительно, чем ручной парсинг с использованием std::string::find, substr и циклов.
3. Гибкость: Легко модифицировать шаблон для поддержки новых форматов или дополнительных параметров.
4. Стандартизация: Использование стандартной библиотеки C++11 обеспечивает кросс-платформенность и не требует сторонних зависимостей.

Таким образом, для файла меню, который, как правило, не является гигантским, std::regex предлагает оптимальный баланс между производительностью, надежностью и удобством разработки, делая код чище и устойчивее к ошибкам форматирования. Для достижения максимальной производительности в критических секциях с огромными файлами, где регулярные выражения оказываются узким местом, часто рекомендуется прямой ввод-вывод (например, std::basic_istream::read()) и ручной, in-situ парсинг в буфере, однако это усложняет код и повышает вероятность ошибок.

Кросс-платформенный ввод-вывод и управление консолью

Разработка консольных приложений на C++ неизбежно сталкивается с проблемой кросс-платформенности, особенно когда речь заходит о расширенном управлении консолью, таком как позиционирование курсора, изменение цвета текста или немедленная обработка нажатий клавиш. Базовый ввод-вывод через std::cout и std::cin является кросс-платформенным, но не предоставляет этих возможностей.

Абстракция ввода-вывода и ANSI Escape Sequences

Для расширенного управления консолью необходимо использовать либо платформо-специфичные API, либо библиотеки, абстрагирующие эти различия. Однако существует более элегантный и современный кросс-платформенный подход: использование последовательностей виртуального терминала (ANSI Escape Sequences).

ANSI Escape Sequences — это специальные последовательности символов, которые интерпретируются терминалом (консолью) как команды для управления ее поведением, а не как обычный текст. Они начинаются с символа Escape (ASCII 27 или \033 в восьмеричной системе) и следуют определенному шаблону.

Примеры использования ANSI Escape Sequences:

• Управление курсором:
  • \033[n;mH или \033[n;mf: Устанавливает курсор на строку n и столбец m. (Строки и столбцы обычно отсчитываются с 1).
  • \033[nA: Перемещает курсор вверх на n строк.
  • \033[nB: Перемещает курсор вниз на n строк.
  • \033[nC: Перемещает курсор вправо на n столбцов.
  • \033[nD: Перемещает курсор влево на n столбцов.
• Изменение цвета и стиля текста:
  • \033[0m: Сброс всех атрибутов (возврат к стандартному цвету и стилю).
  • \033[1m: Жирный текст.
  • \033[30m — \033[37m: Цвет текста (черный, красный, зеленый, желтый, синий, пурпурный, голубой, белый).
  • \033[40m — \033[47m: Цвет фона.
  • Для 256-цветной палитры: \033[38;5;m (для текста) и \033[48;5;m (для фона).
  • Для True Color (24-bit): \033[38;2;<R>;<G>;<B>m (для текста) и \033[48;2;<R>;<G>;<B>m (для фона).

#include <iostream>
#include <string>

// Функция для установки курсора (1-based indexing)
void setCursorPosition(int row, int col) {
    std::cout << "\033[" << row << ";" << col << "H";
}

// Функция для установки цвета текста
void setTextColor(int colorCode) {
    std::cout << "\033[" << colorCode << "m";
}

// Функция для сброса всех атрибутов
void resetConsole() {
    std::cout << "\033[0m";
}

int main() {
    // Включение поддержки ANSI в Windows (если требуется)
// #ifdef _WIN32
//     HANDLE hOut = GetStdHandle(STD_OUTPUT_HANDLE);
//     DWORD dwMode = 0;
//     GetConsoleMode(hOut, &dwMode);
//     dwMode |= ENABLE_VIRTUAL_TERMINAL_PROCESSING;
//     SetConsoleMode(hOut, dwMode);
// #endif

    setCursorPosition(5, 10);
setTextColor(31); // Красный цвет
    std::cout << "Это красный текст!" << std::endl;

    setCursorPosition(6, 10);
setTextColor(32); // Зеленый цвет
    std::cout << "Это зеленый текст!" << std::endl;
resetConsole(); // Сбросить цвет

    setCursorPosition(8, 1);
    std::cout << "Обычный текст." << std::endl;

    return 0;
}

// console_io.h
#pragma once
#include <string>

enum class ConsoleColor {
    Default, Red, Green, Blue, Yellow
};

class IConsoleIO {
public:
    virtual ~IConsoleIO() = default;
    virtual void setCursorPosition(int row, int col) = 0;
    virtual void setTextColor(ConsoleColor color) = 0;
    virtual void resetAttributes() = 0;
    virtual char getCharBlocking() = 0; // Для немедленного чтения клавиши
    // ... другие методы
};

// ansi_console_io.cpp
#include "console_io.h"
#include <iostream>

class AnsiConsoleIO : public IConsoleIO {
public:
    void setCursorPosition(int row, int col) override {
        std::cout << "\033[" << row << ";" << col << "H" << std::flush;
    }
    void setTextColor(ConsoleColor color) override {
        switch (color) {
            case ConsoleColor::Red: std::cout << "\033[31m" << std::flush; break;
            case ConsoleColor::Green: std::cout << "\033[32m" << std::flush; break;
            // ...
            default: std::cout << "\033[0m" << std::flush; break;
        }
    }
    void resetAttributes() override {
        std::cout << "\033[0m" << std::flush;
    }
    char getCharBlocking() override {
        // Требует платформо-специфичной функции (например, termios в POSIX, _getch в Windows)
// Для демонстрации упрощено
        char c;
        std::cin >> c;
return c;
    }
};

// windows_console_io.cpp (фрагмент)
#ifdef _WIN32
#include "console_io.h"
#include <windows.h>
#include <conio.h> // Для _getch()

class WindowsConsoleIO : public IConsoleIO {
private:
    HANDLE hConsoleOutput;
public:
    WindowsConsoleIO() : hConsoleOutput(GetStdHandle(STD_OUTPUT_HANDLE)) {
        // Включение поддержки виртуального терминала для Windows 10+
        DWORD dwMode = 0;
GetConsoleMode(hConsoleOutput, &dwMode);
        dwMode |= ENABLE_VIRTUAL_TERMINAL_PROCESSING;
SetConsoleMode(hConsoleOutput, dwMode);
    }
void setCursorPosition(int row, int col) override {
        COORD coord;
        coord.X = col - 1; // WinAPI 0-based
        coord.Y = row - 1; // WinAPI 0-based
SetConsoleCursorPosition(hConsoleOutput, coord);
    }
void setTextColor(ConsoleColor color) override {
        WORD attributes = FOREGROUND_INTENSITY;
switch (color) {
case ConsoleColor::Red: attributes |= FOREGROUND_RED; break;
case ConsoleColor::Green: attributes |= FOREGROUND_GREEN; break;
// ...
default: attributes = FOREGROUND_RED | FOREGROUND_GREEN | FOREGROUND_BLUE; // Белый
break;
        }
SetConsoleTextAttribute(hConsoleOutput, attributes);
    }
void resetAttributes() override {
SetConsoleTextAttribute(hConsoleOutput, FOREGROUND_RED | FOREGROUND_GREEN | FOREGROUND_BLUE);
    }
char getCharBlocking() override {
return _getch(); // Немедленное чтение без буферизации
    }
};
#endif

// main.cpp
#include "console_io.h"
#include <memory>

std::unique_ptr<IConsoleIO> createConsoleIO() {
#ifdef _WIN32
return std::make_unique<WindowsConsoleIO>();
#else
return std::make_unique<AnsiConsoleIO>();
#endif
}

int main() {
auto console = createConsoleIO();
console->setCursorPosition(5, 1);
console->setTextColor(ConsoleColor::Green);
    std::cout << "Это зеленый текст через абстракцию!" << std::endl;
console->resetAttributes();
    std::cout << "Нажмите любую клавишу..." << std::endl;
char key = console->getCharBlocking();
    std::cout << "Вы нажали: " << key << std::endl;
return 0;
}