求VC中32/64位系统的判断方法

Question

目前找到了如下两个函数：GetSystemInfo（）/GetNativeSystemInfo（）
有如下3个问题：
1.是否还有其他方法实现此判断功能？
2.MSDN没看太明白，GetSystemInfo（是否是win2000后的系统中都支持？）/GetNativeSystemInfo（XP后的系统都支持？）但为什么我的系统是WinXP,而用GetSystemInfo（可以编译过）/GetNativeSystemInfo（编译失）？
3.另外有人说这两个函数有在双核的机器上判断不准，是不是真的这样？

Answer 1

typedef BOOL (WINAPI *LPFN_ISWOW64PROCESS) (HANDLE, PBOOL);LPFN_ISWOW64PROCESS fnIsWow64Process;BOOL IsWow64()
{
BOOL bIsWow64 = FALSE;
fnIsWow64Process = (LPFN_ISWOW64PROCESS) GetProcAddress(
GetModuleHandle(TEXT("kernel32")),"IsWow64Process");
if (NULL != fnIsWow64Process)
{ fnIsWow64Process(GetCurrentProcess(),&bIsWow64);
//if (!fnIsWow64Process(GetCurrentProcess(),&bIsWow64))
//{
// // handle error
// AfxMessageBox(_T("IsWow64 error!"));
//}
}
return bIsWow64;
}来自msdn

Answer 2

1、IsWow64Process，XPSP2以上系统支持。
2、GetSystemInfo从95/NT开始就支持了，不能用于判断WOW64；GetNativeSystemInfo从XP开始支持，在程序中包含Windows.h前需要#define _WIN32_WINNT 0x0501以上。
3、与处理器个数无关。

Answer 3

IsWow64Process()是MSDN上推崇的.
不过,理论上来说,也可以用一个int的大小作为参考,
判断是32位还是64位.
sizeof(int) == 4 //32位系统.
sizeof(int) == 8 //64位系统.
以上纯粹猜测.没实践过.

Answer 4

BOOL IsWow64() 
{ 
    typedef BOOL (WINAPI *LPFN_ISWOW64PROCESS) (HANDLE, PBOOL); 
    LPFN_ISWOW64PROCESS fnIsWow64Process; 
    BOOL bIsWow64 = FALSE; 
    fnIsWow64Process = (LPFN_ISWOW64PROCESS)GetProcAddress( GetModuleHandle("kernel32"),"IsWow64Process"); 
    if (NULL != fnIsWow64Process) 
    { 
        fnIsWow64Process(GetCurrentProcess(),&bIsWow64);
    } 
    return bIsWow64; 
} 

Answer 5

如果我没记错，long也还是4，只有指针变成8

Answer 6

