C标准库

C标准库

/**
 * @file    ctype_note.c
 * @brief   ctye.h笔记
 * @author	hatlonely
 * @e-mail	hatlonely@foxmail.com
 * @date    2013-01-07
 */

/****************************************************************
 * <ctype.h>用于字符的识别和转换
 * ctype.h中的函数已经针对运行速度经过优化，大多函数都通过宏实现
 * 这些函数的可移植性好，可以再任何字符集上运行
 * 当地点发生改变，ctype.h中的函数会相应地调整其行为
 ****************************************************************/

#include <stdio.h>
#include <ctype.h>

/****************************************************************
 * 识别字符函数
 *
 * 当且仅当参数c与函数描述一致时返回非零（真）
 *
 * 标准运动控制字符：换页、换行、回车、水平制表符，垂直制表符
 *					('\f', '\n', '\r', '\t', '\v')
 * isdigit		所有十进制数字，[0-9]
 * isxdigit		十六进制数字，[0-9a-fA-F]
 * islower		小写字母，[a-z]
 * isupper		大写字母，[A-Z]
 * isalpha		字母，isupper或者islower
 * isalnum		字母或数字，isalpha或者isdigit
 * isgraph		图形字符，除空格之外的所有打印字符
 * isprint		打印字符，包括空格在内的所有可打印字符
 * ispunct		除空格和所有isalnum之外的所有字符
 *				如：!@#$%^&*;:'"<>=+-*[]\
 * iscntrl		所有控制字符：5个标准的运动控制字符、退格符BS
 *				和警报符BEL
 * isspace		标准空白字符，5个标准运动控制字符和空格
 ****************************************************************/
/* extern int isdigit(int c); */
/* extern int isxdigit(int c); */
/* extern int islower(int c); */
/* extern int isupper(int c); */
/* extern int isalpha(int c); */
/* extern int isalnum(int c); */
/* extern int isgraph(int c); */
/* extern int isprint(int c); */
/* extern int ispunct(int c); */
/* extern int iscntrl(int c); */
/* extern int isspace(int c); */

/****************************************************************
 * 识别字符函数
 *
 * tolower把大写字母c转换为小写，如果c不是大写字母，则返回原来值
 * toupper把小写字母c转换为大写，如果c不是小写字母，则返回原来值
 ****************************************************************/
/* extern int tolower(int c); */
/* extern int toupper(int c); */


/****************************************************************
 * 主函数
 ****************************************************************/
extern void ctype_main(void)
{
	int c = '\t';
	int lower = 'l';
	int upper = 'U';

	printf("=================================================\n");
	printf("                  ctype.h\n");
	printf("=================================================\n");
	printf("character c = %c:\n", c);
	isdigit(c) ? printf("isdigit\n") : printf("!isdigit\n");
	isxdigit(c) ? printf("isxdigit\n") : printf("!isxdigit\n");
	isupper(c) ? printf("isupper\n") : printf("!isupper\n");
	islower(c) ? printf("islower\n") : printf("!islower\n");
	isalpha(c) ? printf("isalpha\n") : printf("!isalpha\n");
	isalnum(c) ? printf("isalnum\n") : printf("!isalnum\n");
	isgraph(c) ? printf("isgraph\n") : printf("!isgraph\n");
	isprint(c) ? printf("isprint\n") : printf("!isprint\n");
	ispunct(c) ? printf("ispunct\n") : printf("!ispunct\n");
	iscntrl(c) ? printf("iscntrl\n") : printf("!iscntrl\n");
	isspace(c) ? printf("isspace\n") : printf("!isspace\n");

	printf("%c to upper is %c\n", lower, toupper(lower));
	printf("%c to lower is %c\n", upper, toupper(upper));
	printf("\n");
}

/**
 * @file    math_note.c
 * @brief   math.h笔记
 * @author	hatlonely
 * @e-mail	hatlonely@foxmail.com
 * @date    2013-01-07
 */

/****************************************************************
 * <math.h>常用的数学函数
 * math.h处理错误的方式与其他库函数不同，当错误发生时，math.h中的
 * 大多数函数会将一个错误编码存到errno变量中，该变量在errno.h中。
 * 常见的错误有两种：
 *		定义域错误，对应的错误编码EDOM
 *		取值范围错误，对应的错误编码ERANGE
 ****************************************************************/

#include <stdio.h>
#include <math.h>

#define PI 3.1415927
#define E 2.71828183
/****************************************************************
 * 三角函数
 * 
 * 参数x为角度（弧度为单位）
 * 角度和弧度的转换：R为弧度，A为角度
 *      R = PI * A / 180; A = 180 * R / PI
 * cos和sin函数的返回值为[-1, 1]
 ****************************************************************/
/* extern double cos(double x); */
/* extern double sin(double x); */
/* extern double tan(double x); */

static double ator(double a)
{
    return (PI * a / 180);
}
void tri_sample(void)
{
    double a;       /* 角度 */
    double r;       /* 弧度 */
    double val;		/* 三角函数值 */

    printf("三角函数\n");

    a = 60;
    r = ator(a);
    val = cos(r);
    printf("cos %lg = %lg，对应角度为%lg\n", r, val, a);

    a = 30;
    r = ator(a);
    val = sin(r);
    printf("sin %lg = %lg，对应角度为%lg\n", r, val, a);

    a = 45;
    r = ator(a);
    val = tan(r);
    printf("tan %lg = %lg，对应角度为%lg\n", r, val, a);

	printf("\n");
}
/****************************************************************
 * 反三角函数
 * 
 * acos和asin参数x在[-1, 1]范围内，否则发生定义域错误
 * acos正常返回值在[0, PI]
 * asin正常返回值在[-PI/2, PI/2]
 * atan正常返回值在[-PI/2, PI/2]
 * atan2返回y/x的反正切，返回值在[-PI, PI]
 ****************************************************************/
/* extern double acos(double x); */
/* extern double asin(double x); */
/* extern double atan(double x); */
/* extern double atan2(double y, double x); */

static double rtoa(double r)
{
    return (180 * r / PI);
}
void anti_tri_sample(void)
{
    double x;
    double a;
    double r;

    printf("反三角函数\n");

    x = 0.5;
    r = acos(x);
    a = rtoa(r);
    printf("arccos %lg = %lg，对应角度为%lg\n", x, r, a);

    x = 0.5;
    r = asin(x);
    a = rtoa(r);
    printf("arcsin %lg = %lg，对应角度为%lg\n", x, r, a);

    x = 1;
    r = atan(x);
    a = rtoa(r);
    printf("arctan %lg = %lg，对应角度为%lg\n", x, r, a);

	printf("\n");
}
/****************************************************************
 * 双曲函数
 * 
 * cosh(x) = [e^x + e^(-x)] / 2
 * sinh(x) = [e^x - e^(-x)] / 2
 * tanh(x) = sinh(x) / consh(x) 
 *         = [e^x - e^(-x)] / [e^x + e^(-x)]
 * 如果参数x的值太大，会发生值域错误
 ****************************************************************/
/* extern double cosh(double x); */
/* extern double sinh(double x); */
/* extern double tanh(double x); */

void hyp_sample(void)
{
    double x = 0.7;

    printf("双曲函数\n");

    printf("cosh %lg = %lg\n", x, cosh(x));
    printf("sinh %lg = %lg\n", x, sinh(x));
    printf("tanh %lg = %lg\n", x, tanh(x));

	printf("\n");
}
/****************************************************************
 * 指数函数和对数函数
 * 
 * exp(x) = e^x
 * log(x)计算x的自然对数，参数为正数
 * log10(x)计算以10为底的对数，参数为正数
 ****************************************************************/
/* extern double exp(double x); */
/* extern double log(double x); */
/* extern double log10(double x); */

void exp_sample(void)
{
    double x;

    printf("指数函数和对数函数\n");

    x = 1;
    printf("exp %lg = %lg\n", x, exp(x));
    x = E;
    printf("log %lg = %lg\n", x, log(x));
    x = 10000;
    printf("log10 %lg = %lg\n", x, log10(x));

	printf("\n");
}
/****************************************************************
 * 浮点数处理函数
 *
 * frexp把一个浮点数规格化为一个小数和一个2的整数次幂
 * value = frexp(value, exp) * (2 ^ (*exp))
 * frexp的返回值为[1/2, 1)
 *
 * ldexp计算一个浮点数和2的整数次幂的乘积，与frexp相对
 * ldexp(x, exp) = x * (2 ^ exp)
 *
 * modf把一个浮点数value分为整数部分*iptr和小数部分modf(value, iptr)
 * value = *iptr + modf(value, iptr)
 ****************************************************************/
/* extern double frexp(double value, int *exp); */
/* extern double ldexp(double x, int exp); */
/* extern double modf(double value, double *iptr); */

void flo_sample(void)
{
    double unnnum;  /* 非规格浮点数，unnormalized number */
    double nornum;  /* 0.5~1的浮点数，normalized number */
    int n;          /* 2的次幂 */
    double fval;	/* 浮点数 */
    double intpart; /* 整数部分，integer part */
    double frapart; /* 小数部分，fractional part */

    printf("浮点数函数\n");

    unnnum = 5.0;
    nornum = frexp(unnnum, &n);
    printf("frexp %lg = %lg，n = %d\n", unnnum, nornum, n);
    printf("  %lg = %lg * (2 ^ %d)\n", unnnum, nornum, n);

    nornum = 0.7;
    n = 4;
    unnnum = ldexp(nornum, n);
    printf("ldexp (%lg, %d) = %lg\n", nornum, n, unnnum);
    printf("  %lg = %lg * (2 ^ %d)\n", unnnum, nornum, n);

    fval = -123.456;
    frapart = modf(fval, &intpart);
    printf("modf %lg = %lg，intpart = %lg\n", fval, frapart, intpart);
    printf("  %lg整数部分%lg，小数部分%lg\n", fval, frapart, intpart);

	printf("\n");
}
/****************************************************************
 * 幂函数
 *
 * pow(x, y) = x ^ y
 * x < 0 并且y不是一个整数时，发生定义域错误
 * x = 0 并且 y <= 0 时，其结果不能表示
 *
 * sqrt(x) = x ^ 0.5，返回x的平方根，参数x为非负数
 ****************************************************************/
