Linux应用开发4 如何获取系统参数信息（监测终端信息）

本文链接：https://blog.youkuaiyun.com/internetv/article/details/126895608

本文介绍如何在UI界面上监测系统参数，包括系统基本信息、时间日期、进程时间等，并讲解了内存申请、随机数生成及休眠等功能。

摘要生成于 C知道，由 DeepSeek-R1 满血版支持，前往体验 >

通过这一节的学习，你可以在UI界面做监测终端信息，如CPU 时间等各类系统参数，狂拽酷炫吊炸天

获取进程时间

系统基本参数

系统标识 uname（man 2 uname ）

uname()用于获取有关当前操作系统内核的名称和信息，使用时一定要先定义一个 struct utsname 结构体变量

#include <sys/utsname.h>

int uname(struct utsname *buf);

buf ： struct utsname 结构体类型指针，指向一个 struct utsname 结构体类型对象。

返回值： 成功返回 0 ；失败将返回 -1 ，并设置 errno 。

struct utsname {
 char sysname[]; /* 当前操作系统的名称 */
 char nodename[]; /* 网络上的名称（主机名） */
 char release[]; /* 操作系统内核版本 */
 char version[]; /* 操作系统发行版本 */
 char machine[]; /* 硬件架构类型 */
 #ifdef _GNU_SOURCE
 char domainname[];/* 当前域名 */
 #endif
};

#include <stdio.h>
#include <stdlib.h>
#include <sys/utsname.h>
int main(void) {
 struct utsname os_info;
 int ret;
 /* 获取信息 */
 ret = uname(&os_info);
 if (-1 == ret) {
 perror("uname error");
 exit(-1);
 }
 /* 打印信息 */
 printf("操作系统名称: %s\n", os_info.sysname);
 printf("主机名: %s\n", os_info.nodename);
 printf("内核版本: %s\n", os_info.release);
 printf("发行版本: %s\n", os_info.version);
 printf("硬件架构: %s\n", os_info.machine);
 exit(0);
}

sysinfo 函数（可用内存和进程）需要定义一个 struct sysinfo 结构体变量

#include <sys/sysinfo.h>

int sysinfo(struct sysinfo *info);

info ： struct sysinfo 结构体类型指针，指向一个 struct sysinfo 结构体类型对象。

返回值： 成功返回 0 ；失败将返回 -1 ，并设置 errno 。

struct sysinfo {
 long uptime; /* 自系统启动之后所经过的时间（以秒为单位） */
 unsigned long loads[3]; /* 1, 5, and 15 minute load averages */
 unsigned long totalram; /* 总的可用内存大小 */
 unsigned long freeram; /* 还未被使用的内存大小 */
 unsigned long sharedram; /* Amount of shared memory */
 unsigned long bufferram; /* Memory used by buffers */
 unsigned long totalswap; /* Total swap space size */
 unsigned long freeswap; /* swap space still available */ 
 unsigned short procs; /* 系统当前进程数量 */
 unsigned long totalhigh; /* Total high memory size */
 unsigned long freehigh; /* Available high memory size */
 unsigned int mem_unit; /* 内存单元大小（以字节为单位） */
 char _f[20-2*sizeof(long)-sizeof(int)]; /* Padding to 64 bytes */
};

#include <stdio.h>
#include <stdlib.h>
#include <sys/sysinfo.h>
int main(void) {
 struct sysinfo sys_info;
 int ret;
 /* 获取信息 */
 ret = sysinfo(&sys_info);
 if (-1 == ret) {
 perror("sysinfo error");
 exit(-1);
 }
 /* 打印信息 */
 printf("uptime: %ld\n", sys_info.uptime);
 printf("totalram: %lu\n", sys_info.totalram);
 printf("freeram: %lu\n", sys_info.freeram);
 printf("procs: %u\n", sys_info.procs);
 exit(0);
}

gethostname 函数(可用于单独获取 Linux 系统主机名)

#include <unistd.h>

int gethostname(char *name, size_t len);

指向用于存放主机名字符串的缓冲区。

len ：缓冲区长度。

返回值： 成功返回 0, ；失败将返回 -1 ，并会设置 errno 。

sysconf() 函数

sysconf() 函数是一个库函数，可在运行时获取系统的一些配置信息，譬如页大小（ page size ）、主机名的最大长度、进程可以打开的最大文件数、每个用户 ID 的最大并发进程数等