#include <windows.h>
#include <tchar.h>
#include <stdio.h>
#include <strsafe.h>#pragma comment(lib, "User32.lib")#define BUFSIZE 256typedef void (WINAPI *PGNSI)(LPSYSTEM_INFO);
typedef BOOL (WINAPI *PGPI)(DWORD, DWORD, DWORD, DWORD, PDWORD);BOOL GetOSDisplayString( LPTSTR pszOS)
{
   OSVERSIONINFOEX osvi;
   SYSTEM_INFO si;
   PGNSI pGNSI;
   PGPI pGPI;
   BOOL bOsVersionInfoEx;
   DWORD dwType;   ZeroMemory(&si, sizeof(SYSTEM_INFO));
   ZeroMemory(&osvi, sizeof(OSVERSIONINFOEX));   osvi.dwOSVersionInfoSize = sizeof(OSVERSIONINFOEX);   if( !(bOsVersionInfoEx = GetVersionEx ((OSVERSIONINFO *) &osvi)) )
      return 1;   // Call GetNativeSystemInfo if supported or GetSystemInfo otherwise.   pGNSI = (PGNSI) GetProcAddress(
      GetModuleHandle(TEXT("kernel32.dll")), 
      "GetNativeSystemInfo");
   if(NULL != pGNSI)
      pGNSI(&si);
   else GetSystemInfo(&si);   if ( VER_PLATFORM_WIN32_NT==osvi.dwPlatformId && 
        osvi.dwMajorVersion > 4 )
   {
      StringCchCopy(pszOS, BUFSIZE, TEXT("Microsoft "));      // Test for the specific product.      if ( osvi.dwMajorVersion == 6 )
      {
         if( osvi.dwMinorVersion == 0 )
         {
            if( osvi.wProductType == VER_NT_WORKSTATION )
                StringCchCat(pszOS, BUFSIZE, TEXT("Windows Vista "));
            else StringCchCat(pszOS, BUFSIZE, TEXT("Windows Server 2008 " ));
         }         if ( osvi.dwMinorVersion == 1 )
         {
            if( osvi.wProductType == VER_NT_WORKSTATION )
                StringCchCat(pszOS, BUFSIZE, TEXT("Windows 7 "));
            else StringCchCat(pszOS, BUFSIZE, TEXT("Windows Server 2008 R2 " ));
         }
         
         pGPI = (PGPI) GetProcAddress(
            GetModuleHandle(TEXT("kernel32.dll")), 
            "GetProductInfo");         pGPI( osvi.dwMajorVersion, osvi.dwMinorVersion, 0, 0, &dwType);         switch( dwType )
         {
            case PRODUCT_ULTIMATE:
               StringCchCat(pszOS, BUFSIZE, TEXT("Ultimate Edition" ));
               break;
            case PRODUCT_PROFESSIONAL:
               StringCchCat(pszOS, BUFSIZE, TEXT("Professional" ));
               break;
            case PRODUCT_HOME_PREMIUM:
               StringCchCat(pszOS, BUFSIZE, TEXT("Home Premium Edition" ));
               break;
            case PRODUCT_HOME_BASIC:
               StringCchCat(pszOS, BUFSIZE, TEXT("Home Basic Edition" ));
               break;
            case PRODUCT_ENTERPRISE:
               StringCchCat(pszOS, BUFSIZE, TEXT("Enterprise Edition" ));
               break;
            case PRODUCT_BUSINESS:
               StringCchCat(pszOS, BUFSIZE, TEXT("Business Edition" ));
               break;
            case PRODUCT_STARTER:
               StringCchCat(pszOS, BUFSIZE, TEXT("Starter Edition" ));
               break;
            case PRODUCT_CLUSTER_SERVER:
               StringCchCat(pszOS, BUFSIZE, TEXT("Cluster Server Edition" ));
               break;
            case PRODUCT_DATACENTER_SERVER:
               StringCchCat(pszOS, BUFSIZE, TEXT("Datacenter Edition" ));
               break;
            case PRODUCT_DATACENTER_SERVER_CORE:
               StringCchCat(pszOS, BUFSIZE, TEXT("Datacenter Edition (core installation)" ));
               break;
            case PRODUCT_ENTERPRISE_SERVER:
               StringCchCat(pszOS, BUFSIZE, TEXT("Enterprise Edition" ));
               break;
            case PRODUCT_ENTERPRISE_SERVER_CORE:
               StringCchCat(pszOS, BUFSIZE, TEXT("Enterprise Edition (core installation)" ));
               break;
            case PRODUCT_ENTERPRISE_SERVER_IA64:
               StringCchCat(pszOS, BUFSIZE, TEXT("Enterprise Edition for Itanium-based Systems" ));
               break;
            case PRODUCT_SMALLBUSINESS_SERVER:
               StringCchCat(pszOS, BUFSIZE, TEXT("Small Business Server" ));
               break;
            case PRODUCT_SMALLBUSINESS_SERVER_PREMIUM:
               StringCchCat(pszOS, BUFSIZE, TEXT("Small Business Server Premium Edition" ));
               break;
            case PRODUCT_STANDARD_SERVER:
               StringCchCat(pszOS, BUFSIZE, TEXT("Standard Edition" ));
               break;
            case PRODUCT_STANDARD_SERVER_CORE:
               StringCchCat(pszOS, BUFSIZE, TEXT("Standard Edition (core installation)" ));
               break;
            case PRODUCT_WEB_SERVER:
               StringCchCat(pszOS, BUFSIZE, TEXT("Web Server Edition" ));
               break;
         }
      }      if ( osvi.dwMajorVersion == 5 && osvi.dwMinorVersion == 2 )
      {
         if( GetSystemMetrics(SM_SERVERR2) )
            StringCchCat(pszOS, BUFSIZE, TEXT( "Windows Server 2003 R2, "));
         else if ( osvi.wSuiteMask & VER_SUITE_STORAGE_SERVER )
            StringCchCat(pszOS, BUFSIZE, TEXT( "Windows Storage Server 2003"));
         else if ( osvi.wSuiteMask & VER_SUITE_WH_SERVER )
            StringCchCat(pszOS, BUFSIZE, TEXT( "Windows Home Server"));
         else if( osvi.wProductType == VER_NT_WORKSTATION &&
                  si.wProcessorArchitecture==PROCESSOR_ARCHITECTURE_AMD64)
         {
            StringCchCat(pszOS, BUFSIZE, TEXT( "Windows XP Professional x64 Edition"));
         }
         else StringCchCat(pszOS, BUFSIZE, TEXT("Windows Server 2003, "));         // Test for the server type.
         if ( osvi.wProductType != VER_NT_WORKSTATION )
         {
            if ( si.wProcessorArchitecture==PROCESSOR_ARCHITECTURE_IA64 )
            {
                if( osvi.wSuiteMask & VER_SUITE_DATACENTER )
                   StringCchCat(pszOS, BUFSIZE, TEXT( "Datacenter Edition for Itanium-based Systems" ));
                else if( osvi.wSuiteMask & VER_SUITE_ENTERPRISE )
                   StringCchCat(pszOS, BUFSIZE, TEXT( "Enterprise Edition for Itanium-based Systems" ));
            }            else if ( si.wProcessorArchitecture==PROCESSOR_ARCHITECTURE_AMD64 )
            {
                if( osvi.wSuiteMask & VER_SUITE_DATACENTER )
                   StringCchCat(pszOS, BUFSIZE, TEXT( "Datacenter x64 Edition" ));
                else if( osvi.wSuiteMask & VER_SUITE_ENTERPRISE )
                   StringCchCat(pszOS, BUFSIZE, TEXT( "Enterprise x64 Edition" ));
                else StringCchCat(pszOS, BUFSIZE, TEXT( "Standard x64 Edition" ));
            }            else
            {
                if ( osvi.wSuiteMask & VER_SUITE_COMPUTE_SERVER )
                   StringCchCat(pszOS, BUFSIZE, TEXT( "Compute Cluster Edition" ));
                else if( osvi.wSuiteMask & VER_SUITE_DATACENTER )
                   StringCchCat(pszOS, BUFSIZE, TEXT( "Datacenter Edition" ));
                else if( osvi.wSuiteMask & VER_SUITE_ENTERPRISE )
                   StringCchCat(pszOS, BUFSIZE, TEXT( "Enterprise Edition" ));
                else if ( osvi.wSuiteMask & VER_SUITE_BLADE )
                   StringCchCat(pszOS, BUFSIZE, TEXT( "Web Edition" ));
                else StringCchCat(pszOS, BUFSIZE, TEXT( "Standard Edition" ));
            }
         }
      }      if ( osvi.dwMajorVersion == 5 && osvi.dwMinorVersion == 1 )
      {
         StringCchCat(pszOS, BUFSIZE, TEXT("Windows XP "));
         if( osvi.wSuiteMask & VER_SUITE_PERSONAL )
            StringCchCat(pszOS, BUFSIZE, TEXT( "Home Edition" ));
         else StringCchCat(pszOS, BUFSIZE, TEXT( "Professional" ));
      }      if ( osvi.dwMajorVersion == 5 && osvi.dwMinorVersion == 0 )
      {
         StringCchCat(pszOS, BUFSIZE, TEXT("Windows 2000 "));         if ( osvi.wProductType == VER_NT_WORKSTATION )
         {
            StringCchCat(pszOS, BUFSIZE, TEXT( "Professional" ));
         }
         else 
         {
            if( osvi.wSuiteMask & VER_SUITE_DATACENTER )
               StringCchCat(pszOS, BUFSIZE, TEXT( "Datacenter Server" ));
            else if( osvi.wSuiteMask & VER_SUITE_ENTERPRISE )
               StringCchCat(pszOS, BUFSIZE, TEXT( "Advanced Server" ));
            else StringCchCat(pszOS, BUFSIZE, TEXT( "Server" ));
         }
      }       // Include service pack (if any) and build number.      if( _tcslen(osvi.szCSDVersion) > 0 )
      {
          StringCchCat(pszOS, BUFSIZE, TEXT(" ") );
          StringCchCat(pszOS, BUFSIZE, osvi.szCSDVersion);
      }      TCHAR buf[80];      StringCchPrintf( buf, 80, TEXT(" (build %d)"), osvi.dwBuildNumber);
      StringCchCat(pszOS, BUFSIZE, buf);      if ( osvi.dwMajorVersion >= 6 )
      {
         if ( si.wProcessorArchitecture==PROCESSOR_ARCHITECTURE_AMD64 )
            StringCchCat(pszOS, BUFSIZE, TEXT( ", 64-bit" ));
         else if (si.wProcessorArchitecture==PROCESSOR_ARCHITECTURE_INTEL )
            StringCchCat(pszOS, BUFSIZE, TEXT(", 32-bit"));
      }
      
      return TRUE; 
   }   else
   {  
      printf( "This sample does not support this version of Windows.\n");
      return FALSE;
   }
}int __cdecl _tmain()
{
    TCHAR szOS[BUFSIZE];    if( GetOSDisplayString( szOS ) )
        _tprintf( TEXT("\n%s\n"), szOS );
}

