获取计算机硬件信息

获取计算机硬件信息

cpu

HKEY hKey;
	long lResult;
	lResult = RegOpenKeyEx(HKEY_LOCAL_MACHINE, _T("HARDWARE\\DESCRIPTION\\System\\CentralProcessor\\0"), 0, KEY_READ, &hKey);

	DWORD dwSize = 200;
	TCHAR CpuString[200];
	DWORD dwType = REG_SZ;
	if (lResult == ERROR_SUCCESS)
	{
		RegQueryValueEx(hKey, _T("ProcessorNameString"), NULL, &dwType, (LPBYTE)CpuString, &dwSize);
	}

	char CPUInfo[200];
	WideCharToMultiByte(CP_UTF8, 0, CpuString, dwSize, CPUInfo, 100, NULL, NULL);
	RegCloseKey(hKey);

CPU的信息是最简单获取到，就在系统的注册表之中。这里我有24个核心，所有CentralProcessor下面有24个项目，每个里面都有这个字段，一般最少有一个核心，所以取0的数据就可以了，如果电脑的cpu有多个且不同型号，是可能读出多个不同cpu型号的，看个人需要了。

显卡

DISPLAY_DEVICE disp;
	FMemory::Memset(&disp, 0, sizeof(DISPLAY_DEVICE));
	disp.cb = sizeof(DISPLAY_DEVICE);

	int nVgaCnt = 0;
	while (EnumDisplayDevices(NULL, nVgaCnt, &disp, 0))
	{
		if (disp.StateFlags & DISPLAY_DEVICE_PRIMARY_DEVICE)
		{
			char DeviceInfo[100];
			WideCharToMultiByte(CP_UTF8, 0, disp.DeviceString, 100, DeviceInfo, 100, NULL, NULL);
			FMemory::Memcpy(g_PLOSI.xM3, DeviceInfo, 100);
		}

		nVgaCnt++;
	}

硬盘

char* flipAndCodeBytes(const char* str,
    int pos,
    int flip,
    char* buf)
{
    int i;
    int j = 0;
    int k = 0;

    buf[0] = '\0';
    if (pos <= 0)
        return buf;

    if (!j)
    {
        char p = 0;

        // First try to gather all characters representing hex digits only.
        j = 1;
        k = 0;
        buf[k] = 0;
        for (i = pos; j && str[i] != '\0'; ++i)
        {
            char c = tolower(str[i]);

            if (isspace(c))
                c = '0';

            ++p;
            buf[k] <<= 4;

            if (c >= '0' && c <= '9')
                buf[k] |= (unsigned char)(c - '0');
            else if (c >= 'a' && c <= 'f')
                buf[k] |= (unsigned char)(c - 'a' + 10);
            else
            {
                j = 0;
                break;
            }

            if (p == 2)
            {
                if (buf[k] != '\0' && !isprint(buf[k]))
                {
                    j = 0;
                    break;
                }
                ++k;
                p = 0;
                buf[k] = 0;
            }

        }
    }

    if (!j)
    {
        // There are non-digit characters, gather them as is.
        j = 1;
        k = 0;
        for (i = pos; j && str[i] != '\0'; ++i)
        {
            char c = str[i];

            if (!isprint(c))
            {
                j = 0;
                break;
            }

            buf[k++] = c;
        }
    }

    if (!j)
    {
        // The characters are not there or are not printable.
        k = 0;
    }

    buf[k] = '\0';

    if (flip)
        // Flip adjacent characters
        for (j = 0; j < k; j += 2)
        {
            char t = buf[j];
            buf[j] = buf[j + 1];
            buf[j + 1] = t;
        }

    // Trim any beginning and end space
    i = j = -1;
    for (k = 0; buf[k] != '\0'; ++k)
    {
        if (!isspace(buf[k]))
        {
            if (i < 0)
                i = k;
            j = k;
        }
    }

    if ((i >= 0) && (j >= 0))
    {
        for (k = i; (k <= j) && (buf[k] != '\0'); ++k)
            buf[k - i] = buf[k];
        buf[k - i] = '\0';
    }

    return buf;
}


