C/C++通過WMI和系統API函數獲取獲取系統硬件配置信息（轉）

前段時間由於項目需要，要求做一個服務器的實時性能監控（CPU、內存、網絡利用率等）和讀取服務器的硬件配置參數的接口供項目組使用，就是一個類似於魯大師之類的東東吧...

     當然第一想法肯定是利用Windows提供的系統標准API函數來完成所需的功能，當然這也應該是當前最理想最有效率的選擇了。但是如果你對API編程不是很熟練的話...那就相當蛋疼了！你知道用API可以做到但是不知道用哪個API，好啊，可以查MSDN。問題是你連API名字都不知道...當然，如果你們公司允許你們上國內局域網的話那就好辦多了，因為有無數強大的網友會幫你找到答案。使用API編程的另一個問題是如果你仍舊對API不熟悉的話調用起來相當困難、很不順手。

    還有一種方案就是--->“強大”的WMI，.net平台的程序員可能對這個比較熟悉，WMI即windows管理規范。通過它可以訪問、配置、管理和監視幾乎所有的Windows資源。當然對於程序員而言在WMI體系結構中我們最需要關心的就是WMI提供的程序和接口。

    WMI提供程序在WMI和托管資源之間扮演着中間方的角色。提供程序代表使用者應用程序和腳本從WMI托管資源請求信息，並發送指令到WMI托管資源。
下面是我們利用WMI編程經常要用到的WMI內置提供程序清單，以供編程參考。

1.Active Directory提供程序  
鏈接庫文件：dsprov.dll  
命名空間：root\directory\ldap  
作用：將Active Directory 對象映射到 WMI。 

2.事件日志提供程序  
鏈接庫文件：ntevt.dll  
命名空間：root\cimv2  
作用：管理 Windows 事件日志，例如，讀取、備份、清除、復制、刪除、監視、重命名、壓縮、解壓縮和更改事件日志設置。 

3.注冊表提供程序  
鏈接庫文件：stdprov.dll  
命名空間：root\default  
作用：讀取、寫入、枚舉、監視、創建、刪除注冊表項和值。 

4.Win32 提供程序  
鏈接庫文件：cimwin32.dll  
命名空間：root\cimv2  
作用：提供關於計算機、磁盤、外圍設備、文件、文件夾、文件系統、網絡組件、操作系統、打印機、進程、安全性、服務、共享、SAM 用戶及組，以及更多資源的信息。 

5.Windows 安裝程序提供程序  
鏈接庫文件：msiprov.dll  
命名空間：root\cimv2  
作用：提供對已安裝軟件信息的訪問。

  以上可以看出WMI中的類被分組到不同的命名空間中，所以我們在調用相應的程序庫時要注意引入對應的命名空間~~~我們今天用到的庫就是cimwin32.dll庫（第4個）。
好，廢話到此為止,還有不懂的自己下去慢慢研究：現在看代碼...

 

一、基於API方式的實現代碼，簡單的對部分API函數的封裝：

     1、GetSysInfo.h文件

pragma once

     #include <afxtempl.h>

     class GetSysInfo
     {
     public:
    GetSysInfo(void);
    ~GetSysInfo(void);

     public:
    /********獲取操作系統版本，Service pack版本、系統類型************/
    void GetOSVersion(CString &strOSVersion,CString &strServiceVersion);
    BOOL IsWow64();//判斷是否為64位操作系統

    /***********獲取網卡數目和名字***********/
    int  GetInterFaceCount();
    void GetInterFaceName(CString &InterfaceName,int pNum);

    /***獲取物理內存和虛擬內存大小***/
    void GetMemoryInfo(CString &dwTotalPhys,CString &dwTotalVirtual);

    /****獲取CPU名稱、內核數目、主頻*******/
    void GetCpuInfo(CString &chProcessorName,CString &chProcessorType,DWORD &dwNum,DWORD &dwMaxClockSpeed);

    /****獲取硬盤信息****/
    void GetDiskInfo(DWORD &dwNum,CString chDriveInfo[]);

    /****獲取顯卡信息*****/
    void GetDisplayCardInfo(DWORD &dwNum,CString chCardName[]);
     private:
    CStringList Interfaces;                          //保存所有網卡的名字
    CList < DWORD, DWORD &>        Bandwidths;      //各網卡的帶寬
    CList < DWORD, DWORD &>        TotalTraffics;    //各網卡的總流量
     };

2.GetSysInfo.cpp文件

#include "StdAfx.h"  
#include "GetSysInfo.h"  
#include "float.h"  
#include "winperf.h"  
  
GetSysInfo::GetSysInfo(void)  
{  
}  
  
GetSysInfo::~GetSysInfo(void)  
{  
}  
  
