Linux下如何使用C++获取硬件信息_Linux

方法

通过读取linux下存放硬件信息的文件来获取cpu、主板、磁盘、bios信息

获取cpu信息：读取"/proc/cpuinfo"文件

字段及其含义：

处理器基本信息：

processor：处理器的逻辑编号，从 0 开始，用于标识系统中的每个逻辑 cpu。
vendor_id：cpu制造商的标识符。例如，对于 intel cpu，可能是genuineintel；对于 amd cpu，可能是authenticamd。

处理器型号与家族信息

cpu family：cpu 所属的家族编号。不同家族的 cpu 可能具有不同的架构和特性。例如，intel 的酷睿系列和至强系列可能属于不同的家族。
model：cpu型号编号，结合cpu family可以更准确地确定 cpu 的具体型号。
model name：cpu 的完整型号名称，提供了详细的 cpu 型号描述，如intel® core™ i7-10700k cpu @ 3.80ghz。

步进与微代码信息：

stepping：cpu的步进编号，它标识了 cpu 的修订版本。不同的步进可能包含对之前版本的错误修复或性能改进。
microcode：cpu微代码版本号，微代码是嵌入在 cpu 中的一小段代码，用于协助 cpu 执行指令，可以通过更新微代码来修复 cpu 的一些问题或提升性能。

性能相关信息：

cpu mhz：cpu当前的运行频率，单位为 mhz。这可能是动态变化的，尤其是在支持节能技术（如 intel 的 speedstep 或 amd 的

cool’n’quiet）的 cpu 上。
cache size：cpu 缓存的大小，通常以 kb 或 mb 为单位。缓存可以提高 cpu 访问数据的速度，较大的缓存通常意味着更好的性能。

多处理器与多核信息：

physical id：物理处理器的标识符。在多处理器系统中，每个物理 cpu 有一个唯一的physical id。
siblings：同一物理 cpu上的逻辑处理器数量，即超线程技术下每个物理核心对应的逻辑核心数。例如，如果一个物理核心支持超线程，siblings可能为 2。
core id：每个物理核心的唯一标识符，在同一物理 cpu 内，不同的物理核心有不同的core id。
cpu cores：每个物理 cpu 中的核心数量，不包括超线程产生的逻辑核心。

其他信息：

apicid：高级可编程中断控制器（apic）标识符，用于多处理器系统中的中断处理。
flags：cpu支持的特性标志列表，每个标志表示 cpu 支持的一种特定功能或指令集，如mmx、sse、sse2等，这些指令集可以加速特定类型的计算任务。
bogomips：代表 “bogusmips（伪每秒百万条指令数）”。它是一种对 cpu 性能的近似估计值，并非基于实际指令执行的精确测量。这个数值最初由 linus torvalds引入 linux 内核，作为一种快速且相对简单的方法来评估 cpu 的处理能力。
clflush size：缓存行刷新（cache line flush）操作所涉及的缓存行大小。

获取磁盘信息：读取"/proc/diskstats"文件

字段及其含义（从左至右）：

主设备号（major device number）：在示例中为8，它标识设备类型。例如，8通常代表scsi 磁盘设备。不同的设备类型有不同的主设备号，可用于识别设备所属的大类。
次设备号（minor device number）：示例中的0，它用于在同一主设备类型下进一步区分具体的设备实例。主设备号和次设备号共同唯一标识系统中的一个块设备。
设备名称（device name）：这里是sda，这是设备在系统中的名称，通常对应/dev目录下的设备文件名，方便用户和系统管理员识别和操作具体设备。
读完成次数（reads completed successfully）：212553，表示从设备成功完成的读操作次数。每次成功读取数据块，该计数增加。
读合并次数（reads merged）：14992，系统有时会合并相邻的读请求以提高 i/o 效率，该字段统计了合并读操作的次数。合并读可以减少i/o 操作的总次数，提升性能。
读扇区数（sectors read）：1469963，表示从设备读取的扇区总数。一个扇区通常是 512 字节（在现代设备中也可能是 4096字节等），这个数字反映了读取的数据量（以扇区为单位）。
读操作花费的毫秒数（time spent reading (ms)）：334512，累计花费在读操作上的时间，以毫秒为单位。它反映了设备读取数据所花费的总时间，可用于评估读性能。
写完成次数（writes completed successfully）：1005650，表示向设备成功完成的写操作次数。每次成功写入数据块，该计数增加。
写合并次数（writes merged）：121259，类似于读合并，系统会合并相邻的写请求，该字段统计了合并写操作的次数，以提高写性能。
写扇区数（sectors written）：6743707，表示向设备写入的扇区总数，反映了写入的数据量（以扇区为单位）。
写操作花费的毫秒数（time spent writing (ms)）：10052256，累计花费在写操作上的时间，以毫秒为单位，可用于评估写性能。
当前i/o 操作数（i/o requests currently in progress）：0，表示当前正在进行的 i/o请求数量。如果这个值持续不为零，可能表示设备出现了 i/o 瓶颈。
i/o操作花费的总毫秒数（time spent doing i/o (ms)）：343049，累计花费在所有 i/o操作（读和写）上的时间，以毫秒为单位。
加权的i/o 操作花费的毫秒数（weighted time spent doing i/o (ms)）：10386768，这是一个加权时间，考虑了i/o 请求的排队时间等因素，能更全面地反映 i/o 操作对系统资源的占用情况。