#include <unistd.h>

long sysconf(int name)

调用 sysconf() 函数获取系统的配置信息，参数 name 指定了要获取哪个配置信息，参数 name 可取以下任何一个值

⚫ _SC_ARG_MAX ： exec 族函数的参数的最大长度， exec 族函数后面会介绍，这里先不管！

⚫ _SC_CHILD_MAX ：每个用户的最大并发进程数，也就是同一个用户可以同时运行的最大进程数。

⚫ _SC_HOST_NAME_MAX ：主机名的最大长度。

⚫ _SC_LOGIN_NAME_MAX ：登录名的最大长度。

⚫ _SC_CLK_TCK ：每秒时钟滴答数，也就是系统节拍率。

⚫ _SC_OPEN_MAX ：一个进程可以打开的最大文件数。

⚫ _SC_PAGESIZE ：系统页大小（ page size ）。

⚫ _SC_TTY_NAME_MAX ：终端设备名称的最大长度。

#include <stdio.h>
#include <stdlib.h>
#include <unistd.h>
int main(void) {
 printf("每个用户的最大并发进程数: %ld\n", sysconf(_SC_CHILD_MAX));
 printf("系统节拍率: %ld\n", sysconf(_SC_CLK_TCK));
 printf("系统页大小: %ld\n", sysconf(_SC_PAGESIZE));
 exit(0);
}

时间、日期（GMT、UTC、时区）

点时间和段时间

通常描述时间有两种方式：点时间和段时间；点时间顾名思义指的是某一个时间点，譬如当前时间是 2021 年 2 月 22 日星期一 11:12 分 35 秒，所以这里指的就是某一个时间点；而对于段时间来说，顾名思义指的是某一个时间段，譬如早上 8:00 到中午 12:00 这段时间。

实时时钟 RTC

操作系统中一般会有两个时钟，一个系统时钟（system clock ），一个实时时钟（ Real time clock ），也叫 RTC ；系统时钟由系统启动之后由内核来维护，譬如使用 date 命令查看到的就是系统时钟，所以在系统关机情况下是不存在的；而实时时钟一般由 RTC 时钟芯片提供， RTC 芯片有相应的电池为其供电，以保证系统在关机情况下 RTC 能够继续工作、继续计时。

Linux 系统如何记录时间-jiffies 的引入

jiffies 是内核中定义的一个全局变量，内核使用 jiffies 来记录系统从启动以来的系统节拍数，所以这个变量用来记录以系统节拍时间为单位的时间长度，Linux 内核在编译配置时定义了一个节拍时间，使用节拍率（一秒钟多少个节拍数）来表示，譬如常用的节拍率为 100Hz （一秒钟 100 个节拍数，节拍时间为 1s /100）、 200Hz （一秒钟 200 个节拍，节拍时间为 1s / 200 ）、 250Hz （一秒钟 250 个节拍，节拍时间为 1s /250）、 300Hz （一秒钟 300 个节拍，节拍时间为 1s / 300 ）、 500Hz （一秒钟 500 个节拍，节拍时间为 1s /500）等。由此可以发现配置的节拍率越低，每一个系统节拍的时间就越短，也就意味着 jiffies 记录的时间精度越高，当然，高节拍率会导致系统中断的产生更加频繁，频繁的中断会加剧系统的负担，一般默认情况下都是采用 100Hz 作为系统节拍率。

获取时间 time/gettimeofday

time 函数

用于获取当前时间，以秒为单位，返回得到的值是自 1970-01-01 00:00:00 +0000 (UTC) 以来的秒数

#include <time.h>

time_t time(time_t *tloc);

tloc ：如果 tloc 参数不是 NULL ，则返回值也存储在 tloc 指向的内存中。

返回值： 成功则返回自 1970-01-01 00:00:00 +0000 (UTC) 以来的时间值（以秒为单位）；失败则返回 -1 ，并会设置 errno 。

#include <stdio.h>
#include <stdlib.h>
#include <time.h>
int main(void) {
 time_t t;
 t = time(NULL);
 if (-1 == t) {
 perror("time error");
 exit(-1);
 }
 printf("时间值: %ld\n", t);
 exit(0);
}

gettimeofday 函数

time() 获取到的时间只能精确到秒，如果想要获取更加精确的时间可以使用系统调用 gettimeofday 来实现，gettimeofday() 函数提供微秒级时间精度

