C++ 实时获取CPU使用率的类 (源码)

说明：1。内部使用timer定时器，自动刷新，使外部使用十分明了；2。主程序要有消息循环

[cpp] view plain copy print?
//=========================================================  
//  
// Copyright (c) 2000-2004  iWise Technologies，Co. Ltd.  
// All Rights Reserved.  
//  
// Product: iW988  
// File: CpuUsage.h  
// Created: 天衣有缝  
//    
// Description:  
//     ValueAdded main program for iW988.  
//                   Contact:  
//                       waterpub@mail.csdn.net  
//  
//=========================================================  
  
#pragma once   
  
#define SystemBasicInformation 0   
#define SystemPerformanceInformation 2   
#define SystemTimeInformation 3   
  
#define Li2Double(x) ((double)((x).HighPart) * 4.294967296E9 + (double)((x).LowPart))   
  
class CCpuUsage  
{  
public:  
    CCpuUsage();  
    ~CCpuUsage();  
      
public:  
    int GetCpuUsage();                       //得到系统cpu利用率  
    int SetRefreshInterval(int milli_sec);   //定时刷新间隔  
      
private:  
    //类型定义  
    typedef LONG (WINAPI *PROCNTQSI)(UINT,PVOID,ULONG,PULONG);  
      
    typedef struct  
    {  
        DWORD dwUnknown1;  
        ULONG uKeMaximumIncrement;  
        ULONG uPageSize;  
        ULONG uMmNumberOfPhysicalPages;  
        ULONG uMmLowestPhysicalPage;  
        ULONG uMmHighestPhysicalPage;  
        ULONG uAllocationGranularity;  
        PVOID pLowestUserAddress;  
        PVOID pMmHighestUserAddress;  
        ULONG uKeActiveProcessors;  
        BYTE bKeNumberProcessors;  
        BYTE bUnknown2;  
        WORD wUnknown3;  
    } SYSTEM_BASIC_INFORMATION;  
      
    typedef struct  
    {  
        LARGE_INTEGER liIdleTime;  
        DWORD dwSpare[76];  
    } SYSTEM_PERFORMANCE_INFORMATION;  
      
    typedef struct  
    {  
        LARGE_INTEGER liKeBootTime;  
        LARGE_INTEGER liKeSystemTime;  
        LARGE_INTEGER liExpTimeZoneBias;  
        ULONG uCurrentTimeZoneId;  
        DWORD dwReserved;  
    } SYSTEM_TIME_INFORMATION;  
      
    //变量定义  
    SYSTEM_PERFORMANCE_INFORMATION SysPerfInfo;  
    SYSTEM_TIME_INFORMATION SysTimeInfo;  
    SYSTEM_BASIC_INFORMATION SysBaseInfo;       double dbIdleTime;  
    double dbSystemTime;  
      
    LONG status;  
      
    LARGE_INTEGER liOldIdleTime;  
    LARGE_INTEGER liOldSystemTime;  
      
    PROCNTQSI NtQuerySystemInformation;  
      
    int m_nCpuUsage;  
      
    //定时  
    HWND m_hWnd;  
    int  m_nRefreshInterval;//默认为1000毫秒  
    int  m_nTimerID;  
      
private:  
    static void CalcCpuUsage(HWND hwnd, UINT uMsg, UINT_PTR idEvent, DWORD dwTime);  
    int OnTimer();  
};  
  
inline CCpuUsage::CCpuUsage()  
{  
    //  
    m_hWnd = NULL;  
    m_nRefreshInterval = 1000;  
    m_nTimerID = 1000;  
    m_nCpuUsage = 0;  
      
    //  
    memset(&liOldIdleTime  ,   0, sizeof(LARGE_INTEGER));  
    memset(&liOldSystemTime,   0, sizeof(LARGE_INTEGER));   
      
    //  
    NtQuerySystemInformation = (PROCNTQSI)GetProcAddress(  
        GetModuleHandle("ntdll") , "NtQuerySystemInformation");  
    if (!NtQuerySystemInformation)  
        return;  
      
    // get number of processors in the system  
    status =NtQuerySystemInformation(SystemBasicInformation,&SysBaseInfo,sizeof(SysBaseInfo),NULL);  
    if (status != NO_ERROR)  
        return;  
      
    // create control for timer  
    m_hWnd = ::CreateWindow("static", "", 0, 0, 0, 0, 0, NULL, NULL, 0, NULL);  
    ::SetWindowLong(m_hWnd , GWL_USERDATA , (long)(this) );  
      
    TIMERPROC tp = (TIMERPROC)CalcCpuUsage;  
    SetTimer(m_hWnd , m_nTimerID, m_nRefreshInterval, tp);  
      
}  
  
inline CCpuUsage::~CCpuUsage()  
{  
    KillTimer(m_hWnd , m_nTimerID);  
    DestroyWindow(m_hWnd);  
}  
  
inline void CCpuUsage::CalcCpuUsage(  
                                    HWND hwnd,  
                                    UINT uMsg,  
                                    UINT_PTR idEvent,  
                                    DWORD dwTime  
                                    ){  
    CCpuUsage* pCpu = (CCpuUsage*)::GetWindowLong(hwnd , GWL_USERDATA);  
      
    if ( pCpu )  
    {  
        pCpu->OnTimer();  
    }  
      
}  
  
inline int CCpuUsage::OnTimer()  
{  
    status =NtQuerySystemInformation(SystemTimeInformation,&SysTimeInfo,sizeof(SysTimeInfo),0);  
      
    if (status!=NO_ERROR)  
        return 0;  
      
    // get new CPU's idle time  
    status =NtQuerySystemInformation(SystemPerformanceInformation,&SysPerfInfo,sizeof(SysPerfInfo),NULL);  
    if (status != NO_ERROR)  
        return 0;  
      
    // if it's a first call - skip it  
    if (liOldIdleTime.QuadPart != 0)  
    {  
        // CurrentValue = NewValue - OldValue  
        dbIdleTime = Li2Double(SysPerfInfo.liIdleTime) - Li2Double(liOldIdleTime);  
        dbSystemTime = Li2Double(SysTimeInfo.liKeSystemTime) - Li2Double(liOldSystemTime);  
          
        // CurrentCpuIdle = IdleTime / SystemTime  
        dbIdleTime = dbIdleTime / dbSystemTime;  
          
        // CurrentCpuUsage% = 100 - (CurrentCpuIdle * 100) / NumberOfProcessors  
        dbIdleTime = 100.0 - dbIdleTime * 100.0 / (double)SysBaseInfo.bKeNumberProcessors+ 0.5;  
          
        m_nCpuUsage = (UINT)dbIdleTime;  
    }  
      
    // store new CPU's idle and system time  
    liOldIdleTime = SysPerfInfo.liIdleTime;  
    liOldSystemTime = SysTimeInfo.liKeSystemTime;  
      
    // wait one second  
      
    return 0;  
}  
  
inline int CCpuUsage::GetCpuUsage()  
{  
    return m_nCpuUsage;  
}  
  
inline int CCpuUsage::SetRefreshInterval(int milli_sec)  
{  
    m_nRefreshInterval = milli_sec;  
      
    if ( m_hWnd )  
    {  
        TIMERPROC tp = (TIMERPROC)CalcCpuUsage;  
        SetTimer(m_hWnd, m_nTimerID, m_nRefreshInterval ,tp);  
    }  
      
    return 0;  
      
}