获取bios信息有两种方法

1.读取文件

可以通过读取三个文件分别获得bios供应商名称、bios版本号、bios发布日期，分别是：

bios供应商名称：/sys/class/dmi/id/bios_vendor

bios版本号：/sys/class/dmi/id/bios_version

bios发布日期：/sys/class/dmi/id/bios_date

优点：

无需 root 权限：普通用户即可访问。无额外依赖：直接通过文件接口读取，避免调用外部命令。适用于容器/虚拟化环境：即使 dmi 信息被限制，部分字段仍可能可用。

缺点：获取到的信息少。

2.使用dmidecode命令

工作方式：dmidecode的工作方式就是解析dmi表

命令：sudo dmidecode -t bios

字段含义：

vendor：bios供应商名称
version：bios版本号
release date：bios发布日期
address：bios在内存中的物理地址（十六进制）
runtime size：bios运行时占用的内存大小
rom size：存储 bios固件的 rom（只读存储器）容量
characteristics：bios支持的特性列表，每个特性对应一个硬件或软件功能
bios revision：bios 的修订版本号（可能与 version 不同）
firmware revision：主板固件的版本号（可能与 bios 版本分离）

优点： 获取的信息更多、更全面。

缺点：

权限要求：dmidecode 需要 root 权限才能读取完整 dmi表，如果运行程序的用户不是root用户会失败。
依赖性：dmidecode方法需要安装该工具（通常默认已安装），常见的安装目录。有"/usr/sbin/dmidecode"、“/sbin/dmidecode”、“/usr/local/sbin/dmidecode”。代码在调用命令前需要先验证是否存在路径。
适用性：虚拟化环境（如容器）中可能无法提供完整的dmi信息。

获取主板信息有两种方法

1.读取文件

可以通过读取文件分别获得主板供应商名称、主板版本号、主板型号，主板序列号，主板资产标签分别是：

主板供应商名称：/sys/class/dmi/id/board_vendor

主板版本号：/sys/class/dmi/id/board_version

主板型号：/sys/class/dmi/id/board_name

主板序列号：/sys/class/dmi/id/board_serial，读取该文件需要root权限，所以代码中无法依靠读取文件获取，但是可以通过dmidecode命令获取（见下文）

主板资产标签：/sys/class/dmi/id/board_asset_tag

优点：

缺点： 获取到的信息少。

2.使用dmidecode命令

工作方式：dmidecode的工作方式就是解析dmi表

命令：sudo dmidecode -t baseboard

字段含义：

manufacturer：主板制造商
product name: 主板型号
version：主板版本号，none为未指定
serial number：主板序列号，none为未指定
asset tag: 资产标签，not specified为未指定
features：主板特殊功能，none为无特殊功能
location in chassis：主板在机箱中的位置，not specified未记录
chassis handle：关联的机箱记录句柄，0x0000为未关联或默认值
type：主板类型，unknown为未明确
contained object handle：关联的子设备，0表示无关联

优点： 获取的信息更多、更全面。

缺点：

权限要求：dmidecode 需要 root 权限才能读取完整 dmi表，如果运行程序的用户不是root用户会失败。
依赖性：dmidecode方法需要安装该工具（通常默认已安装），常见的安装目录。有"/usr/sbin/dmidecode"、“/sbin/dmidecode”、“/usr/local/sbin/dmidecode”。代码在调用命令前需要先验证是否存在路径。
适用性：虚拟化环境（如容器）中可能无法提供完整的dmi信息。