void GetSysInfo::GetOSVersion(CString &strOSVersion,CString &strServiceVersion)  
{  
    CString str;  
    OSVERSIONINFOEX osvi;  
    SYSTEM_INFO si;  
    BOOL bOsVersionInfoEx;  
  
    ZeroMemory(&si, sizeof(SYSTEM_INFO));  
    ZeroMemory(&osvi, sizeof(OSVERSIONINFOEX));  
  
    osvi.dwOSVersionInfoSize = sizeof(OSVERSIONINFOEX);  
    if( !(bOsVersionInfoEx = GetVersionEx ((OSVERSIONINFO *) &osvi)) )  
    {  
        osvi.dwOSVersionInfoSize = sizeof (OSVERSIONINFO);  
        GetVersionEx ( (OSVERSIONINFO *) &osvi);  
    }  
  
  
    GetProcAddress(GetModuleHandle(TEXT("kernel32.dll")),   
        "GetNativeSystemInfo");  
  
    GetSystemInfo(&si);  
    switch (osvi.dwPlatformId)  
    {  
    case VER_PLATFORM_WIN32_NT:  
        if ( osvi.dwMajorVersion == 6 && osvi.dwMinorVersion == 0 )  
        {  
            if( osvi.wProductType == VER_NT_WORKSTATION )  
            {  
                str.Format(_T("Windows Vista "));  
            }  
            else   
            {  
                str.Format(_T("Windows Server \"Longhorn\" "));  
            }  
        }  
        if ( osvi.dwMajorVersion == 5 && osvi.dwMinorVersion == 2 )  
        {  
            if( GetSystemMetrics(SM_SERVERR2) )  
            {  
                str.Format(_T("Microsoft Windows Server 2003 \"R2\" "));  
            }  
            else if( osvi.wProductType == VER_NT_WORKSTATION &&  
                si.wProcessorArchitecture==PROCESSOR_ARCHITECTURE_AMD64)  
            {  
                str.Format(_T("Microsoft Windows XP Professional x64 Edition "));  
            }  
            else   
            {  
                str.Format(_T("Microsoft Windows Server 2003, "));  
            }  
        }  
  
        if ( osvi.dwMajorVersion == 5 && osvi.dwMinorVersion == 1 )  
        {  
            str.Format(_T("Microsoft Windows XP "));  
        }  
  
        if ( osvi.dwMajorVersion == 5 && osvi.dwMinorVersion == 0 )  
            str.Format(_T("Microsoft Windows 2000 "));  
  
        if ( osvi.dwMajorVersion <= 4 )  
        {  
            str.Format(_T("Microsoft Windows NT "));  
        }  
  
        // Test for specific product on Windows NT 4.0 SP6 and later.  
        if( bOsVersionInfoEx )  
        {  
  
            //將Service Pack 版本保存  
            strServiceVersion.Format(_T("Service Pack %d"),osvi.wServicePackMajor);  
  
            // Test for the workstation type.  
            if ( osvi.wProductType == VER_NT_WORKSTATION &&  
                si.wProcessorArchitecture!=PROCESSOR_ARCHITECTURE_AMD64)  
            {  
                if( osvi.dwMajorVersion == 4 )  
                    str = str + _T("Workstation 4.0");  
                else if( osvi.wSuiteMask & VER_SUITE_PERSONAL )  
                    str = str + _T("Home Edition");  
                else str = str + _T( "Professional");  
            }  
  
            // Test for the server type.  
            else if ( osvi.wProductType == VER_NT_SERVER ||   
                osvi.wProductType == VER_NT_DOMAIN_CONTROLLER )  
            {  
                if(osvi.dwMajorVersion==5 && osvi.dwMinorVersion==2)  
                {  
                    if ( si.wProcessorArchitecture ==  
                        PROCESSOR_ARCHITECTURE_IA64 )  
                    {  
                        if( osvi.wSuiteMask & VER_SUITE_DATACENTER )  
                            str = str + _T("Datacenter Edition for Itanium-based Systems");  
                        else if( osvi.wSuiteMask & VER_SUITE_ENTERPRISE )  
                            str = str + _T("Enterprise Edition for Itanium-based Systems");  
                    }  
  
                    else if ( si.wProcessorArchitecture ==  
                        PROCESSOR_ARCHITECTURE_AMD64 )  
                    {  
                        if( osvi.wSuiteMask & VER_SUITE_DATACENTER )  
                            str = str + _T( "Datacenter x64 Edition ");  
                        else if( osvi.wSuiteMask & VER_SUITE_ENTERPRISE )  
                            str = str + _T( "Enterprise x64 Edition ");  
                        else str = str + _T( "Standard x64 Edition ");  
                    }  
  
                    else  
                    {  
                        if( osvi.wSuiteMask & VER_SUITE_DATACENTER )  
                            str = str + _T( "Datacenter Edition ");  
                        else if( osvi.wSuiteMask & VER_SUITE_ENTERPRISE )  
                            str = str + _T( "Enterprise Edition ");  
                        else if ( osvi.wSuiteMask & VER_SUITE_BLADE )  
                            str = str + _T( "Web Edition ");  
                        else str = str + _T( "Standard Edition ");  
                    }  
                }  
                else if(osvi.dwMajorVersion==5 && osvi.dwMinorVersion==0)  
                {  
                    if( osvi.wSuiteMask & VER_SUITE_DATACENTER )  
                        str = str + _T("Datacenter Server ");  
                    else if( osvi.wSuiteMask & VER_SUITE_ENTERPRISE )  
                        str = str + _T( "Advanced Server ");  
                    else str = str + _T( "Server ");  
                }  
                else  // Windows NT 4.0   
                {  
                    if( osvi.wSuiteMask & VER_SUITE_ENTERPRISE )  
                        str = str + _T ("Server 4.0, Enterprise Edition ");  
                    else str = str + _T ( "Server 4.0 " );  
                }  
            }  
        }  
        // Test for specific product on Windows NT 4.0 SP5 and earlier  
        else    
        {  
            HKEY hKey;  
            TCHAR szProductType[256];  
            DWORD dwBufLen=256*sizeof(TCHAR);  
            LONG lRet;  
  
            lRet = RegOpenKeyEx( HKEY_LOCAL_MACHINE,  
                _T("SYSTEM\\CurrentControlSet\\Control\\ProductOptions"), 0, KEY_QUERY_VALUE, &hKey );  
            if( lRet != ERROR_SUCCESS )  
                strOSVersion = str;  
                return;  
  
            lRet = RegQueryValueEx( hKey, TEXT("ProductType"),  
                NULL, NULL, (LPBYTE) szProductType, &dwBufLen);  
            RegCloseKey( hKey );  
  
            if( (lRet != ERROR_SUCCESS) ||  
                (dwBufLen > 256*sizeof(TCHAR)) )  
                strOSVersion = str;  
                return;  
  
            if ( lstrcmpi( TEXT("WINNT"), szProductType) == 0 )  
                str = str + _T( "Workstation ");  
            if ( lstrcmpi( TEXT("LANMANNT"), szProductType) == 0 )  
                str = str + _T( "Server " );  
            if ( lstrcmpi( TEXT("SERVERNT"), szProductType) == 0 )  
                str = str + _T( "Advanced Server ");  
            str.Format(_T( "%d.%d "), osvi.dwMajorVersion, osvi.dwMinorVersion );  
        }  
  
        // Display service pack (if any) and build number.  
  
        if( osvi.dwMajorVersion == 4 &&   
            lstrcmpi( osvi.szCSDVersion, TEXT("Service Pack 6") ) == 0 )  
        {   
            HKEY hKey;  
            LONG lRet;  
  
            // Test for SP6 versus SP6a.  
            lRet = RegOpenKeyEx( HKEY_LOCAL_MACHINE,  
                _T("SOFTWARE\\Microsoft\\Windows NT\\CurrentVersion\\Hotfix\\Q246009"), 0, KEY_QUERY_VALUE, &hKey );  
            if( lRet == ERROR_SUCCESS )  
                str.Format(_T( "Service Pack 6a (Build %d)\n"),   
                osvi.dwBuildNumber & 0xFFFF );           
            else // Windows NT 4.0 prior to SP6a  
            {  
                _tprintf( TEXT("%s (Build %d)\n"),  
                    osvi.szCSDVersion,  
                    osvi.dwBuildNumber & 0xFFFF);  
            }  
  
            RegCloseKey( hKey );  
        }  
        else // not Windows NT 4.0   
        {  
            _tprintf( TEXT("%s (Build %d)\n"),  
                osvi.szCSDVersion,  
                osvi.dwBuildNumber & 0xFFFF);  
        }  
  
        break;  
  
        // Test for the Windows Me/98/95.  
    case VER_PLATFORM_WIN32_WINDOWS:  
  
        if (osvi.dwMajorVersion == 4 && osvi.dwMinorVersion == 0)  
        {  
            str.Format(_T("Microsoft Windows 95 "));  
            if (osvi.szCSDVersion[1]=='C' || osvi.szCSDVersion[1]=='B')  
                str = str + _T("OSR2 ");  
        }   
  
        if (osvi.dwMajorVersion == 4 && osvi.dwMinorVersion == 10)  
        {  
            str.Format(_T("Microsoft Windows 98 "));  
            if ( osvi.szCSDVersion[1]=='A' || osvi.szCSDVersion[1]=='B')  
                str = str + _T("SE ");  
        }   
        if (osvi.dwMajorVersion == 4 && osvi.dwMinorVersion == 90)  
        {  
            str.Format(_T("Microsoft Windows Millennium Edition\n"));  
        }   
        break;  
  
    case VER_PLATFORM_WIN32s:  
        str.Format(_T("Microsoft Win32s\n"));  
        break;  
    default:  
        break;  
    }  
  
    strOSVersion = str;  
}  
  
