Обработка нажатии с клавиатуры

Функция getPressedKey
принимает
- int8_t key - Клавиша например 'C'
- bool isTurned - принимает true или false
——————————————————————————-
Логика работы:

Сначала мы проверяем наш флаг isTurned и если он true то будет работать в режиме кнопки, а если false то в режиме выключателя

//вот код. Если не будет функции то значит нет файла pdb   

//Функцию BugReport вызывать в начале int main и потом в конце программы Cleanup();


//Код
#include <dbghelp.h>
#pragma comment(lib, "dbghelp.lib")
struct CPPException {
    bool ErrorTextures = false;
    std::string sLastError;
    void* pLastStack = nullptr;

    void log(std::string t) {
        std::cout << "Exception Error: " << t << std::endl;
    }

    void Write(const std::string& t, void* pErrorSegment) {
        ErrorTextures = true;
        sLastError += t + "\n";
        pLastStack = pErrorSegment;
        log("EXCEPTIONS::Write: " + t + ", StackPtr: " + std::to_string(reinterpret_cast<uintptr_t>(pErrorSegment)));
    }

    static std::wstring GetStackTrace(PEXCEPTION_POINTERS pExInfo) {
        std::wstringstream ss;
        HANDLE process = GetCurrentProcess();
        HANDLE thread = GetCurrentThread();

        // Инициализация символов
        SymInitialize(process, NULL, TRUE); // Загружаем символы для всех модулей
        SymSetOptions(SYMOPT_LOAD_LINES | SYMOPT_UNDNAME); // Включаем линии и имена без декораций

        STACKFRAME64 frame = { 0 };
        frame.AddrPC.Offset = pExInfo->ContextRecord->Rip;
        frame.AddrPC.Mode = AddrModeFlat;
        frame.AddrFrame.Offset = pExInfo->ContextRecord->Rbp;
        frame.AddrFrame.Mode = AddrModeFlat;
        frame.AddrStack.Offset = pExInfo->ContextRecord->Rsp;
        frame.AddrStack.Mode = AddrModeFlat;

        while (StackWalk64(
            IMAGE_FILE_MACHINE_AMD64,
            process,
            thread,
            &frame,
            pExInfo->ContextRecord,
            NULL,
            SymFunctionTableAccess64,
            SymGetModuleBase64,
            NULL)) {
            DWORD64 address = frame.AddrPC.Offset;
            if (address == 0) break; // Конец стека

            // Форматирование адреса
            ss << L"[0x" << std::hex << std::setw(16) << std::setfill(L'0') << address << L"] ";

            // Получение имени функции
            char symbolBuffer[sizeof(SYMBOL_INFO) + MAX_SYM_NAME] = { 0 };
            SYMBOL_INFO* symbol = (SYMBOL_INFO*)symbolBuffer;
            symbol->SizeOfStruct = sizeof(SYMBOL_INFO);
            symbol->MaxNameLen = MAX_SYM_NAME;
            DWORD64 displacement = 0;

            if (SymFromAddr(process, address, &displacement, symbol)) {
                // Конвертация char* в wstring
                std::string funcName(symbol->Name);
                std::wstring wFuncName(funcName.begin(), funcName.end()); // Простое преобразование (или используйте MultiByteToWideChar для точности)
                ss << L"Function: " << wFuncName << L" + 0x" << std::hex << displacement;
            }
            else {
                ss << L"Unknown function";
            }

            // Получение имени файла и номера строки
            IMAGEHLP_LINE64 line = { 0 };
            line.SizeOfStruct = sizeof(IMAGEHLP_LINE64);
            DWORD lineDisplacement = 0;
            if (SymGetLineFromAddr64(process, address, &lineDisplacement, &line)) {
                // Конвертация char* в wstring
                std::string fileName(line.FileName);
                std::wstring wFileName(fileName.begin(), fileName.end());
                ss << L" at " << wFileName << L":" << std::dec << line.LineNumber;
            }

            // Получение имени модуля
            IMAGEHLP_MODULE64 module = { 0 };
            module.SizeOfStruct = sizeof(IMAGEHLP_MODULE64);
            if (SymGetModuleInfo64(process, address, &module)) {
                // ModuleName — это TCHAR*, в Unicode-проекте это wchar_t*
                ss << L" in module " << module.ModuleName;
            }

            ss << L"\n";
        }

        // Очистка символов
        SymCleanup(process);
        return ss.str();
    }