代码部分

linuxhardwareinfo.h

#pragma once

#include <iostream>
#include <fstream>
#include <string>
#include <vector>
#include <string.h>
#include <sstream>
#include <memory>
#include <stdexcept>
#include <array>
#include <sys/types.h>
#include <unistd.h>
#include <stdio.h>
#include <unordered_map>
#include <functional>

// cpu信息结构体
struct cpuinfo
{
    std::string processor_;              // cpu 的逻辑编号
    std::string vendor_id_;              // cpu 制造商的标识符
    std::string cpu_family_;             // cpu 所属的家族编号
    std::string model_;                  // cpu 型号编号
    std::string model_name_;             // cpu 的完整型号名称
    std::string stepping_;               // cpu 的步进编号
    std::string microcode_;              // cpu 微代码版本号
    std::string cpu_freq_;               // cpu 当前的运行频率，单位为 mhz
    std::string cache_size_;             // cpu 缓存的大小，单位为kb
    std::string physical_id_;            // cpu 的标识符
    std::string siblings_;               // 同一物理 cpu 上的逻辑处理器数量
    std::string core_id_;                // 每个物理核心的唯一标识符
    std::string cpu_cores_;              // 每个物理 cpu 中的核心数量，不包括超线程产生的逻辑核心
    std::string clflush_size_;           // 缓存行刷新（cache line flush）操作所涉及的缓存行大小
};

// 磁盘信息结构体
struct diskstatsinfo
{
    std::string major_device_num_;          // 主设备号，标识设备类型
    std::string minor_device_num_;          // 次设备号，用于在同一主设备类型下进一步区分具体的设备实例，主设备号和次设备号共同唯一标识系统中的一个块设备
    std::string device_name_;               // 磁盘名称，对应/dev目录下的设备文件名
    std::string read_completed_;            // 从设备成功完成的读操作次数，每次成功读取数据块，该计数增加
    std::string read_merged_;               // 合并读操作次数
    std::string read_sectors_;              // 从设备读取的扇区总数
    std::string read_time_spent_;           // 累计花费在读操作上的时间，单位毫秒
    std::string write_completed_;           // 向设备成功完成的写操作次数，每次成功写入数据块，该计数增加
    std::string write_merged_;              // 合并写操作次数
    std::string write_sectors_;             // 向设备写入的扇区总数
    std::string write_time_spent_;          // 累计花费在写操作上的时间，单位毫秒
};

// bios信息结构体，细节信息通过dmidecode命令获取到的
struct biosmoreinfo
{
    // 基础信息
    std::string     vendor_;                    // bios供应商
    std::string     version_;                   // bios版本
    std::string     date_;                      // bios发布日期
    
    // 细节信息
    std::string   address_;                     // bios 在内存中的物理地址(十六进制)
    std::string   runtime_size_;                // bios运行时占用的内存大小，单位为bytes
    std::string   rom_size_;                    // 存储 bios 固件的 rom（只读存储器）容量，单位为kb
    std::string   bios_revision_;               // bios的修订版本号，可能与version不同
    std::string   firmware_revisioin_;          // 主板固件版本号
};

// 主板信息结构体，细节信息通过dmidecode命令获取
struct baseboardmoreinfo
{
    // 基础信息
    std::string     vendor_;                    // 主板供应商
    std::string     version_;                   // 主板版本号
    std::string     name_;                      // 主板型号
    std::string     asset_tag_;                 // 主板资产标签

    // 细节信息
    std::string     serial_num_;                // 主板序列号
    std::string     location_in_chassis_;       // 主板在机箱中的位置
    std::string     type_;                      // 主板类型
};

// 检测当前运行环境是否可以使用dmidecode命令
#ifndef isusedmidecodecommand
#define isusedmidecodecommand()\
    bool is_use_dmidecode = false;\
    \
    if(geteuid() == 0 && finddmidecodepath())\
        is_use_dmidecode = true;\
    else\
        std::cout << "当前运行环境不支持dmidecode命令, 只获取基本信息" << std::endl;
#endif

// 根据:进行字符串切割并去除两端空格得到key和value字符串
#ifndef splitremovewhite
#define splitremovewhite(_line)\
    size_t pos = _line.find(':');\
    \
    if (pos == std::string::npos)\
        return;\
    \
    std::string key = _line.substr(0, pos);\
    std::string value = _line.substr(pos + 1);\
    \
    removewhitespace(value);\
    removewhitespace(key);