BOOL GetSysInfo::IsWow64()   
{   
    typedef BOOL (WINAPI *LPFN_ISWOW64PROCESS) (HANDLE, PBOOL);   
    LPFN_ISWOW64PROCESS fnIsWow64Process;   
    BOOL bIsWow64 = FALSE;   
    fnIsWow64Process = (LPFN_ISWOW64PROCESS)GetProcAddress( GetModuleHandle(_T("kernel32")),"IsWow64Process");   
    if (NULL != fnIsWow64Process)   
    {   
        fnIsWow64Process(GetCurrentProcess(),&bIsWow64);  
    }   
    return bIsWow64;   
}   
  
void GetSysInfo::GetCpuInfo(CString &chProcessorName,CString &chProcessorType,DWORD &dwNum,DWORD &dwMaxClockSpeed)  
{  
  
    CString strPath=_T("HARDWARE\\DESCRIPTION\\System\\CentralProcessor\\0");//注冊表子鍵路徑  
    CRegKey regkey;//定義注冊表類對象  
    LONG lResult;//LONG型變量－反應結果  
    lResult=regkey.Open(HKEY_LOCAL_MACHINE,LPCTSTR(strPath),KEY_ALL_ACCESS); //打開注冊表鍵  
    if (lResult!=ERROR_SUCCESS)  
    {  
        return;  
    }  
    WCHAR chCPUName[50] = {0};  
    DWORD dwSize=50;   
  
    //獲取ProcessorNameString字段值  
    if (ERROR_SUCCESS == regkey.QueryStringValue(_T("ProcessorNameString"),chCPUName,&dwSize))  
    {  
        chProcessorName = chCPUName;  
    }  
  
    //查詢CPU主頻  
    DWORD dwValue;  
    if (ERROR_SUCCESS == regkey.QueryDWORDValue(_T("~MHz"),dwValue))  
    {  
        dwMaxClockSpeed = dwValue;  
    }  
    regkey.Close();//關閉注冊表  
    //UpdateData(FALSE);  
  
    //獲取CPU核心數目  
    SYSTEM_INFO si;  
    memset(&si,0,sizeof(SYSTEM_INFO));  
    GetSystemInfo(&si);  
    dwNum = si.dwNumberOfProcessors;  
  
    switch (si.dwProcessorType)  
    {  
    case PROCESSOR_INTEL_386:  
        {  
            chProcessorType.Format(_T("Intel 386 processor"));  
        }  
        break;  
    case PROCESSOR_INTEL_486:  
        {  
            chProcessorType.Format(_T("Intel 486 Processor"));  
        }  
        break;  
    case PROCESSOR_INTEL_PENTIUM:  
        {  
            chProcessorType.Format(_T("Intel Pentium Processor"));  
        }  
        break;  
    case PROCESSOR_INTEL_IA64:  
        {  
            chProcessorType.Format(_T("Intel IA64 Processor"));  
        }  
        break;  
    case PROCESSOR_AMD_X8664:  
        {  
            chProcessorType.Format(_T("AMD X8664 Processor"));  
        }  
        break;  
    default:  
        chProcessorType.Format(_T("未知"));  
        break;  
    }  
  
    //GetDisplayName()  
}  
  
void  GetSysInfo::GetMemoryInfo(CString &dwTotalPhys,CString &dwTotalVirtual)   
{   
    //   TODO:     Add   extra   initialization   here   
    MEMORYSTATUS   Mem;   
    //   get   the   memory   status   
    GlobalMemoryStatus(&Mem);   
  
    DWORD dwSize = (DWORD)Mem.dwTotalPhys/(1024*1024);   
    DWORD dwVirtSize = (DWORD)Mem.dwTotalVirtual/(1024*1024);  
  
    dwTotalPhys.Format(_T("物理內存:%ld MB"),dwSize);   
    dwTotalVirtual.Format(_T("虛擬內存:%ld MB"),dwVirtSize);  
}  
  