/* extern double pow(double x, double y); */
/* extern double sqrt(double x); */

void pow_sample(void)
{
    double x = 4.0;
    double y = 3.0;

    printf("幂函数\n");

    printf("pow (%lg, %lg) = %lg\n", x, y, pow(x, y));
    printf("sqrt %lg = %lg\n", x, sqrt(x));

	printf("\n");
}
/****************************************************************
 * 其他浮点处理函数
 *
 * ceil计算不小于x的最小整数
 * floor计算不大于x的最小整数
 * fabs计算x的绝对值
 * fmod计算x/y的浮点余数
 ****************************************************************/
/* extern double ceil(double x); */
/* extern double floor(double x); */
/* extern double fabs(double x); */
/* extern double fmod(double x, double y); */

void oth_sample(void)
{
    double x = -17.6;
    double y = 6.0;

    printf("其他浮点处理函数\n");

    printf("ceil %lg = %lg\n", x, ceil(x));
    printf("floor %lg = %lg\n", x, floor(x));
    printf("fabs %lg = %lg\n", x, fabs(x));
    printf("fmod (%lg, %lg) = %lg\n", x, y, fmod(x, y));

	printf("\n");
}


/****************************************************************
 * 主函数
 ****************************************************************/
void math_main(void)
{
	printf("=================================================\n");
	printf("                  math.h\n");
	printf("=================================================\n");
    tri_sample();
    anti_tri_sample();
    hyp_sample();
    exp_sample();
    flo_sample();
    pow_sample();
    oth_sample();
}

/**
 * @file    time_note.c
 * @brief   time.h笔记
 * @author	hatlonely
 * @e-mail	hatlonely@foxmail.com
 * @date    2013-01-08
 */

/****************************************************************
 * <time.h>日期和时间
 ****************************************************************/

#include <stdio.h>
#include <time.h>

/****************************************************************
 * 类型和宏
 *
 * CLOCKS_PER_SEC	表达式clock()/CLOCKS_PER_SEC以秒为单位计算占用
 *					处理器时间
 * clock_t			函数clock的返回类型，可以是整型也可以是浮点型
 * size_t			sizeof运算返回的类型就是size_t，它是一个无符号
 *					整数类型，unsigned int 或者 unsigned long
 * time_t			函数time的返回类型，不能直接进行算术运算
 * struct tm		它保存了一个日历时间（细分时间）的各个组成部分
 ****************************************************************/ 

/****************************************************************
 * 时间操纵函数
 *
 * clock		返回程序使用处理器时间的最佳近似值
 * difftime		time1 - time0，返回以秒为单位的double类型的值
 * mktime		把timeptr指向的tm结构体中的本地时间转换为一个
 *				size_t类型的日历时间值
 * time			参数timer = NULL时，返回当前的日历时间值
 *				参数timer不为空时，返回值赋给timer指定的对象
 *
 * time上是返回1970年1月1日00:00:00到当前时间的秒数
 * 如果要进行效率分析，用clock函数比time函数精确
 ****************************************************************/
/* extern clock_t clock(void); */
/* extern double difftime(time_t time1, time_t time0); */
/* extern time_t mktime(struct tm *timeptr); */
/* extern time_t time(time_t *timer); */

/****************************************************************
 * 时间转换函数
 *
 * asctime		把timeptr指向的结构转换为固定格式的字符串
 * ctime		把timer指向的日历时间值转换为串形式的本地时间
 *				等价于asctime(localtime(timer))
 * gmtime		把timer指向的日历时间值转换为以UTC表示的细分时间
 * localtime	把timer指向的日历时间值转换为以本地时间表示的细分
 *				时间
 * strftime		把timeptr指向的细分时间格式化为format的形式保存到
 *				s数组中，maxsize为s的最大长度
 *				format的格式中：
 *				"%y"  不带世纪的年份（00~99）
 *				"%Y"  带世纪的年份
 *				"%m"  月份（01~12）
 *				"%b"  缩写的月份名
 *				"%B"  完整的月份名
 *				"%d"  当月的第几天（01~31）
 *				"%j"  当年的第几天（001~366）
 *				"%U"  当年的第几周，每星期从星期日开始（00~53）
 *				"%W"  当年的第几周，每星期从星期一开始（00~53）
 *				"%w"  星期（0~6），星期日表示为0
 *				"%a"  缩写的星期名
 *				"%A"  完整的星期名
 *				"%H"  24小时制的小时（00~23）
 *				"%I"  12小时制的小时（01~12）
 *				"%M"  分钟（00~59）
 *				"%S"  秒（00~59）
 *				"%z"  时区名字或者时区缩写
 *				"%x"  区域设置的适当的日期
 *				"%X"  区域设置的适当的时间
 *				"%c"  区域设置的适当的日期和时间
 ****************************************************************/
/* extern char *asctime(const struct tm *timeptr); */
/* extern char *ctime(const time_t *timer); */
/* extern struct tm *gmtime(const time_t *timer); */
/* extern struct tm *localtime(const time_t *timer); */
/* extern size_t strftime(char *s, size_t maxsize,  */
		/* const char *format, const struct tm *timeptr); */


/****************************************************************
 * 主函数
 ****************************************************************/
void time_main(void)
{
	clock_t time_start;		/* 程序开始时间 */
	clock_t time_end;		/* 程序结束时间 */
	int running_time;		/* 程序运行时间 */
	int running_seconds;	/* 程序运行秒数 */
	time_t time1, time0;	/* difftime函数参数 */
	time_t t;				/* timer指向的值 */
	time_t *timer = &t;		/* ctime，gmtime， localtime的参数 */
	char timestr[100];		/* strtime的参数 */
	int i;					/* 延时的循环变量 */

	printf("=================================================\n");
	printf("                  time.h\n");
	printf("=================================================\n");

	time_start = clock();	/* 开始时间 */
	time0 = time(timer);

	printf("本地时间ctime: %s\n", ctime(timer));
	printf("UTC时间asctime(gmtime()):%s\n", 
			asctime(gmtime(timer)));

	strftime(timestr, 100, "%Y年%m月%d日 %H:%M:%S\n", 
			localtime(timer));
	printf("自定义时间格式strftime: %s\n", timestr);

	printf("延时...\n");
	for(i = 0; i < 1000000000; i++);	/* 延时 */

	time1 = time(NULL);
	printf("time1: %lf, time0: %lf\n", 
			(double)time1, (double)time0);
	printf("difftime(time1, time0): %lf\n", 
			difftime(time1, time0));

	time_end = clock();		/* 结束时间 */
	running_time = (int)time_end - (int)time_start;
	running_seconds = running_time / CLOCKS_PER_SEC;
	printf("time_start: %d, time_end: %d, running_time: %d\n",
			(int)time_start, (int)time_end, running_time);
	printf("CLOCKS_PER_SEC: %d, running_seconds: %d\n", 
			(int)CLOCKS_PER_SEC, running_seconds);
	printf("\n");
}

/**
 * @file    string_note.c
 * @brief   string.h笔记
 * @author	hatlonely
 * @e-mail	hatlonely@foxmail.com
 * @date    2013-01-11
 */

/****************************************************************
 * <string.h>串处理，3种形式的串
 * 1.名字以mem开头的函数对任意字符序列进行操作
 *		可以操作结构体等
 * 2.名字以str开头的函数对字符串进行操作
 *		操作遇到'\0'停止，可能发生越界错误
 * 3.名字以strn开头的函数对字符串序列操作
 *		参数n限制操作的最大范围，因此比以str开头的函数更安全
 ****************************************************************/

#include <stdio.h>
#include <string.h>

/****************************************************************
 * 复制函数
 * memcpy		从s2指向的对象复制n个字符到s1指向的对象中
 *				如果对象之间有重叠，这种行为未定义
 * memmove		从s2指向的对象中复制n个字符到s1指向的对象中
 * strcpy		把s2指向的串（包括'\0'）复制到s1指向的数组
 *				如果对象之间有重叠，这种行为未定义，返回s1
 * strncpy		从s2指向的数组中复制最多n个字符到s1指向的数组中
 *				如果对象之间有重叠，这种行为未定义，返回s1
 ****************************************************************/
/* extern void *memcpy(void *s1, const void *s2, size_t n); */
/* extern void *memmove(void *s1, const void *s2, size_t n); */
/* extern char *strcpy(char *s1, const char *s2); */
/* extern char *strncpy(char *s1, const char *s2, size_t n); */

/****************************************************************
 * 拼接函数
 *
 * strcat		把s2指向的串的添加到s1指向的串的末尾
 *				如果对象之间有重叠，这种行为未定义，返回s1
 * strncat		从s2指向的数组中将最多n个字符添加到s1的末尾
 *				如果对象之间有重叠，这种行为未定义，返回s1
 ****************************************************************/
/* extern char *strcat(char *s1, const char *s2); */
/* extern char *strncat(char *s1, const char *s2, size_t n); */

/****************************************************************
 * 比较函数
 *
 * memcmp		将s1指向的对象的前n个字节和s2指向的对象的前n个字节
 *				进行比较，结构对象内部为对齐而填充的“空隙”内容是
 *				不确定的
 * strcmp		比较串s1和s2的大小，相等时返回0
 * strcoll		比较串s1和s2的大小，比较时串都被解释为适合当前区域
 *				设置的类别LC_COLLATE的形式
 * strncmp		最多比较串s1和串s2的前n个字符
 * strxfrm		将转换s2为另一种形式到s1
 *				这种转换使得用strcmp比较转换后的字符串和用strcoll
 *				比较转换前的字符串的返回值是一样的
 ****************************************************************/