#endif

// linux下获取cpu的所有信息
class linuxhardwareinfo
{
public:

    linuxhardwareinfo();
    ~linuxhardwareinfo();

    /*
        @brief 获取cpu的所有信息
        @param _cpu_infos 会有多个cpu的信息
    */
    void getprocessorallinfo(std::vector<cpuinfo>& _cpu_infos);

    /*
        @brief 获取磁盘的所有信息
        @param _disk_infos 会有多个磁盘信息
    */
    void getdiskstatsallinfo(std::vector<diskstatsinfo>& _disk_infos);

    /*
        @brief 获取bios的信息
            1、该接口会先使用demidecode命令获取bios更详细的信息，如果检测到系统的demidecode命令无法使用，改用读取文件的方式只获取biso
                基本信息！！！
            2、该接口返回true的情况为：linux系统已经安装demidecode命令，并且运行程序的用户为root用户
        @param _bios_info bios信息结构体
        @return true表示demidecode命令可以使用，获取到了更详细的信息；false说明当前运行环境的demidecode命令无法使用，只能获取基本信息。
    */
    bool getbiosallinfo(biosmoreinfo& _bios_info);

    /*
        @brief 获取主板的信息
            1、该接口会先使用demidecode命令获取bios更详细的信息，如果检测到系统的demidecode命令无法使用，改用读取文件的方式只获取主板
                基本信息！！！
            2、该接口返回true的情况为：linux系统已经安装demidecode命令，并且运行程序的用户为root用户
        @param _board_info 主板信息结构体
        @return true表示demidecode命令可以使用，获取到了更详细的信息；false说明当前运行环境的demidecode命令无法使用，只能获取基本信息。
    */
    bool getboardallinfo(baseboardmoreinfo& _board_info);

private:

    /*
        @brief 通过读取文件的方式获取bios基本信息
        @param bios基本信息
    */
    void getbiosbasicinfo(biosmoreinfo& _bios_info);

    /*
        @brief 通过读取文件的方式获取主板基本信息
        @param 主板基本信息
    */
    void getboardbasicinfo(baseboardmoreinfo& _board_info);

    /*
        @brief 去除字符串两端的空白字符，包括空格、\t等
        @param _str 源字符串
    */
    void removewhitespace(std::string& _str);

    /*
        @brief 解析cpu文件信息的一行
        @param _line 一行字符串
        @param _cpu_info 存储数据的结构体
    */
    void parseprocessorline(const std::string& _line, cpuinfo& _cpu_info);

    /*
        @brief 处理biso信息的一行
        @param _line 一行字符串
        @param _bios_info biso数据结构体
    */
    void processbiosline(const std::string& _line, biosmoreinfo& _bios_info);

    /*
        @brief 处理主板信息的一行
        @param _line 一行字符串
        @param _board_info 主板数据结构体
    */
    void processboardline(const std::string& _line, baseboardmoreinfo& _board_info);

    /*
        @brief 检查 dmidecode 是否存在并返回其完整路径
        @return true表示存在，false表示不存在
    */
    bool finddmidecodepath();

    /*
        @brief 执行命令并捕获输出
        @param cmd 命令
        @return 输出的字符串
    */
    std::string getstrbycommand(const char* _cmd);

    /*
        @brief 按照换行符进行切割
        @param _str 源字符串
        @return 切割后的集合
    */
    std::vector<std::string> splitbynewline(const std::string& _str);

    /*
        @brief 更新主板结构体处理器
        @param _key 结构体成员对应的key值
        @param value 结构体成员值
    */
    void updateboardinfo(baseboardmoreinfo& _board_info, const std::string& _key, const std::string& _value);

    /*
        @brief 更新bios结构体处理器
        @param _key 结构体成员对应的key值
        @param value 结构体成员值
    */
    void updatebiosinfo(biosmoreinfo& _bios_info, const std::string& _key, const std::string& _value);

    /*
        @brief 更新cpu结构体处理器
        @param _key 结构体成员对应的key值
        @param value 结构体成员值
    */
    void updatecpuinfo(cpuinfo& _cpu_info, const std::string& _key, const std::string& _value);

private:

    // 成员指针类型别名
    using boardmemberptr = std::string baseboardmoreinfo::*;

    using biosmemberptr = std::string biosmoreinfo::*;

    using cpumemberptr = std::string cpuinfo::*;

