#include <windows.h>
#include <iostream>

double GetCpuUsage() {
    FILETIME idleTime, kernelTime, userTime;
    static FILETIME preIdleTime, preKernelTime, preUserTime;

    GetSystemTimes(&idleTime, &kernelTime, &userTime);

    // 轉(zhuǎn)換為64位整型
    ULONGLONG idle = (*(ULONGLONG*)&idleTime) - (*(ULONGLONG*)&preIdleTime);
    ULONGLONG kernel = (*(ULONGLONG*)&kernelTime) - (*(ULONGLONG*)&preKernelTime);
    ULONGLONG user = (*(ULONGLONG*)&userTime) - (*(ULONGLONG*)&preUserTime);

    preIdleTime = idleTime;
    preKernelTime = kernelTime;
    preUserTime = userTime;

    if (kernel + user == 0) return 0.0;
    return ((kernel + user - idle) * 100.0) / (kernel + user);
}

// 調(diào)用示例
int main() {
    while (true) {
        Sleep(1000); // 間隔1秒采樣
        std::cout << "CPU Usage: " << GetCpuUsage() << "%" << std::endl;
    }
    return 0;
}

#include <windows.h>
#include <pdh.h>
#pragma comment(lib, "pdh.lib") 

double GetCpuUsageByPdh() {
    static PDH_HQUERY query;
    static PDH_HCOUNTER counter;
    static bool initialized = false;
    
    if (!initialized) {
        PdhOpenQuery(nullptr, 0, &query);
        PdhAddCounter(query, L"\\Processor(_Total)\\% Processor Time", 0, &counter);
        initialized = true;
    }

    PDH_FMT_COUNTERVALUE value;
    PdhCollectQueryData(query);
    PdhGetFormattedCounterValue(counter, PDH_FMT_DOUBLE, nullptr, &value);
    return value.doubleValue; 
}

#include <windows.h>
#include <iostream>

class ProcessCpuMonitor {
public:
    ProcessCpuMonitor(DWORD pid) : pid_(pid) {
        hProcess_ = OpenProcess(PROCESS_QUERY_LIMITED_INFORMATION, FALSE, pid_);
    }

    ~ProcessCpuMonitor() {
        if (hProcess_) CloseHandle(hProcess_);
    }

    float GetUsage() {
        FILETIME createTime, exitTime, kernelTime, userTime;
        if (!GetProcessTimes(hProcess_, &createTime, &exitTime, &kernelTime, &userTime))
            return -1;

        ULONGLONG currentKernel = *(ULONGLONG*)&kernelTime;
        ULONGLONG currentUser = *(ULONGLONG*)&userTime;
        ULONGLONG delta = (currentKernel + currentUser) - (lastKernel_ + lastUser_);

        // 計(jì)算時(shí)間差（單位：100納秒）
        ULONGLONG timePassed = GetTickCount64() - lastTick_;
        lastTick_ = GetTickCount64();
        lastKernel_ = currentKernel;
        lastUser_ = currentUser;

        if (timePassed == 0) return 0.0f;
        return (delta / 10000.0f) / timePassed * 100.0f; // 轉(zhuǎn)換為百分比
    }

private:
    DWORD pid_;
    HANDLE hProcess_ = nullptr;
    ULONGLONG lastKernel_ = 0, lastUser_ = 0;
    ULONGLONG lastTick_ = 0;
};

// 調(diào)用示例
int main() {
    DWORD pid = 1234; // 目標(biāo)進(jìn)程ID
    ProcessCpuMonitor monitor(pid);
    while (true) {
        Sleep(1000);
        std::cout << "Process CPU Usage: " << monitor.GetUsage() << "%" << std::endl;
    }
    return 0;
}

#include <fstream>
#include <vector>
#include <string>

struct CpuTime {
    unsigned long user, nice, system, idle, iowait, irq, softirq;
};

CpuTime readCpuStats() {
    std::ifstream file("/proc/stat");
    std::string cpu_label;
    CpuTime time;
    file >> cpu_label >> time.user  >> time.nice  >> time.system  >> time.idle  
         >> time.iowait  >> time.irq  >> time.softirq; 
    return time;
}

double calculateCpuUsage(const CpuTime& prev, const CpuTime& curr) {
    const unsigned long prev_total = prev.user  + prev.nice  + prev.system  + prev.idle  
                                   + prev.iowait  + prev.irq  + prev.softirq; 
    const unsigned long curr_total = curr.user  + curr.nice  + curr.system  + curr.idle  
                                   + curr.iowait  + curr.irq  + curr.softirq; 
    const unsigned long total_diff = curr_total - prev_total;

    const unsigned long idle_diff = curr.idle  - prev.idle; 
    return (total_diff - idle_diff) * 100.0 / total_diff;
}

#include <iostream>
#include <unistd.h>

int main() {
    CpuTime prev = readCpuStats();
    sleep(1); // 采樣間隔1秒
    CpuTime curr = readCpuStats();
    
    double usage = calculateCpuUsage(prev, curr);
    std::cout << "CPU Usage: " << usage << "%" << std::endl;
    return 0;
}

#include <mach/mach_host.h>
#include <mach/processor_info.h>
#include <unistd.h>

double get_cpu_usage() {
    host_cpu_load_info_data_t cpuinfo;
    mach_msg_type_number_t count = HOST_CPU_LOAD_INFO_COUNT;
    kern_return_t kr = host_statistics(mach_host_self(), 
                                      HOST_CPU_LOAD_INFO,
                                      (host_info_t)&cpuinfo,
                                      &count);
    if (kr != KERN_SUCCESS) return -1.0;

    // 第一次采樣
    uint64_t total_user_prev = cpuinfo.cpu_ticks[CPU_STATE_USER]; 
    uint64_t total_sys_prev = cpuinfo.cpu_ticks[CPU_STATE_SYSTEM]; 
    uint64_t total_idle_prev = cpuinfo.cpu_ticks[CPU_STATE_IDLE]; 
    uint64_t total_used_prev = total_user_prev + total_sys_prev;

    // 等待 1 秒后再次采樣
    sleep(1);
    kr = host_statistics(mach_host_self(),
                        HOST_CPU_LOAD_INFO,
                        (host_info_t)&cpuinfo,
                        &count);
    if (kr != KERN_SUCCESS) return -1.0;

    uint64_t total_user = cpuinfo.cpu_ticks[CPU_STATE_USER]; 
    uint64_t total_sys = cpuinfo.cpu_ticks[CPU_STATE_SYSTEM]; 
    uint64_t total_idle = cpuinfo.cpu_ticks[CPU_STATE_IDLE]; 
    uint64_t total_used = total_user + total_sys;

    // 計(jì)算差值
    uint64_t used_diff = total_used - total_used_prev;
    uint64_t idle_diff = total_idle - total_idle_prev;
    uint64_t total_diff = used_diff + idle_diff;

    return (total_diff == 0) ? 0 : (used_diff * 100.0) / total_diff;
}