/* extern int memcmp(const void *s1, const void *s2, size_t n); */
/* extern int strcmp(const char *s1, const char *s2); */
/* extern int strcoll(const char *s1, const char *s2); */
/* extern int strncmp(const char *s1, const char *s2, size_t n); */
/* extern size_t strxfrm(char *s1, const char *s2, size_t n); */

/****************************************************************
 * 查找函数
 *
 * memchr		返回s指向的对象的前n个字符（每个字节解释为unsigned
 *				char）中字符c出现的位置，若没有返回空
 * strchr		返回串s中字符c第一次出现的位置，若没有返回空
 * strrchr		返回串s中字符c最后一次出现的位置，若没有返回空
 * strpbrk		确定s2指向的串中的任意字符在s1指向的串中第一次出现
 *				的位置
 * strspn		计算s1指向的字符串中完全由是s2指向的串中字符组成的
 *				最大初始段长度
 * strcspn		计算s1指向的字符串中完全不是由s2指向的串中字符组成
 *				的最大初始段长度
 * strstr		确定s2指向的串的字符序列在s1指向的串中第一次出现的
 *				位置
 * strtok		连续调用strtok把s1指向的串分解为一系列记号，每个记
 *				号都由s2指向的串的字符界定
 ****************************************************************/
/* extern void *memchr(const void *s, int c, size_t n); */
/* extern char *strchr(const char *s, int c); */
/* extern char *strrchr(const char *s, int c); */
/* extern char *strpbrk(const char *s1, const char *s2); */
/* extern size_t strspn(const char *s1, const char *s2); */
/* extern size_t strcspn(const char *s1, const char *s2); */
/* extern char *strstr(const char *s1, const char *s2); */
/* extern char *strtok(char *s1, const char *s2); */

/****************************************************************
 * 其他函数
 *
 * memset		用c（转成unsigned char）的值填充s的前n个字节
 * strerror		将errnum中的错误编号对应到一个错误信息串
 * strlen		计算串s的长度，'\0'表示一个串的结束
 ****************************************************************/
/* extern void *memset(void *s, int c, size_t n); */
/* extern char *strerror(int errnum); */
/* extern size_t strlen(const char *s); */


/* 自定义结构体，在示例程序中使用 */
struct str_st
{
	int i;
	float f;
	char c;
};
void st_print(char *name, struct str_st *s)
{
	printf("%s: {c:%c, i:%i, f:%f}\n", name, s->c, s->i, s->f);
}

/****************************************************************
 * 主函数
 ****************************************************************/
void string_main(void)
{
	char s1[100];
	const char *s2 = "hello world!";
	const char *s3 = "hello ";
	const char *s4 = "world!";
	struct str_st st1 = {'a', 2, 123.456};
	struct str_st st2;

	printf("=================================================\n");
	printf("                  string.h\n");
	printf("=================================================\n");

	printf("s2: %s\n", s2);
	printf("s3: %s\n", s3);
	printf("s4: %s\n", s4);
	printf("\n");

	printf("memset(s1, 0, sizeof(s1))\n");
	memset(s1, 0, sizeof(s1));
	printf("s1: %s\n\n", s1);

	printf("strncpy(s1, s2, 7)\n");
	strncpy(s1, s2, 7);
	printf("s1: %s\n\n", s1);

	printf("strcpy(s1, s3)\n");
	strcpy(s1, s3);
	printf("s1: %s\n\n", s1);

	printf("strcat(s1, s4)\n");
	strcat(s1, s4);
	printf("s1: %s\n\n", s1);

	printf("strncat(s1, s4, 3)\n");
	strncat(s1, s4, 3);
	printf("s1: %s\n\n", s1);

	printf("memcpy(s1, s4, strlen(s2) + 1)\n");
	memcpy(s1, s2, strlen(s2) + 1);
	printf("s1: %s\n\n", s1);

	printf("strcmp(s1, s2): %d\n", strcmp(s1, s2));
	printf("strcoll(s1, s4): %d\n", strcoll(s1, s4));
	printf("strncmp(s1, s3, 6): %d\n", strncmp(s1, s3, 6));
	printf("strncmp(s1, s3, 7): %d\n", strncmp(s1, s3, 7));
	printf("memcmp(s1, s3, 6): %d\n", memcmp(s1, s3, 6));
	printf("memcmp(s1, s3, 7): %d\n", memcmp(s1, s3, 7));
	printf("\n");
	
	printf("srtchr(s2, 'l'): %d\n", strchr(s2, 'l') - s2);
	printf("srtrchr(s2, 'l'): %d\n", strrchr(s2, 'l') - s2);
	printf("memchr(s2, 'l', 10): %d\n", 
			(char *)memchr(s2, 'l', 10) - s2);
	printf("srtpbrk(s2, \"abcd\"): %d\n", 
			strpbrk(s2, "abcd") - s2);
	printf("strspn(s2, \"hel\"): %d\n", strspn(s2, "hel"));
	printf("strcspn(s2, \"orl\"): %d\n", strcspn(s2, "orl"));
	printf("srtrchr(s2, \"llo\"): %d\n", strstr(s2, "llo") - s2);
	printf("strlen(s2): %d\n", strlen(s2));
	printf("strerror(0): %s\n", strerror(0));
	printf("\n");
	
	strcpy(s1, "192.168.0.1");
	printf("s1: %s\n", s1);
	printf("strtok(s1): ");
	printf("%s ", strtok(s1, "."));
	printf("%s ", strtok(NULL, "."));
	printf("%s ", strtok(NULL, "."));
	printf("%s\n", strtok(NULL, "."));
	printf("\n");

	st_print("st1", &st1);
	st_print("st2", &st2);
	printf("\n");

	printf("memcpy(st2, st1, sizeof(struct str_st))\n");
	memset(&st2, 0, sizeof(struct str_st));
	st_print("st2", &st2);
	printf("\n");

	printf("memcpy(st2, st1, sizeof(struct str_st))\n");
	memcpy(&st2, &st1, sizeof(struct str_st));
	st_print("st2", &st2);

	printf("\n");
	printf("memcmp st1, st2: %d\n", 
			memcmp(&st1, &st2, sizeof(struct str_st)));
	printf("\n");
}

/**
 * @file    stdlib_note.c
 * @brief   stdlib.h笔记
 * @author	hatlonely
 * @e-mail	hatlonely@foxmail.com
 * @date    2013-01-12
 */

/****************************************************************
 * <stdlib.h>是一个大杂烩，定义和声明了那些没有明显定义的宏和函数
 ****************************************************************/

#include <stdio.h>
#include <stdlib.h>

/****************************************************************
 * 类型和宏
 *
 * size_t		sizeof运算符返回的类型
 * wchar_t		宽字节字符，如：L'x'的类型就是wchar_t
 * div_t		函数div的返回值，包含商和余数的结构体
 *				商和余数的类型都为int
 * ldiv_t		函数ldiv的返回值，和div_t类似
 *				商和余数的类型都为long int
 *				现在的很多编译器int和long int都占4个字节
 *				在这些编译器里，div_t和ldiv_t实际上是一样的
 * EXIT_FAILURE	exit的参数或者main函数的返回值，表示程序不成功终止
 * EXIT_SUCCESS	exit的参数或者main函数的返回值，表示程序成功终止
 * MB_CUR_MAX	当前区域设置（类型为LC_CTYPE）指定的扩展字符集中多
 *				字节字符的最大字节数目，该值小于MB_LEN_MAX
 * RAND_MAX		rand()函数返回的最大值，该值至少为32767
 ****************************************************************/
/****************************************************************
 * 字符转换函数
 *
 * atoi			把nptr指向的字符串初始部分转换为int
 * atol			把nptr指向的字符串初始部分转换为long int
 *				有些编译器int和long int一样都占4个字节
 *				此时，atol和atoi一样
 * atof			把nptr指向的字符串初始部分转换为double
 * strtod		把nptr指向的字符串初始部分转换为double
 *				如果endptr != NULL，enptr存储最后串的指针
 *				double序列的期望形式是首先可选的正负号，然后是数字
 *				序列（可能包括小数点），接着可能是可选的指数部分
 * strtol		把nptr指向的字符串初始部分按base进制转换为long
 * strtoul		把nptr指向的字符串初始部分转换为unsigned long
 ****************************************************************/
/* extern int atoi(const char *nptr); */
/* extern long int atol(const char *nptr); */
/* extern double atof(const char *nptr); */
/* extern double strtod(const char *nptr, char **endptr); */
/* extern long int strtol(const char *nptr, char **endptr,  */
		/* int base); */
/* extern unsigned long int strtoul(const char *nptr,  */
		/* char **endptr, int base); */

void to_sample(void)
{
	char pc[20];
	char **endptr = (char **)&pc;
	char *pi = "123abc";
	char *pl = "4294967296def";
	char *pf = "123.456e-2ghi";
	int i;
	long int l;

	printf("atoi(%s): %d\n", pi, atoi(pi));
	printf("atol(%s): %ld\n", pl, atol(pl));
	printf("atof(%s): %f\n", pf, atof(pf));

	i = strtod(pi, endptr);
	printf("strtod(%s, endptr): %d, endptr: %s\n", pi, i, *endptr);
	l = strtol(pl, endptr, 10);
	printf("strtol(%s, endptr, 10): %ld, endptr: %s\n", 
			pl, l, *endptr);
	printf("strtol(\"0xff\", endptr, 16): %ld\n", 
			strtol("0xff", endptr, 16));
	printf("\n");
}

/****************************************************************
 * 伪随机序列产生函数
 *
 * rand			产生一个0~RAND_MAX之间的为随机数
 * srand		设置rand()函数的种子，相同的种子产生相同的随机数
 ****************************************************************/
/* extern int rand(void); */
/* extern void srand(unsigned int seed); */