int GetSysInfo::GetInterFaceCount()  
{  
    /*CGetNetData pNet; 
    DWORD pCount = pNet.GetNetworkInterfacesCount(); 
    return pCount;*/  
  
  
    try  
    {  
#define DEFAULT_BUFFER_SIZE 40960L  
  
        unsigned char *data = (unsigned char*)malloc(DEFAULT_BUFFER_SIZE);  
        DWORD type;  
        DWORD size = DEFAULT_BUFFER_SIZE;  
        DWORD ret;  
  
        char s_key[4096];  
        sprintf_s(s_key , 4096 , "510");  
        //RegQueryValueEx的固定調用格式          
        CString str(s_key);  
  
        //如果RegQueryValueEx函數執行失敗則進入循環  
        while((ret = RegQueryValueEx(HKEY_PERFORMANCE_DATA, str, 0, &type, data, &size)) != ERROR_SUCCESS)  
        {  
            Sleep(10);  
            //如果RegQueryValueEx的返回值為ERROR_MORE_DATA(申請的內存區data太小，不能容納RegQueryValueEx返回的數據)  
            if(ret == ERROR_MORE_DATA)   
            {  
                Sleep(10);  
                size += DEFAULT_BUFFER_SIZE;  
                data = (unsigned char*) realloc(data, size);//重新分配足夠大的內存  
  
                ret = RegQueryValueEx(HKEY_PERFORMANCE_DATA, str, 0, &type, data, &size);//重新執行RegQueryValueEx函數  
            }   
            //如果RegQueryValueEx返回值仍舊未成功則函數返回.....(注意內存泄露“free函數”~~~)。  
            //這個if保證了這個while只能進入一次~~~避免死循環  
            if(ret != ERROR_SUCCESS)  
            {  
                if (NULL != data)  
                {  
                    free(data);  
                    data = NULL;  
                }  
                return 0;//0個接口  
            }  
        }  
  
        //函數執行成功之后就是對返回的data內存中數據的解析了，這個建議去查看MSDN有關RegQueryValueEx函數參數數據結構的說明  
        //得到數據塊       
        PERF_DATA_BLOCK  *dataBlockPtr = (PERF_DATA_BLOCK *)data;  
        //得到第一個對象  
        PERF_OBJECT_TYPE *objectPtr = (PERF_OBJECT_TYPE *) ((BYTE *)dataBlockPtr + dataBlockPtr->HeaderLength);  
  
        for(int a=0 ; a<(int)dataBlockPtr->NumObjectTypes ; a++)   
        {  
            char nameBuffer[255] = {0};  
            if(objectPtr->ObjectNameTitleIndex == 510)   
            {  
                DWORD processIdOffset = ULONG_MAX;  
                PERF_COUNTER_DEFINITION *counterPtr =(PERF_COUNTER_DEFINITION *) ((BYTE *)objectPtr + objectPtr->HeaderLength);  
  
                for(int b=0 ; b<(int)objectPtr->NumCounters ; b++)   
                {  
                    if(counterPtr->CounterNameTitleIndex == 520)  
                        processIdOffset = counterPtr->CounterOffset;  
  
                    counterPtr =(PERF_COUNTER_DEFINITION *) ((BYTE *) counterPtr + counterPtr->ByteLength);  
                }  
  
                if(processIdOffset == ULONG_MAX) {  
                    if(data != NULL)  
                    {  
                        free(data);  
                        data = NULL;  
                    }  
                    return 0;  
                }  
  
                PERF_INSTANCE_DEFINITION *instancePtr =(PERF_INSTANCE_DEFINITION *)  ((BYTE *) objectPtr + objectPtr->DefinitionLength);  
  
                for(int b=0 ; b<objectPtr->NumInstances ; b++)   
                {  
                    wchar_t *namePtr = (wchar_t *) ((BYTE *)instancePtr + instancePtr->NameOffset);  
                    PERF_COUNTER_BLOCK *counterBlockPtr = (PERF_COUNTER_BLOCK *) ((BYTE *)instancePtr + instancePtr->ByteLength);  
          
                    char pName[256] = {0};  
                    WideCharToMultiByte(CP_ACP, 0, namePtr, -1, pName, sizeof(nameBuffer), 0, 0);  
  
                    DWORD bandwith = *((DWORD *) ((BYTE *)counterBlockPtr + processIdOffset));                
                    DWORD tottraff = 0;  
  
                    Interfaces.AddTail(CString(pName)); //各網卡的名稱  
                    Bandwidths.AddTail(bandwith);       //帶寬  
                    TotalTraffics.AddTail(tottraff);    // 流量初始化為0  
  
                    PERF_COUNTER_BLOCK  *pCtrBlk = (PERF_COUNTER_BLOCK *) ((BYTE *)instancePtr + instancePtr->ByteLength);  
  
                      
                    instancePtr = (PERF_INSTANCE_DEFINITION *) ((BYTE *)instancePtr + instancePtr->ByteLength + pCtrBlk->ByteLength);  
                }  
            }  
            objectPtr = (PERF_OBJECT_TYPE *) ((BYTE *)objectPtr + objectPtr->TotalByteLength);  
        }  
        if(data != NULL)  
        {  
            free(data);  
            data = NULL;  
        }  
    }  
    catch(...)  
    {  
        return 0;  
    }  
    return Interfaces.GetCount();  
}  
  
void GetSysInfo::GetInterFaceName(CString &InterfaceName,int pNum)  
{  
    /*CGetNetData pNet; 
    pNet.GetNetworkInterfaceName(&InterfaceName,pNum);*/  
  
    POSITION pos = Interfaces.FindIndex(pNum);  
    if(pos==NULL)  
        return ;  
  
    InterfaceName = Interfaces.GetAt(pos);  
    pos = Bandwidths.FindIndex(pNum);  
    if (pos == NULL)  
        return;  
    DWORD dwBandwidth = Bandwidths.GetAt(pos);  
  
    CString str;  
    str.Format(_T("%d"),dwBandwidth);  
  
    InterfaceName = InterfaceName + str;  
}  
  
