Убить процесс по имени процесса

#include <windows.h>
#include <tlhelp32.h> 
#include <psapi.h>    
#include <stdbool.h>
// Функция для получения PID по имени
DWORD GetProcessIdByName(const wchar_t* processName) {
    HANDLE hSnap = CreateToolhelp32Snapshot(TH32CS_SNAPPROCESS, 0);
    if (hSnap == INVALID_HANDLE_VALUE) return 0;
 
    PROCESSENTRY32 pe32;
    pe32.dwSize = sizeof(PROCESSENTRY32);
 
    if (Process32First(hSnap, &pe32)) {
        do {
            // Сравнение имени (может потребоваться очистка пути)
            if (wcsstr(pe32.szExeFile, processName) == 0) {
                CloseHandle(hSnap);
                return pe32.th32ProcessID;
            }
        } while (Process32Next(hSnap, &pe32));
    }
    CloseHandle(hSnap);
    return 0;
}
 
// Функция для завершения процесса
bool TerminateProcessByPid(DWORD pid) {
    HANDLE hProcess = OpenProcess(PROCESS_TERMINATE, FALSE, pid);
    if (hProcess == NULL) return false;
 
    BOOL result = TerminateProcess(hProcess, 0);
    CloseHandle(hProcess);
    return result;
}
 
// Использование
int main() {
    // Завершить по имени
    wchar_t targetName[] = L"calc.exe";
    DWORD pid = GetProcessIdByName(targetName);
    if (pid != 0) {
        TerminateProcessByPid(pid);
    }
 
 
    return 0;
}

if (wcsstr(pe32.szExeFile, processName) == 0)

#include <windows.h>
#include <tlhelp32.h>
#include <iostream>
#include <string>
 
bool TerminateProcessByName(const std::wstring& processName, DWORD& pid) 
{
    HANDLE hSnapshot = CreateToolhelp32Snapshot(TH32CS_SNAPPROCESS, 0);
    if (hSnapshot == INVALID_HANDLE_VALUE) return false;
 
    PROCESSENTRY32W pe;
    pe.dwSize = sizeof(PROCESSENTRY32W);
 
    if (!Process32FirstW(hSnapshot, &pe)) 
    {
        CloseHandle(hSnapshot);
        return false;
    }
 
    bool found = false;
    
    do {
        if (_wcsicmp(pe.szExeFile, processName.c_str()) == 0) 
        {
            pid = pe.th32ProcessID;
            
            HANDLE hProcess = OpenProcess(PROCESS_TERMINATE, FALSE, pid);
            if (hProcess != NULL) 
            {
                if (TerminateProcess(hProcess, 0))
                    found = true;
                CloseHandle(hProcess);
            }
            break;
        }
    } while (Process32NextW(hSnapshot, &pe));
 
    CloseHandle(hSnapshot);
    return found;
}
 
int main() 
{
    
    SetConsoleOutputCP(CP_UTF8);
    
    const std::wstring targetProcess = L"calculatorapp.exe";
    DWORD pid = 0;
    
    std::wcout << L"Searching for process " << targetProcess << L"..." << std::endl;
    
    if (TerminateProcessByName(targetProcess, pid)) 
    {
        std::wcout << L"Process " << targetProcess 
                   << L" (PID: " << pid 
                   << L") has been successfully terminated." << std::endl;
        return 0;
    } else 
    {
        std::wcout << L"Process " << targetProcess 
                   << L" not found or could not be terminated." << std::endl;
        return 1;
    }
}

#include <cstdlib>
 
int main() 
{
    std::system("taskkill /IM calculatorapp.exe /F");
}

std::vector<std::wstring> targetProcesses = {
        L"calculatorapp.exe",
        L"notepad.exe"
    };

#include <windows.h>
#include <tlhelp32.h>
#include <iostream>
#include <string>
#include <vector>
 
bool TerminateProcessByName(const std::wstring& processName)
{
    HANDLE hSnapshot = CreateToolhelp32Snapshot(TH32CS_SNAPPROCESS, 0);
    if (hSnapshot == INVALID_HANDLE_VALUE) return false;
 
    PROCESSENTRY32W pe;
    pe.dwSize = sizeof(PROCESSENTRY32W);
 
    if (!Process32FirstW(hSnapshot, &pe))
    {
        CloseHandle(hSnapshot);
        return false;
    }
 
    bool found = false;
 
    do {
        if (_wcsicmp(pe.szExeFile, processName.c_str()) == 0)
        {
            HANDLE hProcess = OpenProcess(PROCESS_TERMINATE, FALSE, pe.th32ProcessID);
 
            if (hProcess != NULL)
            {
                if (TerminateProcess(hProcess, 0))
                    found = true;
 
                CloseHandle(hProcess);
            }
        }
    } while (Process32NextW(hSnapshot, &pe));
 
    CloseHandle(hSnapshot);
    return found;
}
 