void rand_sample(void)
{
	int i;

	srand(10);
	printf("rand: ");
	for (i = 0; i < 10; i++)
	{
		printf("%d  ", rand());
	}
	printf("\n\n");
}

/****************************************************************
 * 内存管理函数
 *
 * 有些编译器需要include <malloc.h>
 *
 * calloc		为nmemb个对象的数组分配空间
 *				每个元素的大小为size
 *				分配空间的所有位都初始化为零
 * malloc		为一个对象分配size大小的空间，初始值不确定
 * realloc		重新分配空间，首先判断当前指针是否有足够的连续空间
 *				如果有，扩大ptr指向的地址，返回ptr；如果空间不够，
 *				按照size分配新空间，把原数据拷贝到新空间，返回重新
 *				分配的地址空间
 *				如果ptr为空，则realloc的行为与malloc相同
 *				如果size为零，则ptr指向的空间将被释放
 * free			释放ptr指向的空间
 ****************************************************************/
/* extern void *calloc(size_t nmemb, size_t size); */
/* extern void *malloc(size_t size); */
/* extern void *realloc(void *ptr, size_t size); */
/* extern void free(void *prt); */

void mal_sample(void)
{
	int i;
	int *pi = malloc(10 * sizeof(int));

	printf("memory\n");
	for (i = 0; i < 10; ++i)
	{
		pi[i] = i;
	}
	for (i = 0; i < 10; ++i)
	{
		printf("%d ", pi[i]);
	}
	printf("\n\n");

	free(pi);
}

/****************************************************************
 * 环境通信函数
 *
 * abort		使程序异常终止，或者捕获信号SIGABRT且信号处理程序
 *				没有返回
 * exit			使用程序执行正常终止
 *				如果程序多次调用exit，这种行为未定义
 *				首先调用atexit注册函数，按照他们注册的反序调用
 *				然后清空所有打开的缓冲数据流，关闭所有打开的流，并
 *				删除tmpfile函数创建的所有文件
 *				最后控制权返回给宿主环境，返回status，不能返回给它
 *				的调用者
 * atexit		注册func函数，该函数在程序正常终止的时候被调用
 * getenv		查看环境变量name的值
 * system		把string指向的串传递给宿主环境
 ****************************************************************/
/* extern void abort(void); */
/* extern void exit(int status); */
/* extern int atexit(void (*func)(void)); */
/* extern char *getenv(const char *name); */
/* extern int system(const char *string); */

void func1(void)
{
	printf("atexit function func1 is called\n");
}
void func2(void)
{
	printf("atexit function func2 is called\n");
}
void env_sample(void)
{
	atexit(func1);
	atexit(func2);
	printf("getenv(home): %s\n", getenv("home"));
	printf("system()\n");
	/* windows中dir表示显示当前目录，linux中对应命令为ls */
	system("dir /d ");
	printf("\n\n");
}

/****************************************************************
 * 查找和排序函数
 *
 * bsearch		在数组base中查找元素key的位置
 *				nmemb为元素个数，size为每个元素的大小
 *				compar为比较函数
 * qsort		对数组base排序
 *				nmemb为元素个数，size为每个元素的大小
 *				compar为比较函数
 ****************************************************************/
/* extern void *bsearch(const void *key, const void *base,  */
		/* size_t nmemb, size_t size,  */
		/* int (*compar)(const void *, const void *)); */
/* extern void qsort(void *base, size_t nmemb, size_t szie,  */
		/* int (*compar)(const void *, const void *)); */

int compar(const int *i1, const int *i2)
{
	return *i1 - *i2;
}
void com_sample(void)
{
	int i;
	int iarray[] = {9, 3, 5, 7, 5, 8, 6, 2};
	int key = 7;
	int *pi;

	printf("iarray: ");
	for (i = 0; i < sizeof(iarray) / sizeof(int); ++i)
	{
		printf("%d ", iarray[i]);
	}
	printf("\n");
	pi = bsearch(&key, iarray, sizeof(iarray) / sizeof(int), 
			sizeof(int), compar);
	printf("key %d pos is %d\n", key, pi - iarray);

	qsort(iarray, sizeof(iarray) / sizeof(int), 
			sizeof(int), compar);
	printf("qsort iarray: ");
	for (i = 0; i < sizeof(iarray) / sizeof(int); ++i)
	{
		printf("%d ", iarray[i]);
	}
	printf("\n\n");
}

/****************************************************************
 * 整数算数
 *
 * abs		计算整数j的绝对值
 * div		计算分子numer除以分母所得的商和余数
 *			div_t是一个包含商和余数的结构体
 * labs		和abs类似，参数和返回值都是long int
 * ldiv		和div相似，参数和返回值都是long int
 ****************************************************************/
/* extern int abs(int j); */
/* extern div_t div(int numer, int denom); */
/* extern long int labs(long int j); */
/* extern ldiv_t ldiv(long int numer, long int denom); */

void math_sample(void)
{
	div_t dt = div(34, 11);
	ldiv_t ldt = ldiv(34, 11);
	printf("abs(-17): %d\n", abs(-17));
	printf("labs(-17): %d\n", labs(-17));
	printf("div(34, 11): quot %d, rem %d\n", 
			dt.quot, dt.rem);
	printf("ldiv(34, 11): quot %ld, rem %ld\n", 
			ldt.quot, ldt.rem);
	printf("\n");
}

/****************************************************************
 * 多字节字符函数
 *
 * mblen		确定s指向的多字节字符中包含的字节数
 * mbtowc		转换多字节字符为相应的宽字符
 *				首先确定s包含的字节数，然后确定这个多字节字符对应
 *				的wchar_t类型的值的编码，如果多字节字符有效且pwc不
 *				为空，在pwc中存储编码，最多检测s中的n个字节
 *				返回多字节字符包含的字节数
 * wctomb		转换宽字符为相应的多字节字符
 *				返回wchar的值对应的多字节字符包含的字节数
 * mbstowcs		转换多字节序列为相应的编码序列
 * wcstombs		转换多字节对应的编码序列成初始的多字节序列
 ****************************************************************/
/* extern int mblen(const char *s, size_t n); */
/* extern int mbtowc(wchar_t *pwc, const char *s, size_t n); */
/* extern int wctomb(char *s, wchar_t wchar); */
/* extern size_t mbstowcs(wchar_t *pwcs, const char *s, size_t n); */
/* extern size_t wcstombs(char *s, const wchar_t *pwcs, size_t n); */


/****************************************************************
 * 主函数
 ****************************************************************/
void stdlib_main(void)
{
	printf("=================================================\n");
	printf("                  stdlib.h\n");
	printf("=================================================\n");

	to_sample();
	rand_sample();
	mal_sample();
	env_sample();
	com_sample();
	math_sample();
}

/**
 * @file    stdio_note.c
 * @brief   stdio.h笔记
 * @author	hatlonely
 * @e-mail	hatlonely@foxmail.com
 * @date    2013-01-13
 */

/****************************************************************
 * <stdio.h>标准输入输出流
 * 文本文件和二进制文件在UNIX系统中不区别对待，但是MS-DOS读取文本
 * 文件时要丢弃每行后面的回车符，在UNIX系统中可以忽略fopen函数中的
 * b模式，但如果要移植到其他系统，应正确编写fopen的模式
 * 如果文本最后一行不是一整行，很多系统不能很好的处理他们，因为没
 * 有结束符它们就不能表示行的概念。如果写入文本文件的最后一个字符
 * 不是换行符，那么最后的不完整的文本行可能会丢失，或者自动补充完
 * 整，再次读取文本就多了一个换行符，或者程序运行的时候会出问题，
 * 因此要避免文本文件的最后一行不完整
 ****************************************************************/

#include <stdio.h>
#include <stdlib.h>

/****************************************************************
 * 类型和宏
 *
 * FILE			对象类型，可以记录控制流需要的所有信息
 *				包括它的文件定位符、指向相关缓冲的指针，
 *				记录是否发生了读写错误的错误指示符和
 *				记录文件是否结束的文件结束符
 * fpos_t		对象类型，可以唯一指定文件中的每个位置所需要的信息
 * _IOFBF		setvbuf的mode参数，表示完全缓冲
 * _IOLBF		setvbuf的mode参数，表示行缓冲
 * _IONBF		setvbuf的mode参数，表示没有缓冲
 * BUFSIZ		setbuf使用缓冲的大小
 * EOF			标志文件的结束，即一个流输入结束了
 * FILENAME_MAX	定义存放任意文件名的字符缓冲区的长度
 * FOPEN_MAX	程序至少可以同时打开的文件数
 * L_tmpnam		定义了足够存放一个临时文件名的字符缓冲区的长度
 * SEEK_CUR		fseek的mode参数，表示当前文件定位
 * SEEK_END		fseek的mode参数，表示文件结束
 * SEEK_SET		freek的mode参数，表示文件开始
 * TMP_MAX		tmpnam函数可以生成单独文件名的最小数目
 * stderr		标准错误数据流
 * stdin		标准输入流
 * stdout		标准输出流
 ****************************************************************/