#include <sys/time.h>

int gettimeofday(struct timeval *tv, struct timezone *tz);

tv ：参数 tv 是一个 struct timeval 结构体指针变量

tz ：参数 tz 是个历史产物，早期实现用其来获取系统的时区信息，目前已遭废弃，在调用 gettimeofday() 函数时应将参数 tz 设置为 NULL 。

返回值： 成功返回 0 ；失败将返回 -1 ，并设置 errno 。

时间转换函数
time函数与gettimeofday函数，获得的均是时间段值，因此需要转换为具体的时间。

ctime 函数（变成可打印的字符串形式）

将日历时间转换为可打印输出的字符串形式

#include <time.h>

char *ctime(const time_t *timep);

char *ctime_r(const time_t *timep, char *buf);

timep ： time_t 时间变量指针。

返回值： 成功将返回一个 char * 类型指针，指向转换后得到的字符串；失败将返回 NULL

#include <stdio.h>
#include <stdlib.h>
#include <time.h>
int main(void) {
 char tm_str[100] = {0};
 time_t tm;
 /* 获取时间 */
 tm = time(NULL);
 if (-1 == tm) {
 perror("time error");
 exit(-1);
 }
 /* 将时间转换为字符串形式 
    从tm转至tm_str
    */
 ctime_r(&tm, tm_str);
 /* 打印输出 */
 printf("当前时间: %s", tm_str);
 exit(0);
}


//当前时间：Mon Feb 22 17:10:46 2021 （字符串形式）

localtime 函数（变成struct tm 结构体所表示的时间）（本地时间）

（注意使用时要使用可重入版本 localtime_r()，而不是不可重入版本localtime()）

#include <time.h>

struct tm *localtime(const time_t *timep);

struct tm *localtime_r(const time_t *timep, struct tm *result);

timep ：需要进行转换的 time_t 时间变量对应的指针，可通过 time() 或 gettimeofday() 获取得到。

result ：是一个 struct tm 结构体类型指针，稍后给大家介绍 struct tm 结构体，参数 result 是可重入函数 localtime_r()需要额外提供的参数。

返回值： 对于不可重入版本 localtime() 来说，成功则返回一个有效的 struct tm 结构体指针，而对于可重入版本 localtime_r() 来说，成功执行情况下，返回值将会等于参数 result ；失败则返回 NULL 。

//struct tm 结构体
struct tm {
 int tm_sec; /* 秒(0-60) */
 int tm_min; /* 分(0-59) */
 int tm_hour; /* 时(0-23) */
 int tm_mday; /* 日(1-31) */
 int tm_mon; /* 月(0-11) */
 int tm_year; /* 年(这个值表示的是自 1900 年到现在经过的年数) */
 int tm_wday; /* 星期(0-6, 星期日 Sunday = 0、星期一=1…) */
 int tm_yday; /* 一年里的第几天(0-365, 1 Jan = 0) */
 int tm_isdst; /* 夏令时 */
};

#include <stdio.h>
#include <stdlib.h>
#include <time.h>
int main(void) {
 struct tm t;
 time_t sec;
 /* 获取时间 */
 sec = time(NULL);
 if (-1 == sec) {
 perror("time error");
 exit(-1);
 }
 /* 转换得到本地时间 */
 localtime_r(&sec, &t);
 /* 打印输出 */
 printf("当前时间: %d 年%d 月%d 日 %d:%d:%d\n",
 t.tm_year + 1900, t.tm_mon, t.tm_mday,
 t.tm_hour, t.tm_min, t.tm_sec);
 exit(0);
}

gmtime 函数（变成struct tm 结构体所表示的时间）

gmtime()函数也可以把 time_t 时间变成一个 struct tm 结构体所表示的时间，与 localtime()所不同的是， gmtime()函数所得到的是 UTC 国际标准时间，并不是计算机的本地时间，这是它们之间的唯一区别（咱们往往是北京时间，所以比东八区国际标准时间早8个小时）

#include <time.h>

struct tm *gmtime(const time_t *timep);

struct tm *gmtime_r(const time_t *timep, struct tm *result);

mktime 函数（将struct tm 结构体表示的分解时间转换为 time_t 时间（日历时间），就是原来那个时间段）

#include <time.h>

time_t mktime(struct tm *tm);