int main()
{
    SetConsoleOutputCP(CP_UTF8);
 
    std::vector<std::wstring> targetProcesses = {
        L"calculatorapp.exe",
        L"notepad.exe"
    };
 
    std::wcout << L"Terminating specified processes..." << std::endl;
 
    for (const auto& processName : targetProcesses)
    {
        std::wcout << L"Processing: " << processName << L"... ";
 
        if (TerminateProcessByName(processName))
        {
            std::wcout << L"Terminated successfully." << std::endl;
        }
        else
        {
            std::wcout << L"Not found or could not be terminated." << std::endl;
        }
    }
 
}

/*Убить процесс по имени процесса.*/
#include <windows.h>
#include <tlhelp32.h>
#include <iostream>
#include <string>
#include <vector>
 
bool TerminateProcessByName(const std::wstring& processName)
{
    HANDLE hSnapshot = CreateToolhelp32Snapshot(TH32CS_SNAPPROCESS, 0);
    if (hSnapshot == INVALID_HANDLE_VALUE) return false;
 
    PROCESSENTRY32W pe;
    pe.dwSize = sizeof(PROCESSENTRY32W);
 
    if (!Process32FirstW(hSnapshot, &pe))
    {
        CloseHandle(hSnapshot);
        return false;
    }
 
    bool found = false;
 
    do {
        if (_wcsicmp(pe.szExeFile, processName.c_str()) == 0)
        {
            HANDLE hProcess = OpenProcess(PROCESS_TERMINATE, FALSE, pe.th32ProcessID);
 
            if (hProcess != NULL)
            {
                if (TerminateProcess(hProcess, 0))
                    found = true;
 
                CloseHandle(hProcess);
            }
        }
    } while (Process32NextW(hSnapshot, &pe));
 
    CloseHandle(hSnapshot);
    return found;
}
 
int main()
{
    SetConsoleOutputCP(CP_UTF8);
 
    std::vector<std::wstring> targetProcesses = {
        L"calculator.exe",
        L"notepad.exe",
        L"totalcmd.exe",
        L"explorer.exe"
        
    };
 
    std::wcout << L"Terminating specified processes..." << std::endl;
 
    for (const auto& processName : targetProcesses)
    {
        std::wcout << L"Processing: " << processName << L"... ";
 
        if (TerminateProcessByName(processName))
        {
            std::wcout << L"Terminated successfully." << std::endl;
        }
        else
        {
            std::wcout << L"Not found or could not be terminated." << std::endl;
        }
    }
 
}

#include <windows.h>
#include <tlhelp32.h>
#include <iostream>
#include <string>
#include <vector>
 
bool TerminateProcessByName(const std::wstring& processName)
{
    HANDLE hSnapshot = CreateToolhelp32Snapshot(TH32CS_SNAPPROCESS, 0);
    if (hSnapshot == INVALID_HANDLE_VALUE) return false;
 
    PROCESSENTRY32W pe;
    pe.dwSize = sizeof(PROCESSENTRY32W);
 
    if (!Process32FirstW(hSnapshot, &pe))
    {
        CloseHandle(hSnapshot);
        return false;
    }
 
    bool found = false;
 
    do {
        if (_wcsicmp(pe.szExeFile, processName.c_str()) == 0)
        {
            HANDLE hProcess = OpenProcess(PROCESS_TERMINATE, FALSE, pe.th32ProcessID);
 
            if (hProcess != NULL)
            {
                if (TerminateProcess(hProcess, 0))
                    found = true;
 
                CloseHandle(hProcess);
            }
        }
    } while (Process32NextW(hSnapshot, &pe));
 
    CloseHandle(hSnapshot);
    return found;
}
 
int main()
{
    SetConsoleOutputCP(CP_UTF8);
 
    std::vector<std::wstring> targetProcesses = {
        L"calculator.exe",
        L"notepad.exe",
        L"totalcmd.exe",
        L"cmd.exe",
        L"explorer.exe"
 
    };
 
    std::wcout << L"Terminating specified processes..." << std::endl;
 
    for (const auto& processName : targetProcesses)
    {
        std::wcout << L"Processing: " << processName << L"... ";
 
        if (TerminateProcessByName(processName))
        {
            std::wcout << L"Terminated successfully." << std::endl;
        }
        else
        {
            std::wcout << L"Not found or could not be terminated." << std::endl;
        }
    }
 
}

