У меня есть программа на C++, которая обрабатывает процессы и сохраняет их открытие и закрытие:
#include <iostream>
#include <windows.h>
#include <tlhelp32.h>
#include <sqlite3.h>
#include <string>
#include <map>
#include <vector>
#include <thread>
#include <chrono>


std::string adminPassword = "admin123"; // Задайте пароль админа
// Функция для преобразования WCHAR* в строку в кодировке UTF-8
std::string wideToNarrow(const WCHAR* wide) {
    int bufferLength = WideCharToMultiByte(CP_UTF8, 0, wide, -1, nullptr, 0, nullptr, nullptr);
    std::vector<char> buffer(bufferLength, 0);
    WideCharToMultiByte(CP_UTF8, 0, wide, -1, &buffer[0], bufferLength, nullptr, nullptr);
    return std::string(buffer.begin(), buffer.end() - 1);
}

// Callback функция для обработки результатов SQL запросов
static int callback(void* data, int argc, char** argv, char** azColName) {
    std::vector<std::string>* records = (std::vector<std::string>*)data;
    try {
        std::string result;
        for (int i = 0; i < argc; i++) {
            result += std::string(azColName[i]) + ": " + (argv[i] ? argv[i] : "NULL") + " ";
        }
        records->push_back(result);
    }

    // Обработка исключений
    catch (...) {
        return 1;
    }
    return 0;
}

// Функция для получения текущего времени в формате, подходящем для SQL
std::string getCurrentTime() {
    SYSTEMTIME lt;
    GetLocalTime(&lt);
    char buffer[32];
    snprintf(buffer, sizeof(buffer), "%04d-%02d-%02d %02d:%02d:%02d", lt.wYear, lt.wMonth, lt.wDay, lt.wHour, lt.wMinute, lt.wSecond);
    return std::string(buffer);
}

// Функция определения, является ли процесс пользовательским приложением с видимым окном
bool isUserApp(const DWORD procId) {
    HWND hwnd = GetTopWindow(NULL);
    DWORD pid = 0;
    while (hwnd) {
        GetWindowThreadProcessId(hwnd, &pid);
        if (pid == procId) {
            wchar_t windowTitle[256];
            if (GetWindowText(hwnd, windowTitle, sizeof(windowTitle)) > 0 && IsWindowVisible(hwnd)) {
                return true;
        
            }
        }
        hwnd = GetNextWindow(hwnd, GW_HWNDNEXT);
    }
    return false;
}

// Функция отслеживания процессов
void trackProcesses(sqlite3* db) {
    char* errMsg = nullptr;
    std::map<DWORD, std::pair<std::string, std::string>> activeProcesses; // Карта активных процессов: PID -> (имя файла, время начала)

    while (true) {
        HANDLE snap = CreateToolhelp32Snapshot(TH32CS_SNAPPROCESS, 0); // Создание снимка процессов
        PROCESSENTRY32 pe;
        pe.dwSize = sizeof(PROCESSENTRY32);

        if (Process32First(snap, &pe)) { // Перебор всех процессов
            do {
                if (isUserApp(pe.th32ProcessID) && activeProcesses.find(pe.th32ProcessID))) {
                    std::string startTime = getCurrentTime();
                    std::string executableName = wideToNarrow(pe.szExeFile);
                    activeProcesses[pe.th32ProcessID] = std::make_pair(executableName, startTime);
                   
                    std::string sql = "INSERT INTO WorkTime (ProgramName, StartTime) VALUES ('" + executableName + "', '" + startTime + "');";
                    sqlite3_exec(db, sql.c_str(), nullptr, nullptr, &errMsg); // Вставка новой записи о запущенном процессе в базу данных
                    std::cout << "Открыт процесс: " << executableName << std::endl; // вывод открытого процесса
                }
            } while (Process32Next(snap, &pe));
        }
        CloseHandle(snap);
        // Проверка и обновление закрытых процессов
        for (auto it = activeProcesses.begin(); it != activeProcesses.end();) {
            HANDLE hProcess = OpenProcess(PROCESS_QUERY_LIMITED_INFORMATION, FALSE, it->first);
            if (hProcess == NULL || WaitForSingleObject(hProcess, 0) == WAIT_OBJECT_0) {
                std::string endTime = getCurrentTime();
                std::string sql = "UPDATE WorkTime SET EndTime='" + endTime + "' WHERE ProgramName='" + it->second.first + "' AND StartTime='" + it->second.second + "';";
                sqlite3_exec(db, sql.c_str(), nullptr, nullptr, &errMsg); // Обновление записи с временем окончания работы процесса
                std::cout << "Закрылся процесс: " << it->second.first << std::endl; // вывод закрытого процесса
                it = activeProcesses.erase(it);
            }
            else {
                ++it;
                CloseHandle(hProcess);
            }
        }
        std::this_thread::sleep_for(std::chrono::seconds(1));
    }
}

int main() {
    SetConsoleCP(1251);
    SetConsoleOutputCP(1251);
    sqlite3* db;
    sqlite3_open("employee_time_tracking.db", &db);
    char* errMsg = nullptr;

    // Создание таблиц
    std::string sql = "CREATE TABLE IF NOT EXISTS WorkTime(ID INTEGER PRIMARY KEY AUTOINCREMENT, ProgramName TEXT NOT NULL, StartTime TEXT NOT NULL, EndTime TEXT);";
    sqlite3_exec(db, sql.c_str(), nullptr, nullptr, &errMsg);

    std::thread processThread([&] { trackProcesses(db); });
    processThread.detach();

    std::string input;
    while (true) {
        std::cout << "1. Просмотреть записи\n2. Найти запись\n3. Выход\n";
        std::getline(std::cin, input);
        if (input == "1") {
            std::vector<std::string> records;
            sqlite3_exec(db, "SELECT * FROM WorkTime;", callback, &records, nullptr);
            for (const std::string& record : records) {
                std::cout << record << std::endl;
            }
        }
        else if (input == "2") {
            std::cout << "Введите имя программы/процесса: ";
            std::getline(std::cin, input);
            std::vector<std::string> records;
            std::string sql = "SELECT * FROM WorkTime WHERE ProgramName LIKE '%" + input + "%';";
            sqlite3_exec(db, sql.c_str(), callback, &records, nullptr);
            for (const std::string& record : records) {
                std::cout << record << std::endl;
            }
        }
        else if (input == "3") {
            break;
        }
    }

    sqlite3_close(db);
    return 0;
}

НО мне нужно чтобы она не сохраняла и не отображала уже открытые процессы при запуске программы. А также не реагировала на закрытие процессов открытых до работы программы