void GetSysInfo::GetDiskInfo(DWORD &dwNum,CString chDriveInfo[])  
{  
    DWORD DiskCount = 0;  
  
    //利用GetLogicalDrives()函數可以獲取系統中邏輯驅動器的數量，函數返回的是一個32位無符號整型數據。  
    DWORD DiskInfo = GetLogicalDrives();  
  
    //通過循環操作查看每一位數據是否為1，如果為1則磁盤為真,如果為0則磁盤不存在。  
    while(DiskInfo)  
    {  
        //通過位運算的邏輯與操作，判斷是否為1  
        Sleep(10);  
        if(DiskInfo&1)  
        {  
            DiskCount++;  
        }  
        DiskInfo = DiskInfo >> 1;//通過位運算的右移操作保證每循環一次所檢查的位置向右移動一位。*/  
    }  
  
    if (dwNum < DiskCount)  
    {  
        return;//實際的磁盤數目大於dwNum  
    }  
    dwNum = DiskCount;//將磁盤分區數量保存  
  
  
    //-------------------------------------------------------------------//  
    //通過GetLogicalDriveStrings()函數獲取所有驅動器字符串信息長度  
    int DSLength = GetLogicalDriveStrings(0,NULL);  
  
      WCHAR* DStr = new WCHAR[DSLength];  
      memset(DStr,0,DSLength);  
  
      //通過GetLogicalDriveStrings將字符串信息復制到堆區數組中,其中保存了所有驅動器的信息。  
      GetLogicalDriveStrings(DSLength,DStr);  
  
      int DType;  
      int si=0;  
      BOOL fResult;  
      unsigned _int64 i64FreeBytesToCaller;  
      unsigned _int64 i64TotalBytes;  
      unsigned _int64 i64FreeBytes;  
  
      //讀取各驅動器信息，由於DStr內部數據格式是A:\NULLB:\NULLC:\NULL，所以DSLength/4可以獲得具體大循環范圍  
      for(int i=0;i<DSLength/4;++i)  
      {  
          Sleep(10);  
          CString strdriver = DStr+i*4;  
          CString strTmp,strTotalBytes,strFreeBytes;  
          DType = GetDriveType(strdriver);//GetDriveType函數，可以獲取驅動器類型，參數為驅動器的根目錄  
          switch (DType)  
          {  
          case DRIVE_FIXED:  
              {  
                  strTmp.Format(_T("本地磁盤"));  
              }  
            break;  
          case DRIVE_CDROM:  
              {  
                  strTmp.Format(_T("DVD驅動器"));  
              }  
              break;  
          case DRIVE_REMOVABLE:  
              {  
                  strTmp.Format(_T("可移動磁盤"));  
              }  
              break;  
          case DRIVE_REMOTE:  
              {  
                  strTmp.Format(_T("網絡磁盤"));  
              }  
              break;  
          case DRIVE_RAMDISK:  
              {  
                  strTmp.Format(_T("虛擬RAM磁盤"));  
              }  
              break;  
          case DRIVE_UNKNOWN:  
              {  
                  strTmp.Format(_T("虛擬RAM未知設備"));  
              }  
              break;  
          default:  
              strTmp.Format(_T("未知設備"));  
              break;  
          }  
  
          //GetDiskFreeSpaceEx函數，可以獲取驅動器磁盤的空間狀態,函數返回的是個BOOL類型數據  
          fResult = GetDiskFreeSpaceEx (strdriver,  
              (PULARGE_INTEGER)&i64FreeBytesToCaller,  
              (PULARGE_INTEGER)&i64TotalBytes,  
              (PULARGE_INTEGER)&i64FreeBytes);  
                
          if(fResult)  
          {  
              strTotalBytes.Format(_T("磁盤總容量%fMB"),(float)i64TotalBytes/1024/1024);  
              strFreeBytes.Format(_T("磁盤剩余空間%fMB"),(float)i64FreeBytesToCaller/1024/1024);  
          }  
          else  
          {  
              strTotalBytes.Format(_T(""));  
              strFreeBytes.Format(_T(""));  
          }  
          chDriveInfo[i] = strTmp + _T("(") + strdriver + _T("):") + strTotalBytes + strFreeBytes;  
          si+=4;  
      }  
}  
  
void GetSysInfo::GetDisplayCardInfo(DWORD &dwNum,CString chCardName[])  
{  
    HKEY keyServ;  
    HKEY keyEnum;  
    HKEY key;  
    HKEY key2;  
    LONG lResult;//LONG型變量－保存函數返回值  
  
    //查詢"SYSTEM\\CurrentControlSet\\Services"下的所有子鍵保存到keyServ  
    lResult = RegOpenKeyEx(HKEY_LOCAL_MACHINE,TEXT("SYSTEM\\CurrentControlSet\\Services"),0,KEY_READ,&keyServ);  
    if (ERROR_SUCCESS != lResult)  
        return;  
  
  
    //查詢"SYSTEM\\CurrentControlSet\\Enum"下的所有子鍵保存到keyEnum  
    lResult = RegOpenKeyEx(HKEY_LOCAL_MACHINE,TEXT("SYSTEM\\CurrentControlSet\\Enum"),0,KEY_READ,&keyEnum);  
    if (ERROR_SUCCESS != lResult)  
        return;  
  
    int i = 0,count = 0;  
    DWORD size = 0,type = 0;  
    for (;;++i)  
    {  
        Sleep(5);  
        size = 512;  
        TCHAR name[512] = {0};//保存keyServ下各子項的字段名稱  
  
        //逐個枚舉keyServ下的各子項字段保存到name中  
        lResult = RegEnumKeyEx(keyServ,i,name,&size,NULL,NULL,NULL,NULL);  
  
        //要讀取的子項不存在，即keyServ的子項全部遍歷完時跳出循環  
        if(lResult == ERROR_NO_MORE_ITEMS)  
            break;  
  
        //打開keyServ的子項字段為name所標識的字段的值保存到key  
        lResult = RegOpenKeyEx(keyServ,name,0,KEY_READ,&key);  
        if (lResult != ERROR_SUCCESS)  
        {  
            RegCloseKey(keyServ);  
            return;  
        }  
          
  
        size = 512;  
        //查詢key下的字段為Group的子鍵字段名保存到name  
        lResult = RegQueryValueEx(key,TEXT("Group"),0,&type,(LPBYTE)name,&size);  
        if(lResult == ERROR_FILE_NOT_FOUND)  
        {  
            //?鍵不存在  
            RegCloseKey(key);  
            continue;  
        };  
  
  
  
        //如果查詢到的name不是Video則說明該鍵不是顯卡驅動項  
        if(_tcscmp(TEXT("Video"),name)!=0)  
        {  
            RegCloseKey(key);  
            continue;     //返回for循環  
        };  
          
        //如果程序繼續往下執行的話說明已經查到了有關顯卡的信息，所以在下面的代碼執行完之后要break第一個for循環，函數返回  
        lResult = RegOpenKeyEx(key,TEXT("Enum"),0,KEY_READ,&key2);  
        RegCloseKey(key);  
        key = key2;  
        size = sizeof(count);  
        lResult = RegQueryValueEx(key,TEXT("Count"),0,&type,(LPBYTE)&count,&size);//查詢Count字段（顯卡數目）  
  
        dwNum = count;//保存顯卡數目  
        for(int j=0;j <count;++j)  
        {  
            TCHAR sz[512] = {0};  
            TCHAR name[64] = {0};  
            wsprintf(name,TEXT("%d"),j);  
            size = sizeof(sz);  
            lResult  = RegQueryValueEx(key,name,0,&type,(LPBYTE)sz,&size);  
  
  
            lResult = RegOpenKeyEx(keyEnum,sz,0,KEY_READ,&key2);  
            if (ERROR_SUCCESS)  
            {  
                RegCloseKey(keyEnum);  
                return;  
            }  
              
  
            size = sizeof(sz);  
            lResult = RegQueryValueEx(key2,TEXT("FriendlyName"),0,&type,(LPBYTE)sz,&size);  
            if(lResult == ERROR_FILE_NOT_FOUND)  
            {  
                size = sizeof(sz);  
                lResult = RegQueryValueEx(key2,TEXT("DeviceDesc"),0,&type,(LPBYTE)sz,&size);  
                chCardName[j] = sz;//保存顯卡名稱  
            };  
            RegCloseKey(key2);  
            key2 = NULL;  
        };  
        RegCloseKey(key);  
        key = NULL;  
        break;  
    }  
}  

  以上就是對系統API的簡單封裝，可以看出用的最多的就是RegOpenKeyEx、RegQueryValueEx之類的查詢注冊表的函數，基本上所有系統信息都可以通過注冊表查到，所以...感興趣的童鞋有空可以去研究研究注冊表~~~~~~這里只是提供一個思路也許有更好的方法來實現~~~求交流~~