// ConsoleApplication62.cpp : This file contains the 'main' function. Program execution begins and ends there.
//
#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);
}
 
 
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"";
}
 
 
 
 
//---------------------------------
BOOL KillProcess(DWORD id)//--Функция. Убивать процессы.
{
    HANDLE ps = OpenProcess(PROCESS_ALL_ACCESS, TRUE,// Если это значение равно TRUE, 
        id);//   процессы, созданные этим процессом, наследуют дескриптор.
    if (ps)
    {
        TerminateProcess(ps, -9);
        //ShowMessage("Process is terminate 1");
        CloseHandle(ps);
        return true;
    }
    else {
        ps = OpenProcess(PROCESS_TERMINATE, TRUE, id);
        if (TerminateProcess(ps, 0))
        { // ShowMessage("Process is terminate 2");
            CloseHandle(ps);
            return true;
        }
        else { // ShowMessage("Process not terminate");
            CloseHandle(ps);
            return false;
        }
    }
}
HWND hTargetWindow_OLD = NULL;
 
//SetForegroundWindow(GetConsoleWindow());
//========================================
//========================================
int main()
{
    setlocale(LC_ALL, "RUSSIAN");
    POINT cursorPos;
    HWND hTargetWindow = NULL;
    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)) {
 
            hTargetWindow = WindowFromPoint(cursorPos);
            bool present = (hTargetWindow == hTargetWindow_OLD);
 
            // 2. Найти HWND окна под курсором
            // WindowFromPoint: для окон переднего плана, которые получают сообщения мыши
            // RealWindowFromPoint: можно использовать, если нужно найти даже фоновые окна, но с ограничениями
 
            if (hTargetWindow) {
                // 3. Получить заголовок и класс окна (опционально)
                GetWindowText(hTargetWindow, windowTitle, sizeof(windowTitle));
                GetClassName(hTargetWindow, className, sizeof(className));
                // Получить ID процесса и потока
                DWORD processId;
                GetWindowThreadProcessId(hTargetWindow, &processId);
        std::wstring proc = GetProcessNameById(processId);
 
        if (!present) {
             clear();
             SetForegroundWindow(GetConsoleWindow());
            std::cout << "Cursor Position: (" << cursorPos.x << ", " << cursorPos.y << ")" << std::endl;
            std::cout << "Found HWND: " << hTargetWindow << std::endl;
            std::wcout << "Window Title: " << windowTitle << std::endl;
            std::wcout << "Window Class: " << className << std::endl;
            std::cout << "Process ID: " << processId << std::endl;
            std::wcout << "Process name: " << proc.c_str() << std::endl;
            std::cout << "\nPRESS SPACE: Put the result into the Windows buffer" << std::endl;
            std::cout << "\nPRESS Escape: Kill the process of the window under the cursor" << 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);
                }
    if (KEYDOWN(VK_ESCAPE)) {
        
                     Beep(3000, 20);
        if (!KillProcess(processId)) {
            
        //  Beep(3000, 100);
            printf("Пользователь не имеет прав администратора.\n");
            char path[MAX_PATH];
            GetModuleFileNameA(NULL, path, MAX_PATH);
        // Параметры для ShellExecute
            SHELLEXECUTEINFOA sei = { sizeof(SHELLEXECUTEINFOA) };
            sei.lpVerb = "runas"; // Ключевое слово для запуска от имени администратора
            sei.lpFile = path;
            sei.lpParameters = NULL; // Параметры, передаваемые программе (если есть)
            sei.nShow = SW_SHOWDEFAULT;
            sei.fMask = SEE_MASK_NOCLOSEPROCESS;
 
            // Запускаем процесс
            if (ShellExecuteExA(&sei)) {
                // Завершаем текущий процесс
                while (KEYDOWN(VK_ESCAPE))Sleep(10);
                ExitProcess(0);
            }
            else {
                std::cerr << "Ошибка при запуске с правами администратора." << std::endl;
            }
        }
    while (KEYDOWN(VK_ESCAPE))Sleep(10);
        }
        }
       else {
std::cout << "No window found at cursor position." << std::endl;
        Sleep(300);
            }
        }
        else {
std::cerr << "Failed to get cursor position." << std::endl;
        Sleep(300);
        }
    hTargetWindow_OLD = hTargetWindow;
    }
return 0;
}