tm ：需要进行转换的 struct tm 结构体变量对应的指针。

返回值： 成功返回转换得到 time_t 时间值；失败返回 -1 。

#include <stdio.h>
#include <stdlib.h>
#include <time.h>
int main(void) {
 struct tm local_t;
 time_t sec;
 /* 获取时间 */
 sec = time(NULL);
 if (-1 == sec) {
 perror("time error");
 exit(-1);
 }
 printf("获取得到的秒数: %ld\n", sec);
 localtime_r(&sec, &local_t);
 printf("转换得到的秒数: %ld\n", mktime(&local_t));
 exit(0);
}
//1613996624

asctime 函数()

asctime() 函数与 ctime() 函数的作用一样，也可将时间转换为可打印输出的字符串形式

strftime 函数()

此函数也可以将一个 struct tm 变量表示的分解时间转换为为格式化字符串，它可以 根据自己的喜好自定义时间的显示格式，而 asctime()和 ctime()转换得到的字符串时间格式是固定的。

#include <time.h>

size_t strftime(char *s, size_t max, const char *format, const struct tm *tm);

s ：指向一个缓存区的指针，该缓冲区用于存放生成的字符串。

max ：字符串的最大字节数。

format ：这是一个用字符串表示的字段，包含了普通字符和特殊格式说明符，可以是这两种字符的任意组合。特殊格式说明符将会被替换为 struct tm 结构体对象所指时间的相应值，这些特殊格式说明符如下：

eg：譬如我要想输出"2021-01-14 16:30:25<PM> January Thursday"这样一种形式表示的时间日期

"%Y-%m-%d %H:%M:%S<%p> %B %A"

#include <stdio.h>
#include <stdlib.h>
#include <time.h>
int main(void) {
 struct tm local_t;
 char tm_str[100] = {0};
 time_t sec;
 /* 获取时间 */
 sec = time(NULL);
 if (-1 == sec) {
 perror("time error");
 exit(-1);
 }
 localtime_r(&sec, &local_t);
 strftime(tm_str, sizeof(tm_str), "%Y-%m-%d %A %H:%M:%S", &local_t);
 printf("本地时间: %s\n", tm_str);
 exit(0);
}

设置时间settimeofday

使用 settimeofday() 函数可以设置时间，也就是设置系统的本地时间

注意：使用 settimeofday 设置系统时间时内核会进行权限检查，只有超级用户（root）才可以设置系统时间，普通用户将无操作权限。

#include <sys/time.h>

int settimeofday(const struct timeval *tv, const struct timezone *tz);

tv ：参数 tv 是一个 struct timeval 结构体指针变量， struct timeval 结构体在前面章节内容中已经给大家介绍了，需要设置的时间便通过参数 tv 指向的 struct timeval 结构体变量传递进去。

tz ：参数 tz 是个历史产物，早期实现用其来设置系统的时区信息，目前已遭废弃，在调用 settimeofday()函数时应将参数 tz 设置为 NULL 。

返回值： 成功返回 0 ；失败将返回 -1 ，并设置 errno 。

进程时间

进程时间指的是进程从创建后（也就是程序运行后）到目前为止这段时间内使用 CPU 资源的时间总数，出于记录的目的，内核把 CPU 时间（进程时间）分为以下两个部分：

⚫ 用户 CPU 时间：进程在用户空间（用户态）下运行所花费的 CPU 时间。有时也成为虚拟时间（ virtual time）。

⚫ 系统 CPU 时间：进程在内核空间（内核态）下运行所花费的 CPU 时间。这是内核执行系统调用或代表进程执行的其它任务（譬如，服务页错误）所花费的时间。

一般来说，进程时间指的是用户 CPU 时间和系统 CPU 时间的总和，也就是总的 CPU 时间。（休眠的时间不计算在进程时间中）

times 函数

times() 函数用于获取当前进程时间

如果我们想查看程序运行到某一个位置时的进程时间，或者计算出程序中的某一段代码执行过程所花费的进程时间，都可以使用 times() 函数来实现。

#include <sys/times.h>

clock_t times(struct tms *buf);

buf ： times() 会将当前进程时间信息存在一个 struct tms 结构体数据中，所以我们需要提供 struct tms 变量，使用参数 buf 指向该变量