/****************************************************************
 * 文件访问和操作
 *
 * fopen		以mode的方式打开文件filename
 *				参数mode字符串含义
 *				mode的值：[rwa][b][+]，各个字符的含义如下：
 *				r		表示以只读方式打开文件，该文件必须存在
 *				w		表示以只写方式打开文件
 *						若文件存在，截短文件长度至零
 *						若文件不存在，则创建新文件
 *				a		表示以追加方式打开文件
 *						若文件存在，写入的数据会被附加到文件尾部
 *						若文件不存在，则创建新文件
 *				b		表示二进制文件，如果没有，表示文本文件
 *				+		表示可读写方式
 *				例如：
 *				wb		表示以只写方式打开二进制文件
 *						若文件存在，截短文件长度至零
 *						若文件不存在，则创建新文件
 *				r+		以可读写方式打开文本文件，该文件必须存在
 *				a+		以追加方式打开可读写文本文件
 *						若文件存在，写入的数据会被附加到文件尾部
 *						若文件不存在，则创建新文件
 *				mode的可能只有：r, w, a, r+, w+, a+, rb, wb, ab, 
 *					rb+, wb+, ab+, r+b, w+b, a+b
 *					其中rb+和r+b，wb+和w+b，ab+和a+b含义一样
 *				操作成功返回文件对象，失败返回空
 * freopen		打开名filename文件，并把它和stream流关联在一起
 *				首先尝试关闭和指定的流关联的任意文件，如果不能成功
 *				关闭就忽略这一点
 *				成功返回stream，失败返回空
 * fclose		stream指向的流被清空，并且和流相关联的文件也被关闭
 * fflush		清除文件缓冲区，文件以写方式打开时将缓冲区内容写入
 * setvbuf		设置流stream的缓冲区为buf，缓冲区的大小为size
 *				缓冲的模式为mode，mode有3中取值：
 *				_IOFBF完全缓冲，_IOLBF行缓冲，_IONBF没有缓冲
 * setbuf		设置流stream的缓冲区为buf，缓冲区的大小为BUFSIZ
 *				缓冲的模式为_IOFBF，如果buf为空，模式为_IONBF
 * remove		删除文件名为filename的文件
 *				如果文件文件已打开，这种行为由具体实现定义
 *				成功删除时返回0
 * rename		给old文件重命名为new
 *				如果文件new已存在，这种行为由具体实现定义
 *				成功重命名时返回0
 * tmpfile		以"wb+"的模式创建临时的二进制文件
 *				如果不能创建返回空
 * tmpnam		产生一个唯一的文件名
 *				每次调用tmpnam都产生不同的文件名
 *				如果参数s不为空，产生的文件名存放在s中，并返回s
 *				如果s为空，产生的文件名存放在内部静态对象中，并返
 *				回该对象的地址
 ****************************************************************/
/* extern FILE *fopen(const char *filename, const char *mode); */
/* extern FILE *freopen(const char *filename,  */
		/* const char *mode, FILE *stream); */
/* extern int fclose(FILE *stream); */
/* extern int setvbuf(FILE *stream, char *buf,  */
		/* int mode, size_t size); */
/* extern void setbuf(FILE *stream, char *buf); */
/* extern int fflush(FILE *stream); */
/* extern int remove(const char *filename); */
/* extern int rename(const char *old, const char *new); */
/* extern FILE *tmpfile(void); */
/* extern char *tmpnam(char *s); */

void ope_sample(void)
{
	FILE *file;
	char *old = "old_file.txt";
	char *new = "new_file.txt";

	printf("create file %s\n", old);
	file = fopen(old, "w");	/* 创建old_file */
	printf("close file %s\n", old);
	fclose(file);				/* 关闭old_file */
	printf("remove file %s\n", new);
	remove(new);				/* 删除原来的new_file */
	printf("rename %s to %s\n", old, new);
	rename(old, new);			/* 重命名old_file为new_file */

	printf("create tmpfile %p\n", tmpfile());
	printf("create tmpfile %p\n", tmpfile());
	printf("tmpnam: %s\n", tmpnam(NULL));
	printf("tmpnam: %s\n", tmpnam(NULL));
	printf("tmpnam: %s\n", tmpnam(NULL));

	printf("\n");
}

/****************************************************************
 * 格式化输入输出
 *
 * fprintf		按照格式format将参数列表格式化输出到流文件stream中
 *				format参数为输出的格式
 *				格式定义：%[flags][width][.prec][F|N|h|l]type
 *				1.type	输出的类型
 *					d	有符号十进制整数
 *					i	有符号整数
 *					o	无符号八进制整数
 *					u	无符号十进制整数
 *					x	无符号十六进制整数，小写abcdef表示
 *					X	无符号十六进制整数，大写ABCDEF表示
 *					f	浮点数，[-]ddd.ddd
 *					e/E	指数形式浮点数，[-]d.ddde(+|-)dd
 *					g/G	用%f和%e表示中总位数最短的来表示浮点数
 *					c	单个字符
 *					s	char类型字符串
 *					S	wchar_t类型字符串
 *					%	%本身
 *					p	显示一个指针
 *					n	相应的参数为一个整数指针，这个整数中记录了
 *						存放已写字符的个数，不转换参数
 *				2.flags	输出格式控制
 *					无	右对齐，左边填充0和空格
 *					-	左对齐，右边填充空格
 *					+	在数字前面增加符号+或-
 *					0	将输出的前面补上0，直到占满指定列宽
 *					空格	输出值为正时加空格，为负时加负号
 *					#	当type为csdiu时没有影响
 *						type为oxX时，分别在数值前加"0"，"0x"，"0X"
 *						type为eEf时，总是使用小数点
 *						type为gG时，除了数值为0外，总是显示小数点
 *				3.width	显示宽度控制
 *					n	宽度至少为n位，不够以空格填充
 *					0n	宽度至少为n位，不够以0填充
 *					*	格式列表中，下一个参数还是width
 *				4.prec	精度控制
 *					无	按默认的精度显示
 *					0	当type为eEf时，不显示小数点
 *					n	当type为eEf时，n为最大的小数位数
 *						type为其他时，n为显示的最大宽度
 *					*	格式列表中，下一个参数还是width
 *				5.F|N|h|l
 *					F	远指针
 *					N	近指针
 *					h	短整数或单精度浮点数
 *					l	长整数或双精度浮点数
 *				函数返回传送字符的数目，错误放回负值
 * printf		格式化输出到标准输出，相当于：
 *				fprintf(stdout, format, ... )
 * sprintf		格式化输出到字符串，和fprintf类似
 *				只是输入出写入到一个字符数组中，而不是流文件中
 * vfprintf		与fprintf等价，只是可变参数列表用arg代替
 * vprintf		与printf等价，只是可变参数列表用arg代替
 * vsprintf		与sprintf等价，只是可变参数列表用arg代替
 * fscanf		按照格式format从流stream中格式化读取输入到参数列表
 *				format为输入的格式
 *				格式说明符
 *					a/A	读浮点值（C99适用）
 *					c	读单个字符
 *					d	读十进制整数
 *					u	读无符号十进制整数
 *					i	读整数
 *					o	读八进制整数
 *					x	读十六进制整数
 *					e/f/g	有符号浮点数	
 *					s	读字符串，即非空白字符序列
 *					[]	扫描字符集合
 *					p	读指针值
 *					n	不读取输入，相应的参数为一个整数指针
 *						这个整数中记录了存放已写字符的个数
 *					%	读%
 *				修饰符
 *					L/l	长度修饰（long）
 *					h	长度修饰（short）
 *					数字	整型常数，指定输入数据所占宽度
 *					*	表示本输入项在读入后不赋值给相应变量
 *				空白符
 *					略去读取过程中一个或多个空白字符
 *				非空白字符
 *					略去与这个空白字符相同的字符
 *				函数返回成功赋值的数据项数，读到文件末尾返回EOF
 * scanf		从标准输入格式化读入，相当于：
 *				fscanf(stdin, format, ... )
 * sscanf		从字符串格式化读入，和fscanf类似
 *				只是输入出写入到一个字符数组中，而不是流文件中
 ****************************************************************/
/* extern int fprintf(FILE *stream, const char *format, ... ); */
/* extern int fscanf(FILE *stream, const char *format, ... ); */
/* extern int printf(const char *format, ... ); */
/* extern int scanf(const char *format, ... ); */
/* extern int sprintf(char *s, const char *format, ... ); */
/* extern int sscanf(const char *s, const char *format, ... ); */
/* extern int vfprintf(FILE *stream, const char *format,  */
		/* va_list arg); */
/* extern int vprintf(const char *format, va_list arg); */
/* extern int vsprintf(char *s, const char *format,  */
		/* va_list arg); */

void fmt_sample(void)
{
	FILE *file;
	char *filename = "new_file.txt";
	int i1 = 10;
	int i2 = 20;
	int i3, i4;

	file = fopen(filename, "w");
	fprintf(file, "%d %d\n", i1, i2);
	printf("fprintf %d %d to %s\n", i1, i2, filename);
	fclose(file);

	file = fopen(filename, "r");
	fscanf(file, "%d %d", &i3, &i4);
	printf("fscanf %d %d from %s\n", i3, i4, filename);
	fclose(file);
}

/****************************************************************
 * 字符输入输出
 *
 * fgetc		从流文件stream读取下一个字符
 *				返回流文件中的下一个字符，文件结束或流错误返回EOF
 * fgets		从流文件stream中读取最多n-1个字符到字符数组s中
 *				读入换行符或者文件结束符EOF之后，不在读取其它字符
 *				最后写入一个空字符
 * fputc		将字符c写入流文件stream的文件定位符指定位置处
 * fputs		把字符串s写入到流文件stream中，不写入结束的空字符
 * getc			等价于fgetc
 * getchar		从标准输入stdin读取下一个字符，相当于fgetc(stdin)
 * gets			从标准输入读取一个字符串到s指向的字符数组中
 *				遇到文件结束符或者换行符结束
 * putc			等价于fputc
 * putchar		将字符c写入到标准输出stdout，相当于fputc(c,stdout)
 * puts			把s指向的串写到stdout，并在输出最后添加一个换行符
 * ungetc		把指定字符c转换成unsigned char退回到stream流文件中
 ****************************************************************/
/* extern int fgetc(FILE *stream); */
/* extern char *fgets(char *s, int n, FILE *stream); */
/* extern int fputc(int c, FILE *stream); */
/* extern int fputs(const char *s, FILE *stream); */
/* extern int getc(FILE *stream); */
/* extern int getchar(void); */
/* extern char *gets(char *s); */
/* extern int putc(int c, FILE *stream); */
/* extern int putchar(int c); */
/* extern int puts(const char *s); */
/* extern int ungetc(int c, FILE *stream); */