    const std::string cpu_file_;        // linux系统下cpu信息的存储路径

    const std::string disk_file_;       // linux系统下磁盘信息的存储路径

    const std::string bios_dir_;                             // linux系统下存放bios信息的目录
    const std::vector<std::string>  bios_files_name_;        // linux系统下存放bios信息的所有文件名

    const std::string board_dir_;                             // linux系统下存放主板信息的目录
    const std::vector<std::string>  board_files_name_;        // linux系统下存放主板信息的所有文件名

    const std::vector<std::string>  dmidecode_command_path_; // linux系统下常见的demidecode命令的完整路径，检测系统是否安装该命令会用到

    std::unordered_map<std::string, std::function<void(std::string)>>   process_board_value_map_;           // 给主板信息结构体赋值    
};

linuxhardwareinfo.cpp

#include "linuxhardwareinfo.h"

linuxhardwareinfo::linuxhardwareinfo()
    : cpu_file_("/proc/cpuinfo")
    , disk_file_("/proc/diskstats")
    , bios_dir_("/sys/class/dmi/id/")
    , bios_files_name_({"bios_vendor","bios_version","bios_date"})
    , dmidecode_command_path_({"/usr/sbin/dmidecode", "/sbin/dmidecode", "/usr/local/sbin/dmidecode"})
    , board_dir_("/sys/class/dmi/id/")
    , board_files_name_({"board_vendor","board_version","board_name","board_asset_tag"})
{
}

linuxhardwareinfo::~linuxhardwareinfo()
{
}

void linuxhardwareinfo::getprocessorallinfo(std::vector<cpuinfo> &_cpu_info)
{
    std::ifstream file(cpu_file_);
    
    if (!file.is_open())
    {
        std::cerr << "cpu文件: " << cpu_file_ << "打开失败" << std::endl;

        return;
    }

    cpuinfo cpuinfo;
    std::string line;
    while (std::getline(file, line))
    {
        if (line.empty())
        {
            // 读取下一个cpu的信息
            if(!cpuinfo.model_name_.empty()) 
            {
                _cpu_info.push_back(cpuinfo);
                cpuinfo = cpuinfo();
            }
        }
        else
            parseprocessorline(line, cpuinfo);
    }

    // 添加最后一个cpu信息
    if (!cpuinfo.model_name_.empty()) 
    {
        _cpu_info.push_back(cpuinfo);
    }

    file.close();
}

void linuxhardwareinfo::getdiskstatsallinfo(std::vector<diskstatsinfo> &_disk_infos)
{
    std::ifstream disk_stats_file(disk_file_);
    if (!disk_stats_file.is_open()) 
    {
        std::cerr << "磁盘文件: " << disk_file_ << "打开失败" << std::endl;
     
        return;
    }

    std::string line;
    while (std::getline(disk_stats_file, line))
    {
        std::istringstream iss(line);

        diskstatsinfo diskstats;

        std::string inflight, ioticks, timeinqueue;

        if (!(iss >> diskstats.major_device_num_ >> diskstats.minor_device_num_ >> diskstats.device_name_
                  >> diskstats.read_completed_ >> diskstats.read_merged_ >> diskstats.read_sectors_
                  >> diskstats.read_time_spent_ >> diskstats.write_completed_ 
                  >> diskstats.write_merged_ >> diskstats.write_sectors_ >> diskstats.write_time_spent_ 
                  >> inflight >> ioticks >> timeinqueue)) 
        {
            continue;
        }

        _disk_infos.push_back(diskstats);
    }

    disk_stats_file.close();

    return;
}

bool linuxhardwareinfo::getbiosallinfo(biosmoreinfo &_bios_info)
{
    isusedmidecodecommand()

    if(is_use_dmidecode)   // 使用dmidecode命令获取更详细的biso信息
    {
        try
        {
            // 对获取到的命令输出进行字符串切割
            std::vector<std::string> bios_info_vec = splitbynewline(getstrbycommand("dmidecode -t bios"));

            for(const auto& line : bios_info_vec)
            {
                processbiosline(line, _bios_info);
            }

        } catch (const std::exception& e)
        {
            std::cerr << "dmidecode命令执行错误: " << e.what() << std::endl;

            // 抛出异常后只获取基本信息
            getbiosbasicinfo(_bios_info);

            return false;
        }
    }
    else    // 只获取基本信息
        getbiosbasicinfo(_bios_info);

    return is_use_dmidecode;
}

