OpenHardwareMonitor.h

OpenHardwareMonitor.h 是一个开源的硬件监测库，用于监测计算机硬件的各种参数，如CPU温度、GPU温度、风扇转速等。它提供了一个简单易用的API，可以方便地在自己的程序中使用。该库支持Windows和Linux系统，并且可以通过WMI（Windows Management Instrumentation）或内核驱动程序获取系统信息。OpenHardwareMonitor.h还提供了一个GUI工具，用于显示系统硬件信息和监测数据。

相关问题

OpenHardwareMonitor.h头文件

以下是OpenHardwareMonitor.h头文件的示例代码，你可以将它保存为OpenHardwareMonitor.h文件，然后在你的VC2010项目中引用它：

#pragma once

#include <Windows.h>
#include <vector>
#include <string>

namespace OHM
{
    enum class SensorType
    {
        Voltage,
        Clock,
        Temperature,
        Load,
        Fan,
        Flow,
        Control,
        Level,
        Factor,
        Power,
        Data,
        SmallData,
        Throughput,
        None
    };

    enum class HardwareType
    {
        Mainboard,
        SuperIO,
        CPU,
        RAM,
        GpuNvidia,
        GpuAti,
        TBalancer,
        Heatmaster,
        HDD,
        SSD,
        Heatcore,
        Generic,
        None
    };

    struct Sensor
    {
        std::string Name;
        std::string Identifier;
        float Value;
        SensorType SensorType;
        float Min;
        float Max;
        float DefaultMin;
        float DefaultMax;

        Sensor(const std::string& name, const std::string& identifier, float value, SensorType sensorType, float min, float max, float defaultMin, float defaultMax)
            : Name(name), Identifier(identifier), Value(value), SensorType(sensorType), Min(min), Max(max), DefaultMin(defaultMin), DefaultMax(defaultMax)
        {
        }
    };

    struct Hardware
    {
        std::string Name;
        std::string Identifier;
        HardwareType HardwareType;
        std::vector<Sensor*> Sensors;

        Hardware(const std::string& name, const std::string& identifier, HardwareType hardwareType)
            : Name(name), Identifier(identifier), HardwareType(hardwareType)
        {
        }

        ~Hardware()
        {
            for (Sensor* sensor : Sensors)
            {
                delete sensor;
            }
            Sensors.clear();
        }

        void Update()
        {
            for (Sensor* sensor : Sensors)
            {
                if (sensor)
                {
                    float value;
                    if (GetSensorValue(Identifier.c_str(), sensor->Identifier.c_str(), &value))
                    {
                        sensor->Value = value;
                    }
                }
            }
        }
    };

    class OpenHardwareMonitor
    {
    public:
        OpenHardwareMonitor()
        {
            LoadLib();
            Init();
        }

        ~OpenHardwareMonitor()
        {
            Close();
            UnloadLib();
        }

        bool IsValid() const
        {
            return m_IsValid;
        }

        std::vector<Hardware*> GetHardware() const
        {
            std::vector<Hardware*> hardware;
            if (m_GetHardware)
            {
                int count = m_GetHardware(nullptr, 0);
                if (count > 0)
                {
                    OHM::Hardware** hw = new OHM::Hardware*[count];
                    m_GetHardware(hw, count);
                    for (int i = 0; i < count; i++)
                    {
                        hardware.push_back(hw[i]);
                    }
                    delete[] hw;
                }
            }
            return hardware;
        }

    private:
        bool LoadLib()
        {
            m_Lib = LoadLibraryA("OpenHardwareMonitorLib.dll");
            if (m_Lib)
            {
                m_Init = (bool(*)())GetProcAddress(m_Lib, "OpenHardwareMonitor_Initialize");
                m_Close = (void(*)())GetProcAddress(m_Lib, "OpenHardwareMonitor_Close");
                m_GetHardware = (int(*)(OHM::Hardware**, int))GetProcAddress(m_Lib, "OpenHardwareMonitor_GetHardware");
                m_GetSensorValue = (bool(*)(const char*, const char*, float*))GetProcAddress(m_Lib, "OpenHardwareMonitor_GetSensorValue");
                return true;
            }
            return false;
        }

        void UnloadLib()
        {
            if (m_Lib)
            {
                FreeLibrary(m_Lib);
                m_Lib = nullptr;
            }
        }

        bool Init()
        {
            if (m_Init)
            {
                m_IsValid = m_Init();
            }
            return m_IsValid;
        }

        void Close()
        {
            if (m_Close)
            {
                m_Close();
            }
        }

        bool GetSensorValue(const char* hardware, const char* sensor, float* value) const
        {
            if (m_GetSensorValue)
            {
                return m_GetSensorValue(hardware, sensor, value);
            }
            return false;
        }

    private:
        HMODULE m_Lib = nullptr;
        bool m_IsValid = false;
        bool(*m_Init)() = nullptr;
        void(*m_Close)() = nullptr;
        int(*m_GetHardware)(OHM::Hardware**, int) = nullptr;
        bool(*m_GetSensorValue)(const char*, const char*, float*) = nullptr;
    };
}

需要注意的是，使用Open Hardware Monitor需要将它的DLL文件放到可执行文件所在目录下。在VC2010中，可以将它的DLL文件复制到项目目录下，或者将它的路径添加到系统环境变量中。

给我一份 OpenHardwareMonitor.h 或者 去那里下载

OpenHardwareMonitor 是一个开源的硬件监控工具，你可以在它的官方网站上下载最新版本：https://openhardwaremonitor.org/

如果你需要使用 OpenHardwareMonitor 的 C++ API，可以在官方网站的下载页面中找到 "Open Hardware Monitor Developer Package" 下载链接，里面包含了所有需要的头文件和库文件。

在这个 Developer Package 中，你可以找到 OpenHardwareMonitorLib.h 头文件，它包含了 OpenHardwareMonitor 的 C++ API。你可以在你的项目中包含这个头文件，然后使用其中的函数来获取系统硬件信息。