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

#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_;           // 给主板信息结构体赋值    
};

#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;
}

#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;
}