二、通過WMI（windows管理規范）接口編程來實現系統硬件信息的獲取~~這個相較於上面API方式就方便多了~~~使用起來是相當的方面~~~但是....但是.....這個他媽的實在是太慢了~~~~~比上面的API方式要慢很多倍~~~我沒有試過WMI在.net平台下的效果，但至少在MFC工程里面是相當的慢，看代碼~~

1、WMIInfo.h文件

#pragma once  
#include <atlbase.h>  
#include <afxpriv.h>  
#include <WbemIdl.h>  
#pragma comment(lib,"WbemUuid.lib")  
  
class CWmiInfo  
{  
public:  
    CWmiInfo(void);  
    ~CWmiInfo(void);  
  
public:  
    HRESULT InitWmi();    //初始化WMI  
    HRESULT ReleaseWmi(); //釋放  
  
          
    BOOL GetSingleItemInfo(CString,CString,CString&);<pre class="cpp" name="code" style="margin-top: 4px; margin-right: 0px; margin-bottom: 4px; margin-left: 0px; background-color: rgb(240, 240, 240); ">        BOOL GetGroupItemInfo(CString,CString[],int,CString&);  
  
private:  
    void VariantToString(const LPVARIANT,CString &) const;//將Variant類型的變量轉換為CString  
private:  
    IEnumWbemClassObject* m_pEnumClsObj;  
    IWbemClassObject* m_pWbemClsObj;  
    IWbemServices* m_pWbemSvc;  
    IWbemLocator* m_pWbemLoc;  
};</pre>  
<pre></pre>  
<p>2.WMIInfo.CPP文件</p>  
<pre class="cpp" name="code">#include "StdAfx.h"  
#include "WmiInfo.h"  
  
CWmiInfo::CWmiInfo(void)  
{  
    m_pWbemSvc=NULL;  
    m_pWbemLoc=NULL;  
    m_pEnumClsObj = NULL;  
}  
  
CWmiInfo::~CWmiInfo(void)  
{  
    m_pWbemSvc=NULL;  
    m_pWbemLoc=NULL;  
    m_pEnumClsObj = NULL;  
}  
  
HRESULT CWmiInfo::InitWmi()  
{  
    HRESULT hr;  
  
//一、初始化COM組件  
    //初始化COM  
    hr=::CoInitializeEx(0,COINIT_MULTITHREADED);  
    if (SUCCEEDED(hr) || RPC_E_CHANGED_MODE == hr)  
    {  
        //設置進程的安全級別，（調用COM組件時在初始化COM之后要調用CoInitializeSecurity設置進程安全級別，否則會被系統識別為病毒）  
        hr=CoInitializeSecurity(NULL,  
            -1,  
            NULL,                     
            NULL,  
            RPC_C_AUTHN_LEVEL_PKT,  
            RPC_C_IMP_LEVEL_IMPERSONATE,  
            NULL,  
            EOAC_NONE,  
            NULL);  
        //VERIFY(SUCCEEDED(hr));  
  
        //二、創建一個WMI命名空間連接  
        //創建一個CLSID_WbemLocator對象  
        hr=CoCreateInstance(CLSID_WbemLocator,  
            0,  
            CLSCTX_INPROC_SERVER,  
            IID_IWbemLocator,  
            (LPVOID*)&m_pWbemLoc);  
        VERIFY(SUCCEEDED(hr));  
  
        //使用m_pWbemLoc連接到"root\cimv2"並設置m_pWbemSvc的指針  
        hr=m_pWbemLoc->ConnectServer(CComBSTR(L"ROOT\\CIMV2"),  
            NULL,  
            NULL,  
            0,  
            NULL,  
            0,  
            0,  
            &m_pWbemSvc);  
        VERIFY(SUCCEEDED(hr));  
  
        //三、設置WMI連接的安全性  
        hr=CoSetProxyBlanket(m_pWbemSvc,  
            RPC_C_AUTHN_WINNT,  
            RPC_C_AUTHZ_NONE,  
            NULL,  
            RPC_C_AUTHN_LEVEL_CALL,  
            RPC_C_IMP_LEVEL_IMPERSONATE,  
            NULL,  
            EOAC_NONE);  
        VERIFY(SUCCEEDED(hr));  
  
    }  
    return(hr);  
}  
  
