linux get cpu and memory info

class system_info final
{
public:
    system_info();
    static double getCpuPercent();
    static float getTotalMemPercent();
    static int getTotalMemInfo(int &nTotal,int &nFree,int &nAvailable);
};

#include "system_info.h"
#include <stdio.h>
#include <stdlib.h>
#include <unistd.h>
#include <cstring>
#include <memory>
#include <vector>
#include <cstring>
#include <thread>

typedef struct cpu_occupy_          //定义一个cpu occupy的结构体
{
    char name[20];                  //定义一个char类型的数组名name有20个元素
    unsigned int user;              //定义一个无符号的int类型的user
    unsigned int nice;              //定义一个无符号的int类型的nice
    unsigned int system;            //定义一个无符号的int类型的system
    unsigned int idle;              //定义一个无符号的int类型的idle
    unsigned int iowait;
    unsigned int irq;
    unsigned int softirq;
}cpu_occupy_t;
typedef struct mem_occupy_{
        char nameTotal[20];
        unsigned int total;
        char nameFree[20];
        unsigned int free;
        char nameAvailable[20];
        unsigned int available;
}mem_occupy_t;

double cal_cpuoccupy (cpu_occupy_t *o, cpu_occupy_t *n)
{
    double od, nd;
    double id, sd;
    double cpu_use ;

    od = (double) (o->user + o->nice + o->system +o->idle+o->softirq+o->iowait+o->irq);//第一次(用户+优先级+系统+空闲)的时间再赋给od
    nd = (double) (n->user + n->nice + n->system +n->idle+n->softirq+n->iowait+n->irq);//第二次(用户+优先级+系统+空闲)的时间再赋给od

    id = (double) (o->idle);    //用户第一次和第二次的时间之差再赋给id
    sd = (double) (n->idle) ;    //系统第一次和第二次的时间之差再赋给sd
    if((nd-od) != 0)
    {
        auto t1_busy=od-id;
        auto t2_busy=nd-sd;
        auto busy_delta=t2_busy-t1_busy;
        auto all_delta=nd-od;
        if(t2_busy<=t1_busy)
            return 0.0;
        cpu_use = busy_delta / all_delta *100.0;
        //cpu_use =1- (sd-id)/(nd-od)*100.00;
    }
    else
        cpu_use = 0;
    return cpu_use;
}

std::vector<cpu_occupy_t> get_cpuoccupy (cpu_occupy_t *cpust)
{
    FILE *fd;
    int n;
    char buff[4096]={'\0'};
    cpu_occupy_t *cpu_occupy;
    cpu_occupy=cpust;

    std::vector<cpu_occupy_t> vResult;
    fd = fopen ("/proc/stat", "r");
    if(fd == NULL)
    {
            perror("fopen:");
            exit (0);
    }
    fgets (buff, sizeof(buff), fd);

    sscanf (buff, "%s %u %u %u %u %u %u %u", cpu_occupy->name, &cpu_occupy->user, &cpu_occupy->nice,&cpu_occupy->system, &cpu_occupy->idle ,&cpu_occupy->iowait,&cpu_occupy->irq,&cpu_occupy->softirq);
    const char *pname=cpu_occupy->name;
    while(std::strstr(pname,"cpu")!=nullptr)
    {
        const char *result=nullptr;
        result = std::strchr(buff,'\n');
        if(result!=nullptr)
        {
            ++result;
            std::memmove(buff,&buff[result-buff],sizeof(buff)-(result-buff));
            cpu_occupy_t cpu_core;
            cpu_occupy=&cpu_core;
            sscanf (buff, "%s %u %u %u %u %u %u %u", cpu_occupy->name, &cpu_occupy->user, &cpu_occupy->nice,&cpu_occupy->system, &cpu_occupy->idle ,&cpu_occupy->iowait,&cpu_occupy->irq,&cpu_occupy->softirq);
            vResult.push_back(cpu_core);
        }
        else
            break;
    }
    fclose(fd);
    return vResult;
}

double get_sysCpuUsage(std::vector<double> &perCpuUsage)
{
    cpu_occupy_t cpu_stat1;
    cpu_occupy_t cpu_stat2;
    double cpu;
    auto cpu_first=get_cpuoccupy((cpu_occupy_t *)&cpu_stat1);
    sleep(1);
    //第二次获取cpu使用情况
    auto cpu_second=get_cpuoccupy((cpu_occupy_t *)&cpu_stat2);

    //计算cpu总使用率
    cpu = cal_cpuoccupy ((cpu_occupy_t *)&cpu_stat1, (cpu_occupy_t *)&cpu_stat2);
    //计算各个cpu使用率
    for(size_t i=0;i<cpu_first.size();i++)
    {
        double p_cpu=cal_cpuoccupy ((cpu_occupy_t *)&cpu_first.at(i), (cpu_occupy_t *)&cpu_second.at(i));
        perCpuUsage.push_back(p_cpu);
    }

    return cpu;
}

/
int get_memoccupy(mem_occupy_t *mem)
{
    FILE *pf;
    char buff[256];
    char temp[20];
    mem_occupy_t *m = mem;

    pf = fopen ("/proc/meminfo", "r");
    if(pf == NULL)
        return -1;

    char *pstatus = NULL;
    pstatus = fgets (buff, sizeof(buff), pf);
    if( pstatus == NULL )
    {
        fclose(pf);
        return -1;
    }

    if(sscanf(buff, "%s %u %s", m->nameTotal, &m->total, temp) != 3)
    {
        fclose(pf);
        return -1;
    }

    pstatus = fgets (buff, sizeof(buff), pf);
    if( pstatus == NULL )
    {
        fclose(pf);
        return -1;
    }

    if(sscanf(buff, "%s %u %s", m->nameFree, &m->free, temp) != 3)
    {
        fclose(pf);
        return -1;
    }

    pstatus = fgets (buff, sizeof(buff), pf);
    if( pstatus == NULL )
    {
        fclose(pf);
        return -1;
    }

    if(sscanf (buff, "%s %u %s", m->nameAvailable, &m->available, temp) !=3)
    {
        fclose(pf);
        return -1;
    }

    fclose(pf);
    return 0;
}

system_info::system_info()
{

}
double system_info::getCpuPercent()
{
    std::vector<double> vCpuUsage;
    double totalCpuPercent= get_sysCpuUsage(vCpuUsage);
    return totalCpuPercent;
}
//get memory occupy percent
float system_info::getTotalMemPercent()
{
    mem_occupy_t mem;
    std::memset(&mem, 0 , sizeof(mem_occupy_t));
    if(get_memoccupy(&mem)<0)
        return 0.0;
    return ((mem.total - mem.free)*10000 / mem.total)/100.0;
}
//successed: return 0, failed: return -1
int system_info::getTotalMemInfo(int &nTotal,int &nFree,int &nAvailable)
{
    mem_occupy_t mem;
    std::memset(&mem, 0 , sizeof(mem_occupy_t));
    if(get_memoccupy(&mem)<0)
        return -1;
    nTotal= mem.total;
    nFree = mem.free;
    nAvailable = mem.available;
    return 0;
}