    static LONG WINAPI CrashHandler(PEXCEPTION_POINTERS pExInfo) {
        std::wstring errorMsg;
        std::wstring errorCode;
        std::string errorMsgA;
        std::string errorCodeA;
        switch (pExInfo->ExceptionRecord->ExceptionCode) {
        case EXCEPTION_ILLEGAL_INSTRUCTION: // 0xC000001D
            errorCode = L"Неподдерживамая инструкция (0xC000001D)";
            errorCodeA = "Ошибка доступа к памяти (0xC0000005)";
            break;
        case EXCEPTION_ACCESS_VIOLATION: // 0xC0000005
            errorCode = L"Ошибка доступа к памяти (0xC0000005)";
            errorCodeA = "Ошибка доступа к памяти (0xC0000005)";
            break;
        case EXCEPTION_STACK_OVERFLOW: // 0xC00000FD
            errorCode = L"Переполнение буфера (0xC00000FD)";
            errorCodeA = "Переполнение буфера (0xC00000FD)";
            break;
        default:
            errorCode = L"Неизвестное исключение (0x" + std::wstring(std::to_string(pExInfo->ExceptionRecord->ExceptionCode).begin(), std::to_string(pExInfo->ExceptionRecord->ExceptionCode).end()) + L")";
            errorCodeA = "Неизвестное исключение (0x" + std::to_string(pExInfo->ExceptionRecord->ExceptionCode) + ")";
            break;
        }
        std::wstring stackTraceW = GetStackTrace(pExInfo);
        std::ofstream logFile("crash_log.txt", std::ios::app);
        logFile << "PahomEngine crashed!" << std::endl;
        logFile << "========================" << std::endl;
        logFile << "Crash at:     " << __DATE__ << " " << __TIME__ << "\n";
        logFile << "Exception:    " << errorCodeA << "\n";
        logFile << "Stack Trace:\n" << std::string(stackTraceW.begin(), stackTraceW.end()).c_str() << "\n";
        logFile << "------------------------\n";
        logFile.close();

        std::wstring msg = L"ImPlayer вылетел\n=======================\nКритическая ошибка: " + errorCode + L"\n------------------- STACK TRACE ---------------\n"+ std::wstring(stackTraceW.begin(), stackTraceW.end()) +
            L"\nSee crash_log.txt for details.\nPlease send crash_log.txt to @hcppstudio.";
        MessageBox(NULL, msg.c_str(), L"ImPlayer::Exception", MB_OK | MB_ICONERROR);

        return EXCEPTION_EXECUTE_HANDLER;
    }

    void BugReport() {
        // Инициализация символов (один раз при старте)
        SymInitialize(GetCurrentProcess(), NULL, TRUE);
        SymSetOptions(SYMOPT_LOAD_LINES | SYMOPT_UNDNAME);
        SetUnhandledExceptionFilter(CrashHandler);
    }

    void Cleanup() {
        SymCleanup(GetCurrentProcess());
    }
};
std::unique_ptr<CPPException> pCppException = std::make_unique<CPPException>();
//Проверка указателя то что он не nullptr чтобы не было ошибки доступа к неинициализированной памяти

if(pCppException){
std::cout «" pCppException is true" « std::endl;
}

int128_t i128MSize = 0;
std::string hashFn128(int128_t sz) {
    std::string bff;
    const std::string bff_chr = "qwertyuiop[]asdfghjkl;'zxcvbnm,./12345678890";
    int64_t sd_rd = 0;
    srand(time(0));
    for (int128_t i = 0; i < sz; i++) {
        sd_rd = rand() % bff_chr.size();
        bff += bff_chr[sd_rd];

    }
    i128MSize += bff.size();
    return "Hash Size:" + std::to_string(bff.size());
}
int128_t i128HashSize = 100000000LL;
int128_t i128HashCount = 0;
int128_t GenHashToAllThreads128() {
    unsigned int num_threads = std::thread::hardware_concurrency();
    if (num_threads == 0) {
        num_threads = 4;
    }

    int128_t i128HashChunk = i128HashSize / num_threads;
    std::vector<std::jthread> threads;
    threads.reserve(num_threads);
    for (unsigned int i = 0; i < num_threads; ++i) {
        threads.emplace_back(hashFn128, i128HashChunk);
        i128HashCount += i128HashChunk;
    }
    return 0;
}