HRESULT CWmiInfo::ReleaseWmi()  
{  
    HRESULT hr;  
  
    if (NULL != m_pWbemSvc)  
    {  
        hr=m_pWbemSvc->Release();  
    }  
    if (NULL != m_pWbemLoc)  
    {  
        hr=m_pWbemLoc->Release();  
    }  
    if (NULL != m_pEnumClsObj)  
    {  
        hr=m_pEnumClsObj->Release();  
    }  
  
    ::CoUninitialize();  
  
    return(hr);  
}  
  
BOOL CWmiInfo::GetSingleItemInfo(CString ClassName,CString ClassMember,CString &chRetValue)  
{  
    USES_CONVERSION;  
  
    CComBSTR query("SELECT * FROM ");  
    VARIANT vtProp;  
    ULONG uReturn;  
    HRESULT hr;  
    BOOL bRet = FALSE;  
  
    if (NULL != m_pWbemSvc)  
    {  
        //查詢類ClassName中的所有字段,保存到m_pEnumClsObj中  
        query+=CComBSTR(ClassName);  
        hr=m_pWbemSvc->ExecQuery(CComBSTR("WQL"),query,WBEM_FLAG_FORWARD_ONLY|WBEM_FLAG_RETURN_IMMEDIATELY,  
            0,&m_pEnumClsObj);  
        if (SUCCEEDED(hr))  
        {  
            //初始化vtProp值  
            VariantInit(&vtProp);  
            uReturn=0;  
  
            //返回從當前位置起的第一個對象到m_pWbemClsObj中  
            hr=m_pEnumClsObj->Next(WBEM_INFINITE,1,&m_pWbemClsObj,&uReturn);  
            if(SUCCEEDED(hr)&&uReturn>0)   
            {  
                //從m_pWbemClsObj中找出ClassMember標識的成員屬性值,並保存到vtProp變量中  
                hr=m_pWbemClsObj->Get(CComBSTR(ClassMember),0,&vtProp,0,0);  
                if (SUCCEEDED(hr))  
                {  
                    VariantToString(&vtProp,chRetValue);  
                    VariantClear(&vtProp);//清空vtProp  
                    bRet = TRUE;  
                }  
            }  
        }  
    }  
    if(NULL != m_pEnumClsObj)   
    {  
        hr=m_pEnumClsObj->Release();  
        m_pEnumClsObj = NULL;  
    }  
    if(NULL != m_pWbemClsObj)   
    {  
        hr=m_pWbemClsObj->Release();  
        m_pWbemClsObj = NULL;  
    }  
    return bRet;  
}  
  
BOOL CWmiInfo::GetGroupItemInfo(CString ClassName,CString ClassMember[],int n,CString &chRetValue)  
{  
    USES_CONVERSION;  
  
    CComBSTR query("SELECT * FROM ");  
    CString result,info;  
    VARIANT vtProp;  
    ULONG uReturn;  
    HRESULT hr;  
    int i;  
    BOOL bRet = FALSE;  
    if (NULL  != m_pWbemSvc)  
    {  
        query+=CComBSTR(ClassName);  
        hr=m_pWbemSvc->ExecQuery(CComBSTR("WQL"),query,WBEM_FLAG_FORWARD_ONLY|WBEM_FLAG_RETURN_IMMEDIATELY,0,&m_pEnumClsObj);  
        if (SUCCEEDED(hr))  
        {  
            VariantInit(&vtProp); //初始化vtProp變量  
            if(m_pEnumClsObj)    
            {  
                Sleep(10);  
                uReturn=0;  
                hr=m_pEnumClsObj->Next(WBEM_INFINITE,1,&m_pWbemClsObj,&uReturn);  
                if (SUCCEEDED(hr) &&uReturn>0)  
                {  
                    for(i=0;i<n;++i)  
                    {  
                        hr=m_pWbemClsObj->Get(CComBSTR(ClassMember[i]),0,&vtProp,0,0);  
                        if (SUCCEEDED(hr))  
                        {  
                            VariantToString(&vtProp,info);  
                            chRetValue+=info+_T("\t");  
                            VariantClear(&vtProp);  
                            bRet = TRUE;  
                        }  
                    }  
                    chRetValue+=_T("\r\n");  
                }  
            }  
        }  
    }  
  
    if(NULL != m_pEnumClsObj)  
    {  
        hr=m_pEnumClsObj->Release();  
        m_pEnumClsObj=NULL;  
    }  
    if(NULL != m_pWbemClsObj)  
    {  
        hr=m_pWbemClsObj->Release();  
        m_pWbemClsObj=NULL;  
    }  
    return bRet;  
}  
  