bool linuxhardwareinfo::getboardallinfo(baseboardmoreinfo &_board_info)
{
    isusedmidecodecommand()

    if(is_use_dmidecode)   // 使用dmidecode命令获取更详细的主板信息
    {
        try
        {
            // 对获取到的命令输出进行字符串切割
            std::vector<std::string> board_info_vec = splitbynewline(getstrbycommand("dmidecode -t baseboard"));

            bool is_parse = false;
            for(const auto& line : board_info_vec)
            {
                if(line == "base board information")
                    is_parse = true;
                else if(line.empty())
                    is_parse = false;
                
                if(is_parse)
                    processboardline(line, _board_info);
            }

        } catch (const std::exception& e)
        {
            std::cerr << "dmidecode命令执行错误: " << e.what() << std::endl;

            // 抛出异常后只获取基本信息
            getboardbasicinfo(_board_info);

            return false;
        }
    }
    else    // 只获取基本信息
        getboardbasicinfo(_board_info);

    return is_use_dmidecode;
}

void linuxhardwareinfo::getbiosbasicinfo(biosmoreinfo &_bios_info)
{
    for(const auto& file_name : bios_files_name_)
    {
        // bios文件路径
        std::string path = bios_dir_ + file_name;
        std::ifstream file(path);
        if (!file.is_open())
        {
            std::cerr << "bios文件: " << path << "打开失败" << std::endl;
            return;
        }

        std::string value;
        std::getline(file, value);
        
        updatebiosinfo(_bios_info,file_name,value);
    }
}

void linuxhardwareinfo::getboardbasicinfo(baseboardmoreinfo &_board_info)
{
    for(const auto& file_name : board_files_name_)
    {
        // board文件路径
        std::string path = board_dir_ + file_name;
        std::ifstream file(path);
        if (!file.is_open())
        {
            std::cerr << "主板文件: " << path << "打开失败" << std::endl;
            return;
        }

        std::string value;
        std::getline(file, value);
        
        updateboardinfo(_board_info,file_name,value);
    }
}

void linuxhardwareinfo::removewhitespace(std::string &_str)
{
    int head_idx = 0, tail_idx = _str.length() - 1;

    bool head_flag = false, tail_flag = false;

    while (head_idx != tail_idx)
    {
        // 使用std::isspace方法判断空白字符，因为会有\t等情况
        if(!head_flag && std::isspace(_str[head_idx]))
            head_idx++;
        else
            head_flag = true;

        if(!tail_flag && std::isspace(_str[tail_idx]))
            tail_idx--;
        else
            tail_flag = true;

        if(head_flag && tail_flag)
            break;
    }

    _str = _str.substr(head_idx, tail_idx - head_idx + 1);

    return;
}

void linuxhardwareinfo::parseprocessorline(const std::string &_line, cpuinfo &_cpu_info)
{
    splitremovewhite(_line)

    updatecpuinfo(_cpu_info,key,value);
}

void linuxhardwareinfo::processbiosline(const std::string &_line, biosmoreinfo &_bios_info)
{
    splitremovewhite(_line)

    updatebiosinfo(_bios_info,key,value);
}

void linuxhardwareinfo::processboardline(const std::string &_line, baseboardmoreinfo &_board_info)
{
    splitremovewhite(_line)

    updateboardinfo(_board_info,key,value);
}

bool linuxhardwareinfo::finddmidecodepath()
{
    for (const auto& path : dmidecode_command_path_) 
    {
        if (access(path.c_str(), x_ok) == 0) 
        {
            return true; // 找到有效路径
        }
    }

    return false;
}

std::string linuxhardwareinfo::getstrbycommand(const char *_cmd)
{
    std::array<char, 128> buffer;
    std::string result;
    std::unique_ptr<file, decltype(&pclose)> pipe(popen(_cmd, "r"), pclose);

    if (!pipe) 
    {
        throw std::runtime_error("failed to execute command");
    }

    while (fgets(buffer.data(), buffer.size(), pipe.get()) != nullptr) 
    {
        result += buffer.data();
    }

    return result;
}

std::vector<std::string> linuxhardwareinfo::splitbynewline(const std::string &_str)
{
    std::vector<std::string> lines;
    std::istringstream iss(_str);
    std::string line;   
    
    while (std::getline(iss, line, '\n')) 
    {
        lines.push_back(line);
    }

    return lines;
}

