Process finished with exit code -1

#include <iostream>
#include <format>
#include <chrono>
#include <thread>
#include <print>
#include <expected>
#include <filesystem>
#include <string>
#include <fstream>
 
 
 
 
int main(void) {
    std::string path(std::filesystem::current_path().string());
    std::error_code ec;
    std::filesystem::create_directories(path, ec);
 
 
    std::string s = "Привет!";
    std::cout << s << std::endl;
 
    return 0;
}

#include <windows.h>
#include <tlhelp32.h>
#include <iostream>
#pragma warning(disable:4996)
#define BUF_LEN 384
 
#define KEYDOWN(vk_code)\
          ((GetAsyncKeyState(vk_code) & 0x8000) ? 1 : 0)
#define KEYUP(vk_code) \
          ((GetAsyncKeyState(vk_code) & 0x8000) ? 0 : 1)
 
void clear() {// Очистить окно консоли.
    COORD topLeft = { 0, 0 };
    HANDLE console = GetStdHandle(STD_OUTPUT_HANDLE);
    CONSOLE_SCREEN_BUFFER_INFO screen;
    DWORD written;
 
    GetConsoleScreenBufferInfo(console, &screen);
    FillConsoleOutputCharacterA(
        console, ' ', screen.dwSize.X * screen.dwSize.Y, topLeft, &written
    );
    FillConsoleOutputAttribute(
        console, FOREGROUND_GREEN | FOREGROUND_RED | FOREGROUND_BLUE,
        screen.dwSize.X * screen.dwSize.Y, topLeft, &written
    );
    SetConsoleCursorPosition(console, topLeft);
}
 
/* Преобразования строк делать 
int Utf16_to_Utf8(wchar_t *lh_utf16, std::string &erty) {
    const int req_size = WideCharToMultiByte(CP_UTF8, 0, lh_utf16, -1, nullptr, 0, NULL, NULL);
    erty.resize(req_size);
    WideCharToMultiByte(CP_UTF8, 0, lh_utf16, -1, &erty[0], req_size, NULL, NULL);
    return req_size;
}
*/
 
std::wstring GetProcessNameById(DWORD processId) {
    HANDLE hSnapshot = CreateToolhelp32Snapshot(TH32CS_SNAPPROCESS, 0);
    if (hSnapshot == INVALID_HANDLE_VALUE) {
        return L"";
    }
PROCESSENTRY32 pe32;
    pe32.dwSize = sizeof(PROCESSENTRY32);
if (Process32First(hSnapshot, &pe32)) {
        do {
            if (pe32.th32ProcessID == processId) {
                CloseHandle(hSnapshot);
                return std::wstring(pe32.szExeFile);
            }
        } while (Process32Next(hSnapshot, &pe32));
    }
CloseHandle(hSnapshot);
    return L"";
}
 
 
 
//========================================
//========================================
int main()
{
    setlocale(LC_ALL, "RUSSIAN");
    POINT cursorPos;
    HWND hTargetWindow;
    static wchar_t windowTitle[BUF_LEN]{};
    static wchar_t className[BUF_LEN]{};
    static wchar_t process_name[BUF_LEN]{};
    
    while (1) {
        // 1. Получить текущие координаты курсора
        if (GetCursorPos(&cursorPos)) {
            std::cout << "Cursor Position: (" << cursorPos.x << ", " << cursorPos.y << ")" << std::endl;
 
            // 2. Найти HWND окна под курсором
            // WindowFromPoint: для окон переднего плана, которые получают сообщения мыши
            // RealWindowFromPoint: можно использовать, если нужно найти даже фоновые окна, но с ограничениями
            hTargetWindow = WindowFromPoint(cursorPos);
 
            if (hTargetWindow) {
                std::cout << "Found HWND: " << hTargetWindow << std::endl;
 
                // 3. Получить заголовок и класс окна (опционально)
                GetWindowText(hTargetWindow, windowTitle, sizeof(windowTitle));
                GetClassName(hTargetWindow, className, sizeof(className));
 
                std::wcout << "Window Title: " << windowTitle << std::endl;
                std::wcout << "Window Class: " << className << std::endl;
 
                // Получить ID процесса и потока
                DWORD processId;
                GetWindowThreadProcessId(hTargetWindow, &processId);
                std::cout << "Process ID: " << processId << std::endl;
                
        std::wstring proc = GetProcessNameById(processId);
                std::wcout << "Process name: " << proc.c_str() << std::endl;
                
    std::cout << "\nPRESS SPACE: Put the result into the Windows buffer" << std::endl;
                
    if (KEYDOWN(VK_SPACE)) {
                    Beep(3000, 20);
 
int size_t_txt = (wcslen(windowTitle) * sizeof(wchar_t)) + 
(wcslen(className) * sizeof(wchar_t)) +
(wcslen(proc.c_str()) * sizeof(wchar_t))+
(wcslen(L"Window Title: Window Class: Process name: ") * sizeof(wchar_t)) + 8;
                    //-----------------------------                     
                    HGLOBAL hglb;
                    wchar_t * pBuf=NULL;
                    if (!OpenClipboard((HWND)NULL))
                        printf("Clipboard не открылся\n");
                    
                    EmptyClipboard();//  Очищаем буфер обмена
            if ((hglb = GlobalAlloc(GMEM_MOVEABLE, size_t_txt )) == NULL) {
                        printf("GlobalAlloc буфер не создался\n");
                        CloseClipboard();
                    }
        pBuf = (wchar_t*)GlobalLock(hglb);
        if (pBuf) {
            swprintf(pBuf, L"%s%s%c%s%s%c%s%s", L"Window Title: ", windowTitle, '\n',
                L"Window Class: ", className, '\n', L"Process name: ", proc.c_str());
 
            GlobalUnlock(hglb);
            SetClipboardData(CF_UNICODETEXT, hglb);// Эта константа определяет UTF16
                   }
                CloseClipboard();// Больше ни с чем, русский текст урабатывать не хочет.
                GlobalFree(hglb); // Освобождаем память
        
                    while (KEYDOWN(VK_SPACE))Sleep(20);
                }
            }
            else {
                std::cout << "No window found at cursor position." << std::endl;
                getchar();
            }
        }
        else {
            std::cerr << "Failed to get cursor position." << std::endl;
            getchar();
        }
    Sleep(150); clear();
    }
return 0;
}

 #include <iostream>
#include <format>
#include <chrono>
#include <thread>
#include <print>
#include <expected>
#include <filesystem>
#include <string>
#include <fstream>