#include <stdio.h>
#include <stdlib.h>
#include <sys/times.h>
#include <unistd.h>
int main(int argc, char *argv[])
{
 struct tms t_buf_start;
 struct tms t_buf_end;
 clock_t t_start;
 clock_t t_end;
 long tck;
 int i, j;
 /* 获取系统的节拍率 */
 tck = sysconf(_SC_CLK_TCK);
 /* 开始时间 */
 t_start = times(&t_buf_start);
 if (-1 == t_start) {
 perror("times error");
 exit(-1);
 }
 /* *****需要进行测试的代码段***** */
 for (i = 0; i < 20000; i++);
 sleep(1); //休眠挂起
 /* *************end************** */
 /* 结束时间 */
 t_end = times(&t_buf_end);
 if (-1 == t_end) {
 perror("times error");
 exit(-1);
 }
 /* 打印时间 */
 printf("时间总和: %f 秒\n", (t_end - t_start) / (double)tck);
 printf("用户 CPU 时间: %f 秒\n", (t_buf_end.tms_utime - t_buf_start.tms_utime) / (double)tck);
 printf("系统 CPU 时间: %f 秒\n", (t_buf_end.tms_stime - t_buf_start.tms_stime) / (double)tck);
 exit(0);
}

clock 函数

库函数 clock() 提供了一个更为简单的方式用于进程时间，它的返回值描述了进程使用的总的 CPU 时间（也就是进程时间，包括用户 CPU 时间和系统 CPU 时间）

#include <time.h>

clock_t clock(void);

使用该函数需要包含头文件 <time.h>

返回值是到目前为止程序的进程时间，为 clock_t 类型，

注意 clock() 的返回值并不是系统节拍数，如果想要获得秒数，请除以 CLOCKS_PER_SEC

#include <stdio.h>
#include <stdlib.h>
#include <time.h>
int main(int argc, char *argv[])
{
 clock_t t_start;
 clock_t t_end;
 int i, j;
 /* 开始时间 */
 t_start = clock();
 if (-1 == t_start)
 exit(-1);
 /* *****需要进行测试的代码段***** */
 for (i = 0; i < 20000; i++)
 for (j = 0; j < 20000; j++)
 ;
 /* *************end************** */
 /* 结束时间 */
 t_end = clock();
 if (-1 == t_end)
 exit(-1);
 /* 打印时间 */
 printf("总的 CPU 时间: %f\n", (t_end - t_start) / (double)CLOCKS_PER_SEC);
 exit(0);
}

产生随机数

在应用编程当中可能会用到随机数，譬如老板让你编写一个抽奖的小程序，编号 0~100 ，分为特等奖 1 个、一等奖 2 个、二等级 3 以及三等级 4 个，也就是说需要从 0~100 个编号中每次随机抽取一个号码，这就需要用到随机数

随机数与伪随机数

随机数是随机出现，没有任何规律的一组数列。在我们编程当中，是没有办法获得真正意义上的随机数列的，这是一种理想的情况，在我们的程序当中想要使用随机数列，只能通过算法得到一个伪随机数序列，那在编程当中说到的随机数，基本都是指伪随机数。

rand 函数

rand() 函数用于获取随机数，多次调用 rand() 可得到一组随机数序列

#include <stdlib.h>

int rand(void);

使用该函数需要包含头文件 <stdlib.h>

srand 函数

但是这里有个问题，就是每一次运行srand()程序所得到的随机数序列都是相同的，那如何使得每一次启动应用程序所得到的随机数序列是不一样的呢？那就通过设置不同的随机数种子

使用 srand() 函数为 rand() 设置随机数种子

#include <stdlib.h>

void srand(unsigned int seed);

seed ：指定一个随机数中， int 类型的数据，一般将当前时间作为随机数种子赋值给参数 seed ，譬如 time(NULL) ，因为每次启动应用程序时间上是一样的，所以就能够使得程序中设置的随机数种子在每次启动程序时是不一样的。

返回值： void

常用的用法 srand(time(NULL));

#include <stdio.h>
#include <stdlib.h>
#include <time.h>
int main(int argc, char *argv[])
{
 int random_number_arr[8];
 int count;
 /* 设置随机数种子 */
 srand(time(NULL));
 /* 生成伪随机数 */
 for (count = 0; count < 8; count++)
 random_number_arr[count] = rand() % 100;
 /* 打印随机数数组 */
 printf("[");
 for (count = 0; count < 8; count++) {
 printf("%d", random_number_arr[count]);
 if (count != 8 - 1)
 printf(", ");
 }
 printf("]\n");
 exit(0);
}