void cio_sample(void)
{
	int c;

	fputs("get a character form stdin: ", stdout);
	c = fgetc(stdin);
	fputs("put a character to stdout: ", stdout);
	fputc(c, stdout);
	printf("\n");

	getchar();		/* 读取换行符 */
	printf("getchar: ");
	c = getchar();
	printf("putchar: ");
	putchar(c);
	printf("\n\n");
}
/****************************************************************
 * 直接输入输出
 *
 * fread		从流stream中读取最多nmemb个size大小的元素到ptr中
 *				返回成功读取的元素个数
 * fwrite		从ptr中读取最多nmemb个size大小的元素写入到stream中
 *				返回成功写入的元素个数
 ****************************************************************/
/* extern size_t fread(void *ptr, size_t size,  */
		/* size_t nmemb, FILE *stream); */
/* extern size_t fwrite(const void *ptr, size_t size,  */
		/* size_t nmemb, FILE *stream); */

void frw_sample(void)
{
	FILE *file;
	char *filename = "test_file.txt";
	char str[] = "This is a test file.\n";
	int i;

	file = fopen(filename, "w");
	printf("fwrite \"%s\" to %s\n", str, filename);
	fwrite(str, sizeof(char), sizeof(str) - 1, file);
	fwrite(str, sizeof(char), sizeof(str) - 1, file);
	fwrite(str, sizeof(char), sizeof(str) - 1, file);
	fclose(file);

	printf("clear str...\n");
	for (i = 0; i < sizeof(str); ++i)
	{
		str[i] = '\0';
	}
	file = fopen(filename, "r");
	printf("fread from %s to str\n", filename);
	fread(str, sizeof(char), sizeof(str) - 1, file);
	printf("str: %s", str);
	fclose(file);

	printf("\n");
}
	
/****************************************************************
 * 文件定位
 *
 * fgetpos		把stream的文件定位符当前值存储到pos中
 *				成功返回0
 * fseek		设置stream的文件定位符为whence + offset
 *				whence有3中取值：
 *				SEEK_SET文件开始，SEEK_CUR当前，SEEK_END文件结束
 *				成功返回0
 * fsetpos		设置stream的文件定位符为pos
 *				成功返回0
 * ftell		获得stream文件定位符的当前值
 * rewind		设置stream的文件定位符到文件开始处
 ****************************************************************/
/* extern int fgetpos(FILE *stream, fpos_t *pos); */
/* extern int fseek(FILE *stream, long int offset, int whence); */
/* extern int fsetpos(FILE *stream, const fpos_t *pos); */
/* extern long int ftell(FILE *stream); */
/* extern void rewind(FILE *stream); */

void pos_sample(void)
{
	FILE *file;
	char *filename = "test_file.txt";
	char str[] = "This is a test file.\n";
	fpos_t pos;

	file = fopen(filename, "r");

	printf("fseek(file, 5, SEEK_SET)\n");
	fseek(file, (long int)5, SEEK_SET);
	printf("curpos: %ld\n", ftell(file));

	printf("fgetpos to pos\n");
	fgetpos(file, &pos);
	fgets(str, sizeof(str), file);
	printf("fgets: %s", str);
	printf("curpos: %ld\n", ftell(file));
	fgets(str, sizeof(str), file);
	printf("fgets: %s", str);
	printf("curpos: %ld\n", ftell(file));

	printf("fsetpos at pos\n");
	fsetpos(file, &pos);
	printf("curpos: %ld\n", ftell(file));

	printf("rewind\n");
	rewind(file);
	printf("curpos: %ld\n", ftell(file));

	fclose(file);
}
/****************************************************************
 * 错误处理
 *
 * ferror		测试stream的错误指示符
 *				stream流设置了错误指示符时返回非0
 * perror		把errno中的错误编码转换为一条错误信息
 *				把参数s所指的字符串和错误信息写到标准错误流stderr
 * feof			如果文件结束返回非0，否则返回0
 * clearerr		清空stream指向的流的文件结束符和错误指示符
 ****************************************************************/
/* extern int ferror(FILE *stream); */
/* extern void perror(const char *s); */
/* extern int feof(FILE *stream); */
/* extern void clearerr(FILE *stream); */

void err_sample(void)
{
	perror("hehe");
}

void clean_all(void)
{
	remove("new_file.txt");
	remove("test_file.txt");
}


/****************************************************************
 * 主函数
 ****************************************************************/
void stdio_main(void)
{
	printf("=================================================\n");
	printf("                  stdio.h\n");
	printf("=================================================\n");

	ope_sample();
	fmt_sample();
	/* cio_sample(); */
	frw_sample();
	pos_sample();
	err_sample();
	/* clean_all(); */
}

/**
 * @file    signal_note.c
 * @brief   signal.h笔记
 * @author	hatlonely
 * @e-mail	hatlonely@foxmail.com
 * @date    2013-01-14
 */

/****************************************************************
 * <signal.h>信号处理
 * 信号是程序执行过程发生的异常事件。同步信号的产生是因为程序自身
 * 的某些动作，如：除零错误或不正当访问存储器。异步信号是由程序外
 * 部的行为引起的，如：特定的组合键，或者另一个程序发送信号
 * 程序不能屏蔽的信号要求立即得到处理，如果不对信号指定一种处理方
 * 法，程序就会以失败的状态终止执行
 * 当程序收到一个信号时，就会调用相应的信号处理程序，程序的正常执
 * 行被挂起，如果信号处理程序把控制权返回给调用者，程序就会从挂起
 * 的那个点继续执行
 ****************************************************************/

#include <stdio.h>
#include <signal.h>

/****************************************************************
 * 类型和宏
 *
 * sig_atomic_t	整数类型，该类型对象可作为原子实体被访问
 * 
 * SIG_DFL		signal的第二个参数，对信号进行默认的处理
 * SIG_IGN		signal的第二个参数，忽略该信号
 * SIG_ERR		signal函数调用出错，返回SIG_ERR
 *
 * 信号类型
 * SIGABRT		异常终止，比如执行了abort函数
 * SIGFPE		错误的算术操作，比如除零或者导致溢出操作
 * SIGILL		检测到无效的函数映像，比如一条非法指令
 * SIGINT		收到一条交互式的提示信号
 * SIGSEGV		对存储器的无效访问
 * SIGTERM		送到程序中的终止请求
 * 信号的完整集合，信号的语义和信号的默认处理方法是由实现定义的
 * 所有的信号的编号都应该是正数
 ****************************************************************/
/****************************************************************
 * 信号函数
 *
 * raise		把信号sig发送给正在执行的程序，成功返回0
 * signal		指定程序接收到信号sig时，调用func处理信号
 *				参数sig为信号类型，如SIGABRT，SIGINT等
 *				参数func有3种取值：
 *				1.SIG_DFL表示对信号进行默认处理
 *				2.SIG_IGN表示对忽略该信号
 *				3.func指向一个无返回值的函数
 *					表示当这个信号发生时，就调用这个函数
 *				函数signal成功返回指定的信号sig最后一次调用signal
 *				的func的值；否则返回SIG_ERR
 ****************************************************************/
/* extern void (*signal(int sig, void (*func)(int)))(int); */
/* extern int raise(int sig); */


static int rec_sig = 0;
static void handle_int(int sig)
{
	if(SIGINT == sig)
	{
		printf("recieve signal int\n");
		rec_sig = 1;
	}
	signal(SIGINT, SIG_DFL);
}

/****************************************************************
 * 主函数
 ****************************************************************/
void signal_main(void)
{
	printf("=================================================\n");
	printf("                  signal.h\n");
	printf("=================================================\n");
	
	signal(SIGINT, handle_int);		/* 按ctrl-c产生SIGINT信号 */

	printf("按 CTRL-C 产生信号\n");
	while(!rec_sig);
	printf("按任意键退出\n");
	getchar();
}

/**
 * @file    limits_note.c
 * @brief   limit.h笔记
 * @author	hatlonely
 * @e-mail	hatlonely@foxmail.com
 * @date    2013-01-14
 */

/****************************************************************
 * <limits.h>整型的大小
 ****************************************************************/

#include <stdio.h>
#include <limits.h>

/****************************************************************
 * 整型常量
 *
 * CHAR_BIT		除位域外最小的对象的位数（字节），8
 * SCHAR_MIN	signed char类型最小值，-128
 * SCHAR_MAX	signed char类型最大值，+127
 * UCHAR_MAX	unsigned char类型最大值，255
 * CHAR_MIN		char类型最小值
 * CHAR_MAX		char类型最大值
 * MB_LEN_MAX	任何支持区域设置的多字节字符的最大字节数，1
 * SHRT_MIN		short int类型最小值，-32768
 * SHRT_MAX		short int类型最大值，+32767
 * USHRT_MAX	unsigned short int类型最大值，65535
 * INT_MIN		int类型最小值，2个字节或4个字节，与处理器有关
 * INT_MAX		int类型最大值，2个字节或4个字节，与处理器有关
 * UINT_MAX		unsigned int类型最大值
 * LONG_MIN		long int类型最小值，-2147483648
 * LONG_MAX		long int类型最大值，+2147483647
 * ULONG_MAX	unsigned long int类型最大值，4294967295
 ****************************************************************/


/****************************************************************
 * 主函数
 ****************************************************************/