for (int nDriveID = 0; nDriveID < 16; nDriveID++)
    {
        HANDLE hPhysicalDrive = INVALID_HANDLE_VALUE;

        TCHAR szDriveName[32];
        wsprintf(szDriveName, TEXT("\\\\.\\PhysicalDrive%d"), nDriveID);

        //  Windows NT, Windows 2000, Windows XP - admin rights not required
        hPhysicalDrive = CreateFile(szDriveName, 0,
            FILE_SHARE_READ | FILE_SHARE_WRITE, NULL,
            OPEN_EXISTING, 0, NULL);
        if (hPhysicalDrive == INVALID_HANDLE_VALUE)
        {
            continue;
        }

        STORAGE_PROPERTY_QUERY query;
        DWORD cbBytesReturned = 0;
        static char local_buffer[10000];

        memset((void*)&query, 0, sizeof(query));
        query.PropertyId = StorageDeviceProperty;
        query.QueryType = PropertyStandardQuery;

        memset(local_buffer, 0, sizeof(local_buffer));

        if (DeviceIoControl(hPhysicalDrive, IOCTL_STORAGE_QUERY_PROPERTY,
            &query,
            sizeof(query),
            &local_buffer[0],
            sizeof(local_buffer),
            &cbBytesReturned, NULL))
        {
            STORAGE_DEVICE_DESCRIPTOR* descrip = (STORAGE_DEVICE_DESCRIPTOR*)&local_buffer;
            char serialNumber[1000];
            char* aaa = (char*)descrip + descrip->SerialNumberOffset;
            flipAndCodeBytes(local_buffer,
                descrip->SerialNumberOffset,
                0, serialNumber);

            if (isalnum(serialNumber[0]))
            {
                ULONG ulSerialLenTemp = strnlen(serialNumber, 1023);
                char pszIDBuff[1024];
                memcpy(pszIDBuff, serialNumber, ulSerialLenTemp);
                pszIDBuff[ulSerialLenTemp] = NULL;
                cout <<"serialNumber"<<nDriveID<<":"<< pszIDBuff << endl;

                //return 0;
            }
        }
    }

可以看到这里硬盘序列号是一样的。

网卡

IP_ADAPTER_INFO AdapterInfo[16];			// Allocate information for up to 16 NICs
	DWORD size = sizeof(AdapterInfo);
	DWORD dwStatus = GetAdaptersInfo(AdapterInfo, &size);
	if (dwStatus != ERROR_SUCCESS)
	{
		return;
	}

操作系统

typedef INT_PTR (WINAPI* PGNSI)(LPSYSTEM_INFO);
typedef INT_PTR (WINAPI* PGPI)(DWORD, DWORD, DWORD, DWORD, PDWORD);


OSVERSIONINFOEX osvi;
	SYSTEM_INFO si;
	PGNSI pGNSI;
	PGPI pGPI;

	FMemory::Memset(&si, 0, sizeof(SYSTEM_INFO));
	FMemory::Memset(&osvi, 0, sizeof(OSVERSIONINFOEX));
	osvi.dwOSVersionInfoSize = sizeof(OSVERSIONINFOEX);