Answer 7

我在Win7的AMD64上试过了
1.sizeof(char*)获得的结果并不是8；
2.通过获取环境变量pwsz = _wgetenv(L"PROCESSOR_ARCHITECTURE")
    结果竟然是"x86",简直无语；
3.GetSystemInfo类函数得到的竟然是"intel"而非AMD64；
另外说明下我是在32bit XP上用VS2008编译的，在XP上执行结果是正确的，而将其放到64bit Win7上以"administrator"执行，每次获得结果竟然都不正确。难道有什么更前提的东西被忽略了吗？IsWow64（）都不敢尝试了，有做过的同仁给指点下吧。

Answer 8

你是 win32 的代码，用 IsWow64Process 就可以的，上面已经回答了啊，为啥不相信呢？我就是用的这个。

Answer 9

win7 64上的结果：sizeof(char):1
sizeof(short):2
sizeof(int):4
sizeof(long):4
sizeof(float):4
sizeof(double):8
sizeof(char*):8

Answer 10

IsWow64Process 和他的问题完全没关系么

Answer 11

谢谢lazy_2010给我的确认信息。我试了确实可行。
又想到如下两个问题：
1.为什么其他方法获取的结果都是不正确的呢？
2.现在可以用IsWow64Process获得是否64bit,如果要细分IA64及AMD64的话又该怎样进一步处理？前面已经说明