void linuxhardwareinfo::updateboardinfo(baseboardmoreinfo &_board_info, const std::string &_key, const std::string &_value)
{
    static const std::unordered_map<std::string, boardmemberptr> keys_map = {
        {"manufacturer",   &baseboardmoreinfo::vendor_},
        {"product name",   &baseboardmoreinfo::name_},
        {"version",  &baseboardmoreinfo::version_},
        {"serial number",       &baseboardmoreinfo::serial_num_},
        {"asset tag",  &baseboardmoreinfo::asset_tag_},
        {"location in chassis",    &baseboardmoreinfo::location_in_chassis_},
        {"type",    &baseboardmoreinfo::type_},
        {"board_vendor",   &baseboardmoreinfo::vendor_},
        {"board_name",   &baseboardmoreinfo::name_},
        {"board_version",   &baseboardmoreinfo::version_},
        {"board_asset_tag",   &baseboardmoreinfo::asset_tag_},
        {"board_serial",   &baseboardmoreinfo::serial_num_}
    };

    if (auto it = keys_map.find(_key); it != keys_map.end()) 
    {
        _board_info.*(it->second) = _value;
    }
    // else
    //     std::cerr << "解析出" << _key << "和" << _value << std::endl;
}

void linuxhardwareinfo::updatebiosinfo(biosmoreinfo &_bios_info, const std::string &_key, const std::string &_value)
{
    static const std::unordered_map<std::string, biosmemberptr> keys_map = {
        {"vendor",   &biosmoreinfo::vendor_},
        {"release date",   &biosmoreinfo::date_},
        {"version",  &biosmoreinfo::version_},
        {"address",       &biosmoreinfo::address_},
        {"runtime size",  &biosmoreinfo::runtime_size_},
        {"rom size",    &biosmoreinfo::rom_size_},
        {"bios revision",    &biosmoreinfo::bios_revision_},
        {"firmware revision",    &biosmoreinfo::firmware_revisioin_},
        {"bios_vendor",   &biosmoreinfo::vendor_},
        {"bios_date",   &biosmoreinfo::date_},
        {"bios_version",   &biosmoreinfo::version_}
    };

    if (auto it = keys_map.find(_key); it != keys_map.end()) 
    {
        // 部分字段带有单位，去除单位
        if(_value.find(" ") != std::string::npos)
        {
            size_t pos = _value.find(" ");

            _bios_info.*(it->second) = _value.substr(0, pos);
        }
        else
            _bios_info.*(it->second) = _value;
    }
    // else
    //     std::cerr << "解析出" << _key << "和" << _value << std::endl;
}

void linuxhardwareinfo::updatecpuinfo(cpuinfo& _cpu_info, const std::string &_key, const std::string &_value)
{
    static const std::unordered_map<std::string, cpumemberptr> keys_map = {
        {"processor",   &cpuinfo::processor_},
        {"vendor_id",   &cpuinfo::vendor_id_},
        {"cpu family",  &cpuinfo::cpu_family_},
        {"model",       &cpuinfo::model_},
        {"model name",  &cpuinfo::model_name_},
        {"stepping",    &cpuinfo::stepping_},
        {"microcode",    &cpuinfo::microcode_},
        {"cpu mhz",    &cpuinfo::cpu_freq_},
        {"physical id",   &cpuinfo::physical_id_},
        {"siblings",   &cpuinfo::siblings_},
        {"core id",   &cpuinfo::core_id_},
        {"cpu cores",   &cpuinfo::cpu_cores_},
        {"clflush size",   &cpuinfo::clflush_size_}
    };

    if (auto it = keys_map.find(_key); it != keys_map.end()) 
    {
        // 部分字段带有单位，去除单位
        if(_value.find(" ") != std::string::npos)
        {
            size_t pos = _value.find(" ");

            _cpu_info.*(it->second) = _value.substr(0, pos);
        }
        else
            _cpu_info.*(it->second) = _value;
    }
    // else
    //     std::cerr << "解析出" << _key << "和" << _value << std::endl;
}

main.cpp