void CWmiInfo::VariantToString(const LPVARIANT pVar,CString &chRetValue) const  
{  
    USES_CONVERSION;  
  
    CComBSTR HUGEP* pBstr;  
    BYTE HUGEP* pBuf;  
    LONG low,high,i;  
    HRESULT hr;  
  
    switch(pVar->vt)  
    {  
    case VT_BSTR:  
        {  
            chRetValue=W2T(pVar->bstrVal);  
        }  
        break;  
    case VT_BOOL:  
        {  
            if(VARIANT_TRUE==pVar->boolVal)   
                chRetValue="是";  
            else  
                chRetValue="否";  
        }  
        break;  
    case VT_I4:  
        {  
            chRetValue.Format(_T("%d"),pVar->lVal);  
        }  
        break;  
    case VT_UI1:  
        {  
            chRetValue.Format(_T("%d"),pVar->bVal);  
        }  
        break;  
    case VT_UI4:  
        {  
            chRetValue.Format(_T("%d"),pVar->ulVal);  
        }  
        break;  
  
    case VT_BSTR|VT_ARRAY:  
        {  
            hr=SafeArrayAccessData(pVar->parray,(void HUGEP**)&pBstr);  
            hr=SafeArrayUnaccessData(pVar->parray);  
            chRetValue=W2T(pBstr->m_str);  
        }  
        break;  
  
    case VT_I4|VT_ARRAY:  
        {  
            SafeArrayGetLBound(pVar->parray,1,&low);   
            SafeArrayGetUBound(pVar->parray,1,&high);  
  
            hr=SafeArrayAccessData(pVar->parray,(void HUGEP**)&pBuf);  
            hr=SafeArrayUnaccessData(pVar->parray);  
            CString strTmp;  
            high=min(high,MAX_PATH*2-1);  
            for(i=low;i<=high;++i)  
            {  
                strTmp.Format(_T("%02X"),pBuf[i]);  
                chRetValue+=strTmp;  
            }  
        }  
        break;  
    default:  
        break;  
    }  
}</pre>  
<p>   上面就是一個WMI的封裝，返回參數均以CString類型返回調用順序：</p>  
<p>1.實例化一個CWmiInfo類對象</p>  
<p>2.調用InitWmi()函數初始化COM組件等。。。函數中有說明必須調用InitWmi初始化WMI組件，否則所有調用都無意義。</p>  
<p>3.調用GetXXX方法獲取你要獲取的字段值。</p>  
<p>4.最后使用完CWmiInfo類對象之后一定要記得調用ReleaseWmi()函數來釋放資源</p>  
<p>調用說明：</p>  
<pre class="cpp" name="code">/*GetSingleItemInfo() 
    第一個參數為要查詢的類名如"Win32_Processor"表示CPU類, 
    第二個參數表示要查的類的成員,如"Caption"表示查詢CPU的名稱 
    第三個參數表示返回值.故可以這樣調用 
    CString strRetValue; 
    GetSingleItemInfo(_T("Win32_Processor"),_T("Caption"),strRetValue); 
    一樣調用成功后即可從strRetValue參數中讀取出CPU的名稱*/</pre><pre class="cpp" name="code">/*GetGroupItemInfo 函數與GetSingleItemInfo類似,不同的是GetSingleItemInfo一次只能查一個類成員而GetGroupItemInfo一次可以查詢一個類的多個成員.GetGroupItemInfo的第三個參數表示要查詢的類成員的個數,即:第二個參數CString數組的大小可以這樣調用：CString strRetValue;CString [] strClassMem = {_T("Caption"),_T("CurrentClockSpeed"),_T("DeviceID"),_T("Manufacturer"),_T("Manufacturer")};GetGroupItemInfo(_T("Win32_Processor"),strClassMem,5,strRetValue);*/</pre>  
<p>    可以看出WMI的調用是相當的簡單只需傳入你想要查詢的字段所在的類名和類對象名即可~~~也許到這里有淫還會問、、、、我他媽怎么知道類名叫神馬咧？？？？類中有哪些對象咧？？？？？</p>  
<p>    M。。。S。。。。D。。。N  可以幫到你！！！</p>  
<p>這里教大家一個技巧，WMI的字段類名好像都是以Win32_開頭。。。。如：Win32_Processor，Win32_PhysicalMemory等等。。。所以，你只要在MSDN輸入Win32_就會看到很多以WMI結尾的類了。。。剩下的就是你的English水平問題了，這里google也可以幫你，如果你需要的話。</p>  
<p>下面給大家列出一些常用的類名：</p>  
<pre class="cpp" name="code">     // 硬件信息類名  
      Win32_Processor, // CPU 處理器  
    Win32_PhysicalMemory, // 物理內存條  
    Win32_Keyboard, // 鍵盤  
    Win32_PointingDevice, // 點輸入設備，包括鼠標。  
    Win32_FloppyDrive, // 軟盤驅動器  
    Win32_DiskDrive, // 硬盤驅動器  
    Win32_CDROMDrive, // 光盤驅動器  
    Win32_BaseBoard, // 主板  
    Win32_BIOS, // BIOS 芯片  
    Win32_ParallelPort, // 並口  
    Win32_SerialPort, // 串口  
    Win32_SerialPortConfiguration, // 串口配置  
    Win32_SoundDevice, // 多媒體設置，一般指聲卡。  
    Win32_SystemSlot, // 主板插槽 (ISA & PCI & AGP)  
    Win32_USBController, // USB 控制器  
    Win32_NetworkAdapter, // 網絡適配器  
    Win32_NetworkAdapterConfiguration, // 網絡適配器設置  
    Win32_Printer, // 打印機  
    Win32_PrinterConfiguration, // 打印機設置  
    Win32_PrintJob, // 打印機任務  
    Win32_TCPIPPrinterPort, // 打印機端口  
    Win32_POTSModem, // MODEM  
    Win32_POTSModemToSerialPort, // MODEM 端口  
    Win32_DesktopMonitor, // 顯示器  
    Win32_DisplayConfiguration, // 顯卡  
    Win32_DisplayControllerConfiguration, // 顯卡設置  
    Win32_VideoController, // 顯卡細節。  
    Win32_VideoSettings, // 顯卡支持的顯示模式。  
  
    // 操作系統  
    Win32_TimeZone, // 時區  
    Win32_SystemDriver, // 驅動程序  
    Win32_DiskPartition, // 磁盤分區  
    Win32_LogicalDisk, // 邏輯磁盤  
    Win32_LogicalDiskToPartition, // 邏輯磁盤所在分區及始末位置。  
    Win32_LogicalMemoryConfiguration, // 邏輯內存配置  
    Win32_PageFile, // 系統頁文件信息  
    Win32_PageFileSetting, // 頁文件設置  
    Win32_BootConfiguration, // 系統啟動配置  
    Win32_ComputerSystem, // 計算機信息簡要  
    Win32_OperatingSystem, // 操作系統信息  
    Win32_StartupCommand, // 系統自動啟動程序  
    Win32_Service, // 系統安裝的服務  
    Win32_Group, // 系統管理組  
    Win32_GroupUser, // 系統組帳號  
    Win32_UserAccount, // 用戶帳號  
    Win32_Process, // 系統進程  
    Win32_Thread, // 系統線程  
    Win32_Share, // 共享  
    Win32_NetworkClient, // 已安裝的網絡客戶端  
    Win32_NetworkProtocol, // 已安裝的網絡協議  
</pre>  
<p>   在、msdn中輸入相應的類名即可查看個類中包括的類成員及其含義~~</p>  
<p>       正如前面所說，WMI使用相當方便，但是速度太慢，API比較復雜，但是速度很給力~~~~~可以根據自己的需求來選用實現方式~~~~</p>  
<p>  以上代碼均已在vs2008中編譯通過~~~~可以直接使用~~~~~~有不當的地方請指教！！</p>  
<p></p>  
<pre></pre>