void limits_main(void)
{
	printf("=================================================\n");
	printf("                  limits.h\n");
	printf("=================================================\n");
	printf("CHAR_BIT: %d\n", CHAR_BIT);
	printf("SCHAR_MIN: %d\n", SCHAR_MIN);
	printf("SCHAR_MAX: %d\n", SCHAR_MAX);
	printf("UCHAR_MAX: %d\n", UCHAR_MAX);
	printf("CHAR_MIN: %d\n", CHAR_MIN);
	printf("CHAR_MAX: %d\n", CHAR_MAX);
	printf("MB_LEN_MAX: %d\n", MB_LEN_MAX);
	printf("SHRT_MIN: %d\n", SHRT_MIN);
	printf("SHRT_MAX: %d\n", SHRT_MAX);
	printf("USHRT_MAX: %d\n", USHRT_MAX);
	printf("INT_MIN: %d\n", INT_MIN);
	printf("INT_MAX: %d\n", INT_MAX);
	printf("UINT_MAX: %u\n", UINT_MAX);
	printf("LONG_MIN: %ld\n", LONG_MIN);
	printf("LONG_MAX: %ld\n", LONG_MAX);
	printf("ULONG_MAX: %lu\n", ULONG_MAX);

	printf("\n");
}

/**
 * @file    float_note.c
 * @brief   float.h笔记
 * @author	hatlonely
 * @e-mail	hatlonely@foxmail.com
 * @date    2013-01-15
 */

/****************************************************************
 * <float.h>浮点类型特征
 * 浮点数x = s * b^e * sum(f(k) * b^(-k)) (k = 1, 2, ... , p)
 *		s	符号
 *		b	指数的基数（大于1的整数）
 *		e	指数（整数）
 *		p	精度（有效数字的位数）
 *		f(k)	小数点后第k位数字（比b小的整数）
 ****************************************************************/
#include <stdio.h>
#include <float.h>

/****************************************************************
 * 浮点常量
 *
 * FLT_ROUNDS		浮点加法的舍入模式：
 *					-1	不能确定
 *					0	向0舍入
 *					1	最近舍入
 *					2	向正无穷舍入
 *					3	向负无穷舍入
 * FLT_RADIX		指数表示的基数b
 *
 * FLT_MANT_DIG		有效数字位数（基数FLT_RADIX）
 * DBL_MANT_DIG
 * LDBL_MANT_DIG
 *
 * FLT_DIG			有效数字位数（十进制）
 * DBL_DIG
 * LDBL_DIG
 *
 * FLT_MIN_EXP		FLT_RADIX能表示的最小负的次幂
 * DBL_MIN_EXP
 * LDBL_MIN_EXP
 * FLT_MAX_EXP		FLT_RADIX能表示的最大次幂
 * DBL_MAX_EXP
 * LDBL_MAX_EXP
 *
 * FLT_MIN_10_EXP	10能表示的最小的负的次幂
 * DBL_MIN_10_EXP
 * LDBL_MIN_10_EXP
 * FLT_MAX_10_EXP	10能表示的最大次幂
 * DBL_MAX_10_EXP
 * LDBL_MAX_10_EXP
 *
 * FLT_MIN			最小的正的规格化浮点数
 * DBL_MIN
 * LDBL_MIN
 * FLT_MAX			最大可表示的有限浮点数
 * DBL_MAX
 * LDBL_MAX
 *
 * FLT_EPSILO		最小的正浮点数e，满足1.0 + e != 1.0
 * DBL_EPSILON
 * LDBL_EPSILON
 ****************************************************************/


/****************************************************************
 * 主函数
 ****************************************************************/
void float_main(void)
{
	printf("=================================================\n");
	printf("                  float.h\n");
	printf("=================================================\n");

	printf("FLT_ROUNDS: %d\n", FLT_ROUNDS);
	printf("FLT_RADIX: %d\n", FLT_RADIX);
	printf("FLT_MANT_DIG: %d\n", FLT_MANT_DIG);
	printf("DBL_MANT_DIG: %d\n", DBL_MANT_DIG);
	printf("LDBL_MANT_DIG: %d\n", LDBL_MANT_DIG);
	printf("FLT_DIG: %d\n", FLT_DIG);
	printf("DBL_DIG: %d\n", DBL_DIG);
	printf("LDBL_DIG: %d\n", LDBL_DIG);
	printf("FLT_MIN_EXP: %d\n", FLT_MIN_EXP);
	printf("DBL_MIN_EXP: %d\n", DBL_MIN_EXP);
	printf("LDBL_MIN_EXP: %d\n", LDBL_MIN_EXP);
	printf("FLT_MAX_EXP: %d\n", FLT_MAX_EXP);
	printf("DBL_MAX_EXP: %d\n", DBL_MAX_EXP);
	printf("LDBL_MAX_EXP: %d\n", LDBL_MAX_EXP);
	printf("FLT_MIN_10_EXP: %d\n", FLT_MIN_10_EXP);
	printf("DBL_MIN_10_EXP: %d\n", DBL_MIN_10_EXP);
	printf("LDBL_MIN_10_EXP: %d\n", LDBL_MIN_10_EXP);
	printf("FLT_MAX_10_EXP: %d\n", FLT_MAX_10_EXP);
	printf("DBL_MAX_10_EXP: %d\n", DBL_MAX_10_EXP);
	printf("LDBL_MAX_10_EXP: %d\n", LDBL_MAX_10_EXP);
	printf("FLT_MIN: %g\n", FLT_MIN);
	printf("DBL_MIN: %lg\n", DBL_MIN);
	printf("LDBL_MIN: %llg\n", LDBL_MIN);
	printf("FLT_MAX: %g\n", FLT_MAX);
	printf("DBL_MAX: %lg\n", DBL_MAX);
	printf("LDBL_MAX: %llg\n", LDBL_MAX);
	printf("FLT_EPSILON: %g\n", FLT_EPSILON);
	printf("DBL_EPSILON: %lg\n", DBL_EPSILON);
	printf("LDBL_EPSILON: %llg\n", LDBL_EPSILON);
	
	printf("\n");
}

/**
 * @file    assert_note.c
 * @brief   assert.h笔记
 * @author	hatlonely
 * @e-mail	hatlonely@foxmail.com
 * @date    2013-01-15
 */

/****************************************************************
 * <assert.h>的唯一目的是提供宏assert的定义，可以再程序的任何关键
 * 地方使用这个宏进行断言，如果某处断言为假，会在标准错误流中输出
 * 一条错误信息，并使程序异常终止
 * 头文件assert.h，每次包含它的时候它的行为都会发生变化
 * 其他头文件包含多次与包含一次的效果完全相同
 * 打开断言：
 *		#undef NDEBUG
 *		#include <assert.h>
 * 关闭断言
 *		#define NDEBUG
 *		#include <assert.h>
 ****************************************************************/

#include <stdio.h>
#include <assert.h>

/****************************************************************
 * 断言
 *
 * NDEBUG		断言的开关
 * assert		如果表达式为假，向标准错误流写入错误并调用abort
 *				assert的实现是一个宏
 *
 * 宏assert的结构
 *		#undef assert
 *		#ifdef NDEBUG
 *			#define assert (test) ((void)0)
 *		#else
 *			#define assert (test) ...
 *		#endif
 ****************************************************************/
/* 宏void assert(int expression); */


/****************************************************************
 * 主函数
 ****************************************************************/
void assert_main(void)
{
	printf("=================================================\n");
	printf("                  assert.h\n");
	printf("=================================================\n");

	assert(1 == 1);
	/* assert(1 == 2); */

	printf("\n");
}

/**
 * @file    errno_note.c
 * @brief   errno.h笔记
 * @author	hatlonely
 * @e-mail	hatlonely@foxmail.com
 * @date    2013-01-15
 */

/****************************************************************
 * <errno.h>定义了错误编码，错误编码与具体定义有关
 * errno是一个整型变量存储了错误编码，该值会被其它库函数改变：
 *		<math.h>中的很多函数发生域错误或者溢出错误
 *		<stdlib.h>中把文本转换成算术类型发生溢出错误
 *		<stdio.h>中改变文件中下一次读或写的位置
 *		<signal.h>中signal函数
 ****************************************************************/

#include <stdio.h>
#include <errno.h>

/****************************************************************
 * 错误
 *
 * EDOM			算术域错误码
 * ERANGE		算术溢出错误码
 * errno		一个存储错误码的整型变量
 ****************************************************************/
/* extern int errno; */


/****************************************************************
 * 主函数
 ****************************************************************/
void errno_main(void)
{
	int errnum;

	printf("=================================================\n");
	printf("                  errno.h\n");
	printf("=================================================\n");

	printf("EDOM: %d\n", EDOM);
	printf("ERANGE: %d\n", ERANGE);
	printf("\n");

	printf("error code: \n");
	for (errnum = 0; errnum < 50; errnum++)
	{
		printf("errno: %2d  %s\n", errnum, strerror(errnum));
	}
	printf("\n");
}

/**
 * @file    stdarg_note.c
 * @brief   stdarg.h笔记
 * @author	hatlonely
 * @e-mail	hatlonely@foxmail.com
 * @date    2013-01-15
 */

/****************************************************************
 * <stdarg.h>可变参数
 * C语言允许定义接受可变参数列表的函数
 * 在调用可变参数函数时，必须知道每个参数的类型，可以使用一个固定
 * 的参数来确定参数的个数和类型，如printf函数
 ****************************************************************/

#include <stdio.h>
#include <stdarg.h>

/****************************************************************
 * 可变参数
 *
 * va_list		它是一个保存va_start，va_arg，va_end所需信息的类型
 * va_start		对ap进行初始化，以便va_arg和va_end使用
 *				参数parmN是函数定义可变参数列表左边的标识符
 * va_arg		修改ap的值指向下一个参数并返回该参数
 *				type是一种参数的类型
 * va_end		使函数正常返回，可能修改ap的值
 ****************************************************************/
/* 宏void va_start(va_list ap, parmN); */
/* 宏type va_arg(va_list ap, type); */
/* 宏void va_end(va_list ap); */

void print_arg(const char *format, ...)
{
	va_list ap;

	va_start(ap, format);
	for (; *format != '\0'; ++format)
	{
		while(*format != '%')
		{
			printf("%c", *format);
			++format;
		}
		++format;
		switch(*format)
		{
		case 'i':
			printf("%d", va_arg(ap, int));
			break;
		case 'd':
			printf("%lf", va_arg(ap, double));
			break;
		case 's':
			printf("%s", va_arg(ap, char *));
			break;
		case 'c':
			printf("%c", va_arg(ap, char));
			break;
		default:
			printf("%c", *format);
			break;
		}
	}
	va_end(ap);
}