Answer 12

#9 的答案貌似对判断 IA64, AMD64 有用，不过我没有这么多硬件设备，没有这样尝试过。另外，找到一个代码，给你参考，但也没有尝试。wstring getCPUType()
{
    SYSTEM_INFO info;
    GetSystemInfo(&info);
    wstring type;
    switch(info.wProcessorArchitecture)
    {
        case PROCESSOR_ARCHITECTURE_INTEL:
            switch(info.wProcessorLevel)
            {
                case PROCESSOR_INTEL_386:
                    type=_T("Intel 386");
                    break;
                case PROCESSOR_INTEL_486:
                    type=_T("Intel 486");
                    break;
                case PROCESSOR_INTEL_PENTIUM:
                    type=_T("Intel Pentium");
                    break;
                case PROCESSOR_INTEL_IA64:
                    type=_T("Intel IA64");
                    break;
                default:
                    type=_T("Intel平台处理器");
                    break;
            }
            break;
        case PROCESSOR_ARCHITECTURE_AMD64:
            if(info.wProcessorLevel==PROCESSOR_AMD_X8664)
                type=_T("AMD X8664");
            else
                type=_T("AMD64平台处理器");
            break;
        case PROCESSOR_ARCHITECTURE_MIPS:
            switch(info.wProcessorLevel)
            {
                case PROCESSOR_MIPS_R4000:
                    type=_T("MIPS R4000");
                    break;
                default:
                    type=_T("MIPS平台处理器");
                    break;
            }
            break;
        case PROCESSOR_ARCHITECTURE_SHX:
            switch(info.wProcessorLevel)
            {
                case PROCESSOR_SHx_SH3:
                    type=_T("SHx SH3");
                    break;
                case PROCESSOR_SHx_SH4:
                    type=_T("SHx SH4");
                    break;
                default:
                    type=_T("SHx平台处理器");
                    break;
            }
            break;
        case PROCESSOR_ARCHITECTURE_ARM:
            switch(info.wProcessorLevel)
            {
                case PROCESSOR_ARM720:
                    type=_T("ARM 720");
                    break;
                case PROCESSOR_ARM820:
                    type=_T("ARM 820");
                    break;
                case PROCESSOR_ARM920:
                    type=_T("ARM 920");
                    break;
                case PROCESSOR_ARM_7TDMI:
                    type=_T("ARM 7TDMI");
                    break;
                default:
                    type=_T("ARM平台处理器");
                    break;
            }
            break;
        case PROCESSOR_ARCHITECTURE_ALPHA:
            switch(info.wProcessorLevel)
            {
                case PROCESSOR_ALPHA_21064:
                    type=_T("Alpha 21064");
                    break;
                default:
                    type=_T("Alpha平台处理器");
                    break;
            }
            break;
        case PROCESSOR_ARCHITECTURE_PPC:
            switch(info.wProcessorLevel)
            {
                case PROCESSOR_PPC_601:
                    type=_T("PPC 610");
                    break;
                case PROCESSOR_PPC_603:
                    type=_T("PPC 603");
                    break;
                case PROCESSOR_PPC_604:
                    type=_T("PPC 604");
                    break;
                case PROCESSOR_PPC_620:
                    type=_T("PPC 620");
                    break;
                default:
                    type=_T("PPC平台处理器");
                    break;
            }
            break;
        default:
            type=_T("未知的处理器平台");
            break;
    }
    return type;
}

Answer 13

GetSystemInfo()的方法前面我已经有说明，所获得结果根本就不正确。

Answer 14

但为什么我的系统是WinXP,而用GetSystemInfo（可以编译过）/GetNativeSystemInfo（编译失）？
-------------------------------------------------------------------------
更新一下平台的SDK包，再试试GetNativeSystemInfo

Answer 15

没一个对的,我的win7 32位系统机器用的是64cpu,结果都成了64位系统,有几个说用sizeof判断更是汗,那是编译时就确定的

Answer 16

算是投机吧  检查系统是否支持PAE  64的WIN好像不用支持PAE  再或者你随便编写一个64的驱动  看能不能加载

Answer 17

64的EXE也行  不能运行的话  肯定就不是64的