#include <iostream>
#include "linuxhardwareinfo.h"
int main()
{
    linuxhardwareinfo info;

    std::cout << "*************************cpu信息*************************" << std::endl;

    std::vector<cpuinfo> cpuinfos;
    info.getprocessorallinfo(cpuinfos);

    for (const auto& cpuinfo : cpuinfos)
    {
        std::cout << "-------------------------" << std::endl;
        std::cout << "processor: " << cpuinfo.processor_ << std::endl;
        std::cout << "vendor id: " << cpuinfo.vendor_id_ << std::endl;
        std::cout << "cpu family: " << cpuinfo.cpu_family_ << std::endl;
        std::cout << "model: " << cpuinfo.model_ << std::endl;
        std::cout << "model name: " << cpuinfo.model_name_ << std::endl;
        std::cout << "stepping: " << cpuinfo.stepping_ << std::endl;
        std::cout << "microcode: " << cpuinfo.microcode_ << std::endl;
        std::cout << "cpu mhz: " << cpuinfo.cpu_freq_ << std::endl;
        std::cout << "cache size: " << cpuinfo.cache_size_ << std::endl;
        std::cout << "physical id: " << cpuinfo.physical_id_ << std::endl;
        std::cout << "siblings: " << cpuinfo.siblings_ << std::endl;
        std::cout << "core id: " << cpuinfo.core_id_ << std::endl;
        std::cout << "cpu cores: " << cpuinfo.cpu_cores_ << std::endl;
        std::cout << "clflush size: " << cpuinfo.clflush_size_ << std::endl;
        std::cout << "-------------------------" << std::endl;
    }

    std::cout << "*************************cpu信息*************************" << std::endl;

    std::cout << "*************************磁盘信息*************************" << std::endl;

    std::vector<diskstatsinfo> disk_infos;
    info.getdiskstatsallinfo(disk_infos);

    for (const auto& diskstats : disk_infos) 
    {
        std::cout << "-------------------------" << std::endl;
        std::cout << "主设备号: " << diskstats.major_device_num_ << std::endl;
        std::cout << "次设备号: " << diskstats.minor_device_num_ << std::endl;
        std::cout << "磁盘名称: " << diskstats.device_name_ << std::endl;
        std::cout << "完成的读操作次数: " << diskstats.read_completed_ << std::endl;
        std::cout << "合并读操作次数: " << diskstats.read_merged_ << std::endl;
        std::cout << "读取的扇区总数: " << diskstats.read_sectors_ << std::endl;
        std::cout << "花费在读操作上的时间: " << diskstats.read_time_spent_ << std::endl;
        std::cout << "完成的写操作次数: " << diskstats.write_completed_ << std::endl;
        std::cout << "合并写操作次数: " << diskstats.write_merged_ << std::endl;
        std::cout << "写入的扇区总数: " << diskstats.write_sectors_ << std::endl;
        std::cout << "花费在写操作上的时间: " << diskstats.write_time_spent_ << std::endl;
        std::cout << "-------------------------" << std::endl;
    }
    std::cout << "*************************磁盘信息*************************" << std::endl;

    std::cout << "*************************bios信息*************************" << std::endl;

    biosmoreinfo bios_info;
    info.getbiosallinfo(bios_info);

    std::cout << "bios版本号: " << bios_info.version_ << std::endl;
    std::cout << "bios供应商: " << bios_info.vendor_ << std::endl;
    std::cout << "bios发布日期: " << bios_info.date_ << std::endl;
    std::cout << "bios 在内存中的物理地址: " << bios_info.address_ << std::endl;
    std::cout << "bios运行时占用的内存大小: " << bios_info.runtime_size_ << std::endl;
    std::cout << "存储bios固件的rom(只读存储器)容量: " << bios_info.rom_size_ << std::endl;
    std::cout << "bios 的修订版本号: " << bios_info.bios_revision_ << std::endl;
    std::cout << "主板固件的版本号: " << bios_info.firmware_revisioin_ << std::endl;
    std::cout << "*************************bios信息*************************" << std::endl;
 
    std::cout << "*************************主板信息*************************" << std::endl;
 
    baseboardmoreinfo board_info;
    info.getboardallinfo(board_info);
 
    std::cout << "主板版本号: " << board_info.version_ << std::endl;
    std::cout << "主板供应商: " << board_info.vendor_ << std::endl;
    std::cout << "主板型号: " << board_info.name_ << std::endl;
    std::cout << "主板序列号: " << board_info.serial_num_ << std::endl;
    std::cout << "主板资产标签: " << board_info.asset_tag_ << std::endl;
    std::cout << "主板在机箱中的位置: " << board_info.location_in_chassis_ << std::endl;
    std::cout << "主板类型: " << board_info.type_ << std::endl;
    std::cout << "*************************主板信息*************************" << std::endl;

    return 0;
}