#pragma warning(disable:4996)
	if (GetVersionEx((OSVERSIONINFO*)&osvi) == 0)
	{
		return false;
	}

	pGNSI = (PGNSI)GetProcAddress(GetModuleHandle(TEXT("kernel32.dll")), "GetNativeSystemInfo");
	if (0 != pGNSI)
	{
		pGNSI(&si);
	}
	else
	{
		GetSystemInfo(&si);
	}

	if (VER_PLATFORM_WIN32_NT == osvi.dwPlatformId && osvi.dwMajorVersion > 4)
	{
		StringCchCopy(pszOS, MAX_LEN1, TEXT("Microsoft "));

		if (osvi.dwMajorVersion == 6)
		{
			if (osvi.dwMinorVersion == 0)
			{
				if (osvi.wProductType == VER_NT_WORKSTATION)
					StringCchCat(pszOS, MAX_LEN1, TEXT("Windows Vista "));
				else StringCchCat(pszOS, MAX_LEN1, TEXT("Windows Server 2008 "));
			}

			if (osvi.dwMinorVersion == 1)
			{
				if (osvi.wProductType == VER_NT_WORKSTATION)
					StringCchCat(pszOS, MAX_LEN1, TEXT("Windows 7 "));
				else StringCchCat(pszOS, MAX_LEN1, TEXT("Windows Server 2008 R2 "));
			}

			pGPI = (PGPI)GetProcAddress(GetModuleHandle(TEXT("kernel32.dll")), "GetProductInfo");

			DWORD dwType;
			pGPI(osvi.dwMajorVersion, osvi.dwMinorVersion, 0, 0, &dwType);
			switch (dwType)
			{
			case PRODUCT_ULTIMATE:
				StringCchCat(pszOS, MAX_LEN1, TEXT("Ultimate Edition"));
				break;
			case PRODUCT_PROFESSIONAL:
				StringCchCat(pszOS, MAX_LEN1, TEXT("Professional"));
				break;
			case PRODUCT_HOME_PREMIUM:
				StringCchCat(pszOS, MAX_LEN1, TEXT("Home Premium Edition"));
				break;
			case PRODUCT_HOME_BASIC:
				StringCchCat(pszOS, MAX_LEN1, TEXT("Home Basic Edition"));
				break;
			default:
				StringCchCat(pszOS, MAX_LEN1, TEXT("etc Edition"));
				break;
			}
		}

		if (osvi.dwMajorVersion == 5 && osvi.dwMinorVersion == 2)
		{

			if (osvi.wSuiteMask & VER_SUITE_STORAGE_SERVER)
				StringCchCat(pszOS, MAX_LEN1, TEXT("Windows Storage Server 2003"));
			else if (osvi.wProductType == VER_NT_WORKSTATION &&
				si.wProcessorArchitecture == PROCESSOR_ARCHITECTURE_AMD64)
			{
				StringCchCat(pszOS, MAX_LEN1, TEXT("Windows XP Professional x64 Edition"));
			}
			else StringCchCat(pszOS, MAX_LEN1, 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, MAX_LEN1, TEXT("Datacenter Edition for Itanium-based Systems"));
					else if (osvi.wSuiteMask & VER_SUITE_ENTERPRISE)
						StringCchCat(pszOS, MAX_LEN1, TEXT("Enterprise Edition for Itanium-based Systems"));
				}

				else if (si.wProcessorArchitecture == PROCESSOR_ARCHITECTURE_AMD64)
				{
					if (osvi.wSuiteMask & VER_SUITE_DATACENTER)
						StringCchCat(pszOS, MAX_LEN1, TEXT("Datacenter x64 Edition"));
					else if (osvi.wSuiteMask & VER_SUITE_ENTERPRISE)
						StringCchCat(pszOS, MAX_LEN1, TEXT("Enterprise x64 Edition"));
					else StringCchCat(pszOS, MAX_LEN1, TEXT("Standard x64 Edition"));
				}

				else
				{
					if (osvi.wSuiteMask & VER_SUITE_COMPUTE_SERVER)
						StringCchCat(pszOS, MAX_LEN1, TEXT("Compute Cluster Edition"));
					else if (osvi.wSuiteMask & VER_SUITE_DATACENTER)
						StringCchCat(pszOS, MAX_LEN1, TEXT("Datacenter Edition"));
					else if (osvi.wSuiteMask & VER_SUITE_ENTERPRISE)
						StringCchCat(pszOS, MAX_LEN1, TEXT("Enterprise Edition"));
					else if (osvi.wSuiteMask & VER_SUITE_BLADE)
						StringCchCat(pszOS, MAX_LEN1, TEXT("Web Edition"));
					else StringCchCat(pszOS, MAX_LEN1, TEXT("Standard Edition"));
				}
			}
		}

		if (osvi.dwMajorVersion == 5 && osvi.dwMinorVersion == 1)
		{
			StringCchCat(pszOS, MAX_LEN1, TEXT("Windows XP "));
			if (osvi.wSuiteMask & VER_SUITE_PERSONAL)
				StringCchCat(pszOS, MAX_LEN1, TEXT("Home Edition"));
			else StringCchCat(pszOS, MAX_LEN1, TEXT("Professional"));
		}

		if (osvi.dwMajorVersion == 5 && osvi.dwMinorVersion == 0)
		{
			StringCchCat(pszOS, MAX_LEN1, TEXT("Windows 2000 "));

			if (osvi.wProductType == VER_NT_WORKSTATION)
			{
				StringCchCat(pszOS, MAX_LEN1, TEXT("Professional"));
			}
			else
			{
				if (osvi.wSuiteMask & VER_SUITE_DATACENTER)
					StringCchCat(pszOS, MAX_LEN1, TEXT("Datacenter Server"));
				else if (osvi.wSuiteMask & VER_SUITE_ENTERPRISE)
					StringCchCat(pszOS, MAX_LEN1, TEXT("Advanced Server"));
				else StringCchCat(pszOS, MAX_LEN1, TEXT("Server"));
			}
		}

		if (_tcslen(osvi.szCSDVersion) > 0)
		{
			StringCchCat(pszOS, MAX_LEN1, TEXT(" "));
			StringCchCat(pszOS, MAX_LEN1, osvi.szCSDVersion);
		}

		TCHAR buf[80];

		StringCchPrintf(buf, 80, TEXT(" (build %d)"), osvi.dwBuildNumber);
		StringCchCat(pszOS, MAX_LEN1, buf);

		if (osvi.dwMajorVersion >= 6)
		{
			if (si.wProcessorArchitecture == PROCESSOR_ARCHITECTURE_AMD64)
				StringCchCat(pszOS, MAX_LEN1, TEXT(", 64-bit"));
			else if (si.wProcessorArchitecture == PROCESSOR_ARCHITECTURE_INTEL)
				StringCchCat(pszOS, MAX_LEN1, TEXT(", 32-bit"));
		}

		return true;
	}
	else
	{
		//printf("This sample does not support this version of Windows.\n");
		return false;
	}