int max_int(int num, ... )
{
	va_list ap;
	int i;
	int cur;
	int max;

	va_start(ap, num);
	max = va_arg(ap, int);
	for(i = 1; i < num; ++i)
	{
		cur = va_arg(ap, int);
		if (max < cur)
		{
			max = cur;
		}
	}
	va_end(ap);

	return max;
}

/****************************************************************
 * 主函数
 ****************************************************************/
void stdarg_main(void)
{
	int i = 789;
	double d = 123.456;
	char *s = "this is a string";
	char c = 'c';

	printf("=================================================\n");
	printf("                  stdarg.h\n");
	printf("=================================================\n");

	print_arg("int: %i, double: %d, string: %s, char: %c",
			i, d, s, c);
	printf("\n");
	printf("max_int(5, 7, 9, -6, 10, 2): %d\n", 
			max_int(5, 7, 9, -6, 10, 2));

	printf("\n\n");
}

/**
 * @file    stddef_note.c
 * @brief   stddef.h笔记
 * @author	hatlonely
 * @e-mail	hatlonely@foxmail.com
 * @date    2013-01-15
 */

/****************************************************************
 * <stddef.h>定义了一些类型
 ****************************************************************/

#include <stdio.h>
#include <stddef.h>

/****************************************************************
 * 一般定义
 *
 * ptrdiff_t	两个指针相减的结果，有符号整型
 * size_t		sizeof操作符的结果，无符号整型
 * wchar_t		整型，它范围内的值可以表示最大扩展字符集中所有成员
 *				的不同编码值，而该字符集是由支持它的区域设置指定的
 * NULL			空指针常量
 * offsetof		展开为一个size_t类型的整值常量表达式，它的值是从结
 *				构体的起始位置开始（type）到结构体成员（member）的
 *				偏移量，以字节为单位
 *				offsetof(type, member)
 ****************************************************************/


/* 自定义结构体，在示例程序中使用 */
struct def_st
{
	char c;
	int i;
	double d;
};
/****************************************************************
 * 主函数
 ****************************************************************/
void stddef_main(void)
{
	printf("=================================================\n");
	printf("                  stddef.h\n");
	printf("=================================================\n");

	printf("sizeof(char): %d\n", sizeof(char));
	printf("sizeof(short int): %d\n", sizeof(short int));
	printf("sizeof(int): %d\n", sizeof(int));
	printf("sizeof(long int): %d\n", sizeof(long int));
	printf("sizeof(float): %d\n", sizeof(float));
	printf("sizeof(double): %d\n", sizeof(double));
	printf("sizeof(long double): %d\n", sizeof(long double));
	printf("\n");

	printf("offsetof(ds, c): %d\n", offsetof(struct def_st, c));
	printf("offsetof(ds, i): %d\n", offsetof(struct def_st, i));
	printf("offsetof(ds, d): %d\n", offsetof(struct def_st, d));
	printf("\n");
}

/**
 * @file    setjmp_note.c
 * @brief   setjmp.h笔记
 * @author	hatlonely
 * @e-mail	hatlonely@foxmail.com
 * @date    2013-01-15
 */

/****************************************************************
 * <setjmp.h>非本地跳转
 * goto语句只能跳到所在函数内部标号，而不能将控制权转移到任意地点
 * setjmp和longjmp分别承担非局部标号和goto作用
 * 这些函数对处理程序中的低级函数中遇到的异常情况很有用
 ****************************************************************/

#include <stdio.h>
#include <setjmp.h>

/****************************************************************
 * 类型
 *
 * jmp_buf		数组类型，适合存储恢复一个调用环境所需的信息
 *				程序存放位置，栈和框架指针，重要寄存器和内部数据
 ****************************************************************/
/****************************************************************
 * 保存和恢复环境
 *
 * setjmp		将它的调用环境存在它的jmp_buf参数中
 *				以供后面的longjmp函数使用
 *				如果setjmp来自一个直接调用返回0，来自函数longjmp的
 *				调用，setjmp返回一个非0值
 * longjmp		使用相应的jmp_buf恢复程序的调用环境
 *				val不为0时，函数返回val，否则返回1
 ****************************************************************/
/* 宏int setjmp(jmp_buf env); */
/* extern void longjmp(jmp_buf env, int val); */


/****************************************************************
 * 主函数
 ****************************************************************/
void setjmp_main(void)
{
	jmp_buf jmpbuf;

	printf("=================================================\n");
	printf("                  setjmp.h\n");
	printf("=================================================\n");

	switch(setjmp(jmpbuf))
	{
	case 0:
		printf("in case 0\n");
		longjmp(jmpbuf, 0);			/* 这里返回1 */
		break;
	case 1:
		printf("in case 1\n");
		longjmp(jmpbuf, 2);			/* 这里返回2 */
		break;
	case 2:
		printf("in case 2\n");
		longjmp(jmpbuf, 3);			/* 这里返回3 */
		break;
	default:
		break;
	}

	printf("\n");
}

/**
 * @file    locale_note.c
 * @brief   locale.h笔记
 * @author	hatlonely
 * @e-mail	hatlonely@foxmail.com
 * @date    2013-01-15
 */

/****************************************************************
 * <locale.h>区域设置
 * 这些区域设置影响标准库的输入输出函数
 ****************************************************************/

#include <stdio.h>
#include <locale.h>

/****************************************************************
 * 类型和宏
 *
 * struct lconv	它包含的成员和数字值的格式有关
 * NULL			空指针
 * LC_ALL		setlocale函数的第一个参数，对整个区域进行设置
 * LC_COLLATE	影响<string.h>中strcoll和strxfrm的比较方式
 * LC_CTYPE		影响<ctype.h>中的函数、<stdio.h>中打印和扫描函数
 *				和<stdlib.h>中多字节函数
 * LC_MONETARY	影响<locale.h>中localeconv的返回值
 * LC_NUMERIC	影响<stdio.h>中打印和扫描函数、<stdlib.h>中atof和
 *				strtod函数对十进制小数点字符的使用方式，也会影响
 *				<locale.h>中localeconv的返回值
 * LC_TIME		影响<time.h>中的时间转换函数
 ****************************************************************/

/****************************************************************
 * 区域设置与查询
 *
 * setlocale	区域设置函数，参数category为要设置的类别，locale为
 *				要设置的值，locale的值"C"为编译器指定最小的环境值
 *				local的值""指定实现定义的本地环境
 * localeconv	获得当前的区域设置
 ****************************************************************/
/* extern char *setlocale(int category, const char *locale); */
/* extern struct lconv *localeconv(void); */


/****************************************************************
 * 主函数
 ****************************************************************/
void locale_main(void)
{
	struct lconv *lc;

	printf("=================================================\n");
	printf("                  locale.h\n");
	printf("=================================================\n");
	
	/* setlocale(LC_ALL, ""); */
	/* setlocale(LC_ALL, "C"); */
	setlocale(LC_ALL, "Chinese");
	/* setlocale(LC_ALL, "English"); */
	lc = localeconv();
	printf("int_curr_symbol: \"%s\"\n", lc->int_curr_symbol);
	printf("currency_symbol: \"%s\"\n", lc->currency_symbol);
	printf("mon_decimal_point: \"%s\"\n", lc->mon_decimal_point);
	printf("mon_thousands_sep: \"%s\"\n", lc->mon_thousands_sep);
	printf("mon_grouping: \"%s\"\n", lc->mon_grouping);
	printf("positive_sign: \"%s\"\n", lc->positive_sign);
	printf("negative_sign: \"%s\"\n", lc->negative_sign);
	printf("int_frac_digits: %d\n", lc->int_frac_digits);
	printf("frac_digits: %d\n", lc->frac_digits);
	printf("n_sep_by_space: %d\n", lc->n_sep_by_space);
	printf("p_sep_by_space: %d\n", lc->p_sep_by_space);
	printf("n_cs_precedes: %d\n", lc->n_cs_precedes);
	printf("p_cs_precedes: %d\n", lc->p_cs_precedes);
	printf("n_sign_posn: %d\n", lc->n_sign_posn);
	printf("p_sign_posn: %d\n", lc->p_sign_posn);
}

/**
 * @file    main.c
 * @brief   主函数
 * @author	hatlonely
 * @e-mail	hatlonely@foxmail.com
 * @date    2013-01-07
 */

extern void math_main(void);
extern void ctype_main(void);
extern void time_main(void);
extern void string_main(void);
extern void stdlib_main(void);
extern void stdio_main(void);
extern void signal_main(void);
extern void limits_main(void);
extern void float_main(void);
extern void assert_main(void);
extern void errno_main(void);
extern void setjmp_main(void);
extern void stdarg_main(void);
extern void stddef_main(void);
extern void locale_main(void);


int main()
{
	math_main();
	ctype_main();
	time_main();
	string_main();
	stdlib_main();
	stdio_main();
	limits_main();
	float_main();
	assert_main();
	errno_main();
	setjmp_main();
	stdarg_main();
	stddef_main();
	locale_main();
	signal_main();

	return 0;
}

objects= main.o \
		math_note.o \
		ctype_note.o \
		time_note.o \
		string_note.o \
		stdlib_note.o \
		stdio_note.o \
		signal_note.o \
		limits_note.o \
		float_note.o \
		assert_note.o \
		errno_note.o \
		setjmp_note.o \
		stdarg_note.o \
		stddef_note.o \
		locale_note.o

CSTDL: $(objects)
	gcc -o CSTDL $(objects) -lm

%.o: %.c
	gcc -c $< -o $@

clean:
	rm *.o CSTDL

run:
	./CSTDL