休眠(重要)

有时需要将进程暂停或休眠一段时间，进入休眠状态之后，程序将暂停运行，直到休眠结束。常用的系统调用和 C 库函数有 sleep() 、 usleep() 以及 nanosleep() ，这些函数在应用程序当中通常作为延时使用，譬如延时 1 秒钟

秒级休眠 : sleep（以秒为单位休眠）

#include <unistd.h>

unsigned int sleep(unsigned int seconds);

seconds ：休眠时长，以秒为单位。

返回值： 如果休眠时长为参数 seconds 所指定的秒数，则返回 0 ；若被信号中断则返回剩余的秒数。

#include <stdio.h>
#include <stdlib.h>
#include <unistd.h>
int main(void) {
 puts("Sleep Start!");
 /* 让程序休眠 3 秒钟 */
 sleep(3);
 puts("Sleep End!");
 exit(0);
}

微秒级休眠: usleep

#include <unistd.h>

int usleep(useconds_t usec);

usec ：休眠时长，以微秒为单位。

返回值： 成功返回 0 ；失败返回 -1 ，并设置 errno 。

#include <stdio.h>
#include <stdlib.h>
#include <unistd.h>
int main(void) {
 puts("Sleep Start!");
 /* 让程序休眠 3 秒钟(3*1000*1000 微秒) */
 usleep(3 * 1000 * 1000);
 puts("Sleep End!");
 exit(0);
}

高精度休眠 : nanosleep（支持纳米级休眠设置）

#include <time.h>

int nanosleep(const struct timespec *req, struct timespec *rem);

使用该函数需要包含头文件 <time.h> 。

req ：一个 struct timespec 结构体指针，指向一个 struct timespec 变量，用于设置休眠时间长度，可精确到纳秒级别。

rem ：也是一个 struct timespec 结构体指针，指向一个 struct timespec 变量，也可设置 NULL 。

#include <stdio.h>
#include <stdlib.h>
#include <time.h>
int main(void) {
 struct timespec request_t;
 puts("Sleep Start!");
 /* 让程序休眠 3 秒钟 */
 request_t.tv_sec = 3;
 request_t.tv_nsec = 0;
 nanosleep(&request_t, NULL);
 puts("Sleep End!");
 exit(0);
}

申请堆内存(重要)

在操作系统下，内存资源是由操作系统进行管理、分配的，当应用程序想要内存时（这里指的是堆内存），可以向操作系统申请内存，然后使用内存；当不再需要时，将申请的内存释放、归还给操作系统；在许多的应用程序当中，往往都会有这种需求，譬如为一些数据结构动态分配/ 释放内存空间，本小节向大家介绍应用程序如何向操作系统申请堆内存。

在堆上分配内存： malloc 和 free（这很熟悉了应该）

malloc() 在堆区分配一块指定大小的内存空间，用来存放数据。这块内存空间在函数执行完成后不会被初始化，它们的值是未知的，所以通常需要程序员对 malloc() 分配的堆内存进行初始化操作。

在堆上分配的内存，需要开发者自己手动释放掉，通常使用 free() 函数释放堆内存

申请过以后，最好free()释放掉，如果持续占用，将会导致内存泄漏

#include <stdlib.h>

void *malloc(size_t size);

使用该函数需要包含头文件 <stdlib.h> 。

size ：需要分配的内存大小，以字节为单位。

返回值： 返回值为 void * 类型，如果申请分配内存成功，将返回一个指向该段内存的指针

#include <stdlib.h>

void free(void *ptr);

使用该函数同样需要包含头文件 <stdlib.h> 。

ptr ：指向需要被释放的堆内存对应的指针。

#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#define MALLOC_MEM_SIZE (1 * 1024 * 1024)
int main(int argc, char *argv[])
{
 char *base = NULL;
 /* 申请堆内存 */
 base = (char *)malloc(MALLOC_MEM_SIZE);
 if (NULL == base) {
 printf("malloc error\n");
 exit(-1);
 }
 /* 初始化申请到的堆内存 */
 memset(base, 0x0, MALLOC_MEM_SIZE);
 /* 使用内存 */
 /* ...... */
 /* 释放内存 */
 free(base);
 exit(0);
}