今天阅读的第三本书（有0.25本忽略不计了）。

大概一个小时就读完了，因为非常简单、易懂，写得也很生动，而且，不少内容以前是明白的，有这个基础，再逐字逐句地读是没必要的。右侧的图也是一扫而过，所以事实上，202页书，是当100页读的。

但这验证了一个道理：读书越多，越快。因为读的书越多，越会明白，相当部分内容是重复的，当你明白了论点，而且看到论据有的是重复的，就没必要一定要认真地看完，而是略过即可，眼睛一扫，明白大意，足矣。

我之前曾经看过作者的另一本书，《每天懂一点色彩心理学》，同系列的，写的类似的好玩，一本好书，应是让人读起来轻松，又能够学到东西，这两本书都符合这个要求。

我同时也注意到延伸阅读里有推荐作者的《每天懂一点创意心理学》，对这本书很感兴趣，可惜图书馆现在不提供预借，所以先Mark了。

心理学是必须要懂的学科之一，因为人是群体动物，在与人相处的时候，懂点心理学非常有益，即使不为与人相处，人也需要与自己相处，那么，懂得 自己的心理，也是非常必要的。现代人由于压力太大，常有精神疾患，如果能够学会做自己的医生，对自己来说是桩功德，若能兼济他人，则更是功德无量。

文章来源：逍遥游

1、过程中注意记录。最好随身带笔和纸，因为数码工具好是好，但比较慢，比如笔记本要启动，需要一点时间，而纸是随时可以拿出来的，当然笔要准备好，不出墨就惨了，这次在日本丰田，因为天冷，结果笔出水不太顺畅，影响了记录，只好把笔芯取出来放在手里暖，才好一些;

2、记录不用太详细。只要线索就够了;要多拍照，拍照不是只拍风景，照片也可以当线索记;照片最好是用手机、touch等，如果能够上网、定位最佳，因为可以按地点进行区分，这也是记录的一种方式;

3、要及时总结。不要拖得太久，太久以后记忆不是那么鲜明，需要花很多时间来回忆。最好是尽快完成。

4、写之前的准备。最好是先看照片或者带回的相关资料，在脑子里勾勒出记录的大纲，要么按顺序，要么按地点，在写之前，通过看照片等引发记忆，然后一气呵成。

5、全部写完文字后再加照片。如果边写边加照片，就会比较慢，我一般是先写文字，因为事先看过了照片，所以知道在哪些地方应该加照片，文字和照片呼应，等到全部写完，把照片一次性加进去。

6、游记每篇不要写得太长。分散开主题，短篇、多篇，这样比较不会造成读者的负担，一定要图文并茂。不要只有文字没有图，或者反之。

7、制作合集。在全部写完以后，一定要做一个合集，一方面是为了自己归整资料的方便，另一方面也方便读者阅读。

原文标题:February Twilight

　　#include<iostream>

　　#include <windows.h>

　　using namespace std;

　　int *p=NULL;

　　void fun()

　　{

　　int i=10;

　　p=&i;

　　}

　　void main()

　　{

　　fun();

　　cout<<"*p= "<<*p<<endl;

　　Sleep(1000);

　　cout<<“一秒钟后，fun()中的i变量的存储空间被释放,p所指对象的值为:"<<endl<<"*p= "<<*p<<endl;

　　}

　　输出为：

　　*p= 10

　　一秒钟后，fun()中的i变量的存储空间被释放,p所指对象的值为:

　　*p= 1245056

　　Press any key to continue

　　可见，fun()运行完一秒钟后，p成为悬垂指针。

　　则其实并不是C标准里面的内容，它是从C标准的声明规定中归纳出来的方法。C标准的声明规则，是用来解决如何创建声明的，而右左法则是用

　　来解决如何辩识一个声明的，两者可以说是相反的。右左法则的英文原文是这样说的：

　　The right－left rule: Start reading the declaration from the innermost parentheses, go right, and then go left. When you

　　encounter parentheses, the direction should be reversed. Once everything in the parentheses has been

　　parsed, jump out of it. Continue till the whole declaration has been parsed.

　　这段英文的翻译如下：

　　右左法则：首先从最里面的圆括号看起，然后往右看，再往左看。每当遇到圆括号时，就应该掉转阅读方向。一旦解析完圆括号里面所有的东西，就跳出圆括号。重复这个过程直到整个声明解析完毕。

　　笔者要对这个法则进行一个小小的修正，应该是从未定义的标识符开始阅读，而不是从括号读起，之所以是未定义的标识符，是因为一个声明里面可能有多个标识符，但未定义的标识符只会有一个。

　　现在通过一些例子来讨论右左法则的应用，先从最简单的开始，逐步加深：

　　int (*func)(int *p);

　　首先找到那个未定义的标识符，就是func，它的外面有一对圆括号，而且左边是一个*号，这说明func是一个指针，然后跳出这个圆括号，先看

　　右边，也是一个圆括号，这说明(*func)是一个函数，而func是一个指向这类函数的指针，就是一个函数指针，这类函数具有int*类型的形参，返回值类型是 int。

　　int (*func)(int *p, int (*f)(int*));

　　func被一对括号包含，且左边有一个*号，说明func是一个指针，跳出括号，右边也有个括号，那么func是一个指向函数的指针，这类函数具有int *和int (*)(int*)这样的形参，返回值为int类型。再来看一看func的形参int (*f)(int*)，类似前面的解释，f也是一个函数指针，指向的函数具有int*类型的形参，返回值为int。

　　int (*func[5])(int *p);

　　func右边是一个[]运算符，说明func是一个具有5个元素的数组，func的左边有一个*，说明func的元素是指针，要注意这里的*不是修饰 func的，而是修饰func[5]的，原因是[]运算符优先级比*高，func先跟[]结合，因此*修饰的是func[5]。跳出这个括号，看右边，也是一对圆括号，说明func数组的元素是函数类型的指针，它所指向的函数具有int*类型的形参，返回值类型为int。

　　int (*(*func)[5])(int *p);

　　func被一个圆括号包含，左边又有一个*，那么func是一个指针，跳出括号，右边是一个[]运算符号，说明func是一个指向数组的指针，现在往左看，左边有一个*号，说明这个数组的元素是指针，再跳出括号，右边又有一个括号，说明这个数组的元素是指向函数的指针。总结一下，就是：func是一个指向数组的指针，这个数组的元素是函数指针，这些指针指向具有int*形参，返回值为int类型的函数。

　　int (*(*func)(int *p))[5];

　　func是一个函数指针，这类函数具有int*类型的形参，返回值是指向数组的指针，所指向的数组的元素是具有5个int元素的数组。

　　要注意有些复杂指针声明是非法的，例如：

　　int func(void) [5];

　　func是一个返回值为具有5个int元素的数组的函数。但C语言的函数返回值不能为数组，这是因为如果允许函数返回值为数组，那么接收这个数组的内容的东西，也必须是一个数组，但C语言的数组名是一个右值，它不能作为左值来接收另一个数组，因此函数返回值不能为数组。

　　int func[5](void);

　　func是一个具有5个元素的数组，这个数组的元素都是函数。这也是非法的，因为数组的元素除了类型必须一样外，每个元素所占用的内存空间也必须相同，显然函数是无法达到这个要求的，即使函数的类型一样，但函数所占用的空间通常是不相同的。

　　作为练习，下面列几个复杂指针声明给读者自己来解析。

　　int (*(*func)[5][6])[7][8];

　　int (*(*(*func)(int *))[5])(int *);

　　int (*(*func[7][8][9])(int*))[5];

　　实际当中，需要声明一个复杂指针时，如果把整个声明写成上面所示的形式，对程序可读性是一大损害。应该用typedef来对声明逐层

　　分解，增强可读性，例如对于声明：

　　int (*(*func)(int *p))[5];

　　可以这样分解：

　　typedef  int (*PARA)[5];

　　typedef PARA (*func)(int *);

　　这样就容易看得多了。

　　答案，同时给出用typedef的分解方法：

　　int (*(*func)[5][6])[7][8];

　　func是一个指向数组的指针，这类数组的元素是一个具有5X6个int元素的二维数组，而这个二维数组的元素又是一个二维数组。

　　typedef int (*PARA)[7][8];

　　typedef PARA (*func)[5][6];

　　int (*(*(*func)(int *))[5])(int *);

　　func是一个函数指针，这类函数的返回值是一个指向数组的指针，所指向数组的元素也是函数指针，指向的函数具有int*形参，返回值为int。

　　typedef int (*PARA1)(int*);

　　typedef PARA1 (*PARA2)[5];

　　typedef PARA2 (*func)(int*);

　　int (*(*func[7][8][9])(int*))[5];

　　func是一个数组，这个数组的元素是函数指针，这类函数具有int*的形参，返回值是指向数组的指针，所指向的数组的元素是具有5个int元素

　　的数组。

　　typedef int (*PARA1)[5];

　　typedef PARA1 (*PARA2)(int*);

　　typedef PARA2 func[7][8][9];

　　范例
　　#include<stdio.h>
　　main()
　　{
　　FILE * fp =fdopen(0,”w+”);
　　fprintf(fp,”%s ”,”hello!”);
　　fclose(fp);
　　}
　　执行 hello!
　　feof（检查文件流是否读到了文件尾）
　　相关函数 fopen，fgetc，fgets，fread
　　表头文件 #include<stdio.h>
　　定义函数 int feof(FILE * stream);
　　函数说明 feof()用来侦测是否读取到了文件尾，尾数stream为fopen（）所返回之文件指针。如果已到文件尾则返回非零值，其他情况返回0。
　　返回值 返回非零值代表已到达文件尾。
　　fflush（更新缓冲区）
　　相关函数 write，fopen，fclose，setbuf
　　表头文件 #include<stdio.h>
　　定义函数 int fflush(FILE* stream);
　　函数说明 fflush()会强迫将缓冲区内的数据写回参数stream指定的文件中。如果参数stream为NULL，fflush()会将所有打开的文件数据更新。
　　返回值 成功返回0，失败返回EOF，错误代码存于errno中。
　　错误代码 EBADF 参数stream 指定的文件未被打开，或打开状态为只读。其它错误代码参考write（）。
　　fgetc（由文件中读取一个字符）
　　相关函数 open，fread，fscanf，getc
　　表头文件 include<stdio.h>
　　定义函数 nt fgetc(FILE * stream);
　　函数说明 fgetc()从参数stream所指的文件中读取一个字符。若读到文件尾而无数据时便返回EOF。
　　返回值 getc()会返回读取到的字符，若返回EOF则表示到了文件尾。

　　范例
　　#include<stdio.h>
　　main()
　　{
　　FILE *fp;
　　int c;
　　fp=fopen(“exist”,”r”);
　　while((c=fgetc(fp))!=EOF)
　　printf(“%c”,c);
　　fclose(fp);
　　}
　　fgets（由文件中读取一字符串）
　　相关函数 open，fread，fscanf，getc
　　表头文件 include<stdio.h>
　　定义函数 har * fgets(char * s,int size,FILE * stream);
　　函数说明 fgets()用来从参数stream所指的文件内读入字符并存到参数s所指的内存空间，直到出现换行字符、读到文件尾或是已读了size-1个字符为止，最后会加上NULL作为字符串结束。
　　返回值 gets()若成功则返回s指针，返回NULL则表示有错误发生。
　　范例
　　#include<stdio.h>
　　main()
　　{
　　char s[80];
　　fputs(fgets(s,80,stdin),stdout);
　　}
　　执行 this is a test /*输入*/
　　this is a test /*输出*/
　　fileno（返回文件流所使用的文件描述词）
　　相关函数 open，fopen
　　表头文件 #include<stdio.h>
　　定义函数 int fileno(FILE * stream);
　　函数说明 fileno()用来取得参数stream指定的文件流所使用的文件描述词。
　　返回值 返回文件描述词。

　　范例
　　#include<stdio.h>
　　main()
　　{
　　FILE * fp;
　　int fd;
　　fp=fopen(“/etc/passwd”,”r”);
　　fd=fileno(fp);
　　printf(“fd=%d ”,fd);
　　fclose(fp);
　　}
　　执行 fd=3
　　fopen（打开文件）
　　相关函数 open，fclose
　　表头文件 #include<stdio.h>
　　定义函数 FILE * fopen(const char * path,const char * mode);
　　函数说明 参数path字符串包含欲打开的文件路径及文件名，参数mode字符串则代表着流形态。
　　mode有下列几种形态字符串:
　　r 打开只读文件，该文件必须存在。
　　r+ 打开可读写的文件，该文件必须存在。
　　w 打开只写文件，若文件存在则文件长度清为0，即该文件内容会消失。若文件不存在则建立该文件。
　　w+ 打开可读写文件，若文件存在则文件长度清为零，即该文件内容会消失。若文件不存在则建立该文件。
　　a 以附加的方式打开只写文件。若文件不存在，则会建立该文件，如果文件存在，写入的数据会被加到文件尾，即文件原先的内容会被保留。
　　a+ 以附加方式打开可读写的文件。若文件不存在，则会建立该文件，如果文件存在，写入的数据会被加到文件尾后，即文件原先的内容会被保留。
　　上述的形态字符串都可以再加一个b字符，如rb、w+b或ab＋等组合，加入b 字符用来告诉函数库打开的文件为二进制文件，而非纯文字文件。不过在POSIX系统，包含Linux都会忽略该字符。由fopen()所建立的新文件会具有S_IRUSR|S_IWUSR|S_IRGRP|S_IWGRP|S_IROTH|S_IWOTH(0666)权限，此文件权限也会参考umask值。
　　返回值 文件顺利打开后，指向该流的文件指针就会被返回。若果文件打开失败则返回NULL，并把错误代码存在errno 中。
　　附加说明 一般而言，开文件后会作一些文件读取或写入的动作，若开文件失败，接下来的读写动作也无法顺利进行，所以在fopen()后请作错误判断及处理。

　　范例
　　#include<stdio.h>
　　main()
　　{
　　FILE * fp;
　　fp=fopen(“noexist”,”a+”);
　　if(fp= =NULL) return;
　　fclose(fp);
　　}
　　fputc（将一指定字符写入文件流中）
　　相关函数 fopen，fwrite，fscanf，putc
　　表头文件 #include<stdio.h>
　　定义函数 int fputc(int c,FILE * stream);
　　函数说明 fputc 会将参数c 转为unsigned char 后写入参数stream 指定的文件中。
　　返回值 fputc()会返回写入成功的字符，即参数c。若返回EOF则代表写入失败。
　　范例
　　#include<stdio.h>
　　main()
　　{
　　FILE * fp;
　　char a[26]=”abcdefghijklmnopqrstuvwxyz”;
　　int i;
　　fp= fopen(“noexist”,”w”);
　　for(i=0;i<26;i++)
　　fputc(a,fp);
　　fclose(fp);
　　}
　　fputs（将一指定的字符串写入文件内）
　　相关函数 fopen，fwrite，fscanf，fputc，putc
　　表头文件 #include<stdio.h>
　　定义函数 int fputs(const char * s,FILE * stream);
　　函数说明 fputs()用来将参数s所指的字符串写入到参数stream所指的文件内。
　　返回值 若成功则返回写出的字符个数，返回EOF则表示有错误发生。
　　范例 请参考fgets（）。
　　fread（从文件流读取数据）
　　相关函数 fopen，fwrite，fseek，fscanf
　　表头文件 #include<stdio.h>
　　定义函数 size_t fread(void * ptr,size_t size,size_t nmemb,FILE * stream);
　　函数说明 fread()用来从文件流中读取数据。参数stream为已打开的文件指针，参数ptr 指向欲存放读取进来的数据空间，读取的字符数以参数size*nmemb来决定。Fread()会返回实际读取到的nmemb数目，如果此值比参数nmemb 来得小，则代表可能读到了文件尾或有错误发生，这时必须用feof()或ferror()来决定发生什么情况。
　　返回值 返回实际读取到的nmemb数目。

　　附加说明
　　范例
　　#include<stdio.h>
　　#define nmemb 3
　　struct test
　　{
　　char name[20];
　　int size;
　　}s[nmemb];
　　int main(){
　　FILE * stream;
　　int i;
　　stream = fopen(“/tmp/fwrite”,”r”);
　　fread(s,sizeof(struct test),nmemb,stream);
　　fclose(stream);
　　for(i=0;i<nmemb;i++)
　　printf(“name[%d]=%-20s:size[%d]=%d ”,i,s.name,i,s.size);
　　}
　　执行
　　name[0]=Linux! size[0]=6
　　name[1]=FreeBSD! size[1]=8
　　name[2]=Windows2000 size[2]=11
　　freopen（打开文件）
　　相关函数 fopen，fclose
　　表头文件 #include<stdio.h>
　　定义函数 FILE * freopen(const char * pathconst char * mode,FILE * stream);
　　函数说明 参数path字符串包含欲打开的文件路径及文件名，参数mode请参考fopen()说明。参数stream为已打开的文件指针。Freopen()会将原stream所打开的文件流关闭，然后打开参数path的文件。
　　返回值 文件顺利打开后，指向该流的文件指针就会被返回。如果文件打开失败则返回NULL，并把错误代码存在errno 中。

　　范例
　　#include<stdio.h>
　　main()
　　{
　　FILE * fp;
　　fp=fopen(“/etc/passwd”,”r”);
　　fp=freopen(“/etc/group”,”r”,fp);
　　fclose(fp);
　　}
　　fseek（移动文件流的读写位置）
　　相关函数 rewind，ftell，fgetpos，fsetpos，lseek
　　表头文件 #include<stdio.h>
　　定义函数 int fseek(FILE * stream,long offset,int whence);
　　函数说明 fseek()用来移动文件流的读写位置。参数stream为已打开的文件指针，参数offset为根据参数whence来移动读写位置的位移数。
　　参数 whence为下列其中一种:
　　SEEK_SET从距文件开头offset位移量为新的读写位置。SEEK_CUR 以目前的读写位置往后增加offset个位移量。
　　SEEK_END将读写位置指向文件尾后再增加offset个位移量。
　　当whence值为SEEK_CUR 或SEEK_END时，参数offset允许负值的出现。
　　下列是较特别的使用方式:
　　1) 欲将读写位置移动到文件开头时:fseek(FILE *stream,0,SEEK_SET);
　　2) 欲将读写位置移动到文件尾时:fseek(FILE *stream,0,0SEEK_END);
　　返回值 当调用成功时则返回0，若有错误则返回-1，errno会存放错误代码。
　　附加说明 fseek()不像lseek()会返回读写位置，因此必须使用ftell()来取得目前读写的位置。

　　范例
　　#include<stdio.h>
　　main()
　　{
　　FILE * stream;
　　long offset;
　　fpos_t pos;
　　stream=fopen(“/etc/passwd”,”r”);
　　fseek(stream,5,SEEK_SET);
　　printf(“offset=%d ”,ftell(stream));
　　rewind(stream);
　　fgetpos(stream,&pos);
　　printf(“offset=%d ”,pos);
　　pos=10;
　　fsetpos(stream,&pos);
　　printf(“offset = %d ”,ftell(stream));
　　fclose(stream);
　　}
　　执行 offset = 5
　　offset =0
　　offset=10
　　ftell（取得文件流的读取位置）
　　相关函数 fseek，rewind，fgetpos，fsetpos
　　表头文件 #include<stdio.h>
　　定义函数 long ftell(FILE * stream);
　　函数说明 ftell()用来取得文件流目前的读写位置。参数stream为已打开的文件指针。
　　返回值 当调用成功时则返回目前的读写位置，若有错误则返回-1，errno会存放错误代码。
　　错误代码 EBADF 参数stream无效或可移动读写位置的文件流。
　　范例 参考fseek()。
　　fwrite（将数据写至文件流）
　　相关函数 fopen，fread，fseek，fscanf
　　表头文件 #include<stdio.h>
　　定义函数 size_t fwrite(const void * ptr,size_t size,size_t nmemb,FILE * stream);
　　函数说明 fwrite()用来将数据写入文件流中。参数stream为已打开的文件指针，参数ptr 指向欲写入的数据地址，总共写入的字符数以参数size*nmemb来决定。Fwrite()会返回实际写入的nmemb数目。
　　返回值 返回实际写入的nmemb数目。

　　范例
　　#include<stdio.h>
　　#define set_s (x,y) {strcoy(s[x].name,y);s[x].size=strlen(y);}
　　#define nmemb 3
　　struct test
　　{
　　char name[20];
　　int size;
　　}s[nmemb];
　　main()
　　{
　　FILE * stream;
　　set_s(0,”Linux!”);
　　set_s(1,”FreeBSD!”);
　　set_s(2,”Windows2000.”);
　　stream=fopen(“/tmp/fwrite”,”w”);
　　fwrite(s,sizeof(struct test),nmemb,stream);
　　fclose(stream);
　　}
　　执行 参考fread（）。
　　getc（由文件中读取一个字符）
　　相关函数 read，fopen，fread，fgetc
　　表头文件 #include<stdio.h>
　　定义函数 int getc(FILE * stream);
　　函数说明 getc()用来从参数stream所指的文件中读取一个字符。若读到文件尾而无数据时便返回EOF。虽然getc()与fgetc()作用相同，但getc()为宏定义，非真正的函数调用。
　　返回值 getc()会返回读取到的字符，若返回EOF则表示到了文件尾。
　　范例 参考fgetc()。
　　getchar（由标准输入设备内读进一字符）
　　相关函数 fopen，fread，fscanf，getc
　　表头文件 #include<stdio.h>
　　定义函数 int getchar(void);
　　函数说明 getchar()用来从标准输入设备中读取一个字符。然后将该字符从unsigned char转换成int后返回。
　　返回值 getchar()会返回读取到的字符，若返回EOF则表示有错误发生。
　　附加说明 getchar()非真正函数，而是getc(stdin)宏定义。
　　范例
　　#include<stdio.h>
　　main()
　　{
　　FILE * fp;
　　int c,i;
　　for(i=0li<5;i++)
　　{
　　c=getchar();
　　putchar(c);
　　}
　　}
　　执行 1234 /*输入*/
　　1234 /*输出*/
　　gets（由标准输入设备内读进一字符串）
　　相关函数 fopen，fread，fscanf，fgets
　　表头文件 #include<stdio.h>
　　定义函数 char * gets(char *s);
　　函数说明 gets()用来从标准设备读入字符并存到参数s所指的内存空间，直到出现换行字符或读到文件尾为止，最后加上NULL作为字符串结束。
　　返回值 gets()若成功则返回s指针，返回NULL则表示有错误发生。
　　附加说明 由于gets()无法知道字符串s的大小，必须遇到换行字符或文件尾才会结束输入，因此容易造成缓冲溢出的安全性问题。建议使用fgets()取代。

　　范例 参考fgets()
　　mktemp（产生唯一的临时文件名）
　　相关函数 tmpfile
　　表头文件 #include<stdlib.h>
　　定义函数 char * mktemp(char * template);
　　函数说明 mktemp()用来产生唯一的临时文件名。参数template所指的文件名称字符串中最后六个字符必须是XXXXXX。产生后的文件名会借字符串指针返回。
　　返回值 文件顺利打开后，指向该流的文件指针就会被返回。如果文件打开失败则返回NULL，并把错误代码存在errno中。
　　附加说明 参数template所指的文件名称字符串必须声明为数组，如:
　　char template[ ]=”template-XXXXXX”；
　　不可用char * template=”template-XXXXXX”；
　　范例
　　#include<stdlib.h>
　　main()
　　{
　　char template[ ]=”template-XXXXXX”;
　　mktemp(template);
　　printf(“template=%s ”,template);
　　}
　　putc（将一指定字符写入文件中）
　　相关函数 fopen，fwrite，fscanf，fputc
　　表头文件 #include<stdio.h>
　　定义函数 int putc(int c,FILE * stream);
　　函数说明 putc()会将参数c转为unsigned char后写入参数stream指定的文件中。虽然putc()与fputc()作用相同，但putc()为宏定义，非真正的函数调用。
　　返回值 putc()会返回写入成功的字符，即参数c。若返回EOF则代表写入失败。　　范例 参考fputc（）。
　　putchar（将指定的字符写到标准输出设备）
　　相关函数 fopen，fwrite，fscanf，fputc
　　表头文件 #include<stdio.h>
　　定义函数 int putchar (int c);
　　函数说明 putchar()用来将参数c字符写到标准输出设备。
　　返回值 putchar()会返回输出成功的字符，即参数c。若返回EOF则代表输出失败。
　　附加说明 putchar()非真正函数，而是putc(c，stdout)宏定义。
　　范例 参考getchar()。
　　rewind（重设文件流的读写位置为文件开头）
　　相关函数 fseek，ftell，fgetpos，fsetpos
　　表头文件 #include<stdio.h>
　　定义函数 void rewind(FILE * stream);
　　函数说明 rewind()用来把文件流的读写位置移至文件开头。参数stream为已打开的文件指针。此函数相当于调用fseek(stream,0,SEEK_SET)。
　　返回值

　　范例 参考fseek()
　　setbuf（设置文件流的缓冲区）
　　相关函数 setbuffer，setlinebuf，setvbuf
　　表头文件 #include<stdio.h>
　　定义函数 void setbuf(FILE * stream,char * buf);
　　函数说明 在打开文件流后，读取内容之前，调用setbuf()可以用来设置文件流的缓冲区。参数stream为指定的文件流，参数buf指向自定的缓冲区起始地址。如果参数buf为NULL指针，则为无缓冲IO。Setbuf()相当于调用:setvbuf(stream,buf,buf?_IOFBF:_IONBF,BUFSIZ)
　　返回值
　　setbuffer（设置文件流的缓冲区）
　　相关函数 setlinebuf，setbuf，setvbuf
　　表头文件 #include<stdio.h>
　　定义函数 void setbuffer(FILE * stream,char * buf,size_t size);
　　函数说明 在打开文件流后，读取内容之前，调用setbuffer()可用来设置文件流的缓冲区。
　　参数stream为指定的文件流，参数buf指向自定的缓冲区起始地址，参数size为缓冲区大小。
　　返回值
　　setlinebuf（设置文件流为线性缓冲区）
　　相关函数 setbuffer，setbuf，setvbuf
　　表头文件 #include<stdio.h>
　　定义函数 void setlinebuf(FILE * stream);
　　函数说明 setlinebuf()用来设置文件流以换行为依据的无缓冲IO。相当于调用:setvbuf(stream,(char * )NULL,_IOLBF,0);请参考setvbuf()。
　　返回值
　　setvbuf（设置文件流的缓冲区）
　　相关函数 setbuffer，setlinebuf，setbuf
　　表头文件 #include<stdio.h>
　　定义函数 int setvbuf(FILE * stream,char * buf,int mode,size_t size);
　　函数说明 在打开文件流后，读取内容之前，调用setvbuf()可以用来设置文件流的缓冲区。参数stream为指定的文件流，参数buf指向自定的缓冲区起始地址，参数size为缓冲区大小，参数mode有下列几种
　　_IONBF 无缓冲IO
　　_IOLBF 以换行为依据的无缓冲IO
　　_IOFBF 完全无缓冲IO。如果参数buf为NULL指针，则为无缓冲IO。
　　返回值
　　ungetc（将指定字符写回文件流中）
　　相关函数 fputc，getchar，getc
　　表头文件 #include<stdio.h>
　　定义函数 int ungetc(int c,FILE * stream);
　　函数说明 ungetc()将参数c字符写回参数stream所指定的文件流。这个写回的字符会由下一个读取文件流的函数取得。
　　返回值 成功则返回c 字符，若有错误则返回EOF。

 
　　对于64位的浮点数，最高的1位是符号位S，接着的11位是指数E，剩下的52位为有效数字M。

　　5.
　　IEEE 754对有效数字M和指数E，还有一些特别规定。
　　前面说过，1≤M<2，也就是说，M可以写成1.xxxxxx的形式，其中xxxxxx表示小数部分。IEEE 754规定，在计算机内部保存M时，默认这个数的第一位总是1，因此可以被舍去，只保存后面的xxxxxx部分。比如保存1.01的时候，只保存01，等到读取的时候，再把第一位的1加上去。这样做的目的，是节省1位有效数字。以32位浮点数为例，留给M只有23位，将第一位的1舍去以后，等于可以保存24位有效数字。
　　至于指数E，情况就比较复杂。
　　首先，E为一个无符号整数（unsigned int）。这意味着，如果E为8位，它的取值范围为0~255；如果E为11位，它的取值范围为0~2047。但是，我们知道，科学计数法中的E是可以出现负数的，所以IEEE 754规定，E的真实值必须再减去一个中间数，对于8位的E，这个中间数是127；对于11位的E，这个中间数是1023。
　　比如，2^10的E是10，所以保存成32位浮点数时，必须保存成10+127=137，即10001001。
　　然后，指数E还可以再分成三种情况：
　　（1）E不全为0或不全为1。这时，浮点数就采用上面的规则表示，即指数E的计算值减去127（或1023），得到真实值，再将有效数字M前加上第一位的1。
　　（2）E全为0。这时，浮点数的指数E等于1-127（或者1-1023），有效数字M不再加上第一位的1，而是还原为0.xxxxxx的小数。这样做是为了表示±0，以及接近于0的很小的数字。
　　（3）E全为1。这时，如果有效数字M全为0，表示±无穷大（正负取决于符号位s）；如果有效数字M不全为0，表示这个数不是一个数（NaN）。
　　6.
　　好了，关于浮点数的表示规则，就说到这里。
　　下面，让我们回到一开始的问题：为什么0x00000009还原成浮点数，就成了0.000000？
　　首先，将0x00000009拆分，得到第一位符号位s=0，后面8位的指数E=00000000，最后23位的有效数字M=000 0000 0000 0000 0000 1001。
　　由于指数E全为0，所以符合上一节的第二种情况。因此，浮点数V就写成：
　　V=(-1)^0×0.00000000000000000001001×2^(-126)=1.001×2^(-146)
　　显然，V是一个很小的接近于0的正数，所以用十进制小数表示就是0.000000。
　　7.
　　再看例题的第二部分。
　　请问浮点数9.0，如何用二进制表示？还原成十进制又是多少？
　　首先，浮点数9.0等于二进制的1001.0，即1.001×2^3。
　　那么，第一位的符号位s=0，有效数字M等于001后面再加20个0，凑满23位，指数E等于3+127=130，即10000010。
　　所以，写成二进制形式，应该是s+E+M，即0 10000010 001 0000 0000 0000 0000 0000。这个32位的二进制数，还原成十进制，正是1091567616。

　　杨支柱主要讨论的是政治方面的论据来说明这个结论的，其实从经济上讲也是有一些根据的，在我大学的历史教材中称1912年之后的十年为中国民族工业的“黄金时代”，我当年第一次看到这个观点也非常惊讶，因为我在接触这本教材前，从中学和小学里根本就不知道这个时代的经济发展竟然会是这么惊人，说到的都是社会无比黑暗，农民的破产造成萧条等等。而大学的教材却将以前的教材里说的话都推翻了，这使得我明白了一个道理：如果说教科书可以骗人的话，大学教材中骗人最少，小学教材则最多。不过虽然大学骗人少，但骗人却最有欺骗性，小学教材的骗人却可以一眼就识破。

　　在这本《中国革命史教程》中的“中国资本主义经济的新发展和新文化运动的兴起”一节中，绘声绘色地描述了这段时间中国经济发展的惊人速度，这里我摘录一些数据：“据统计，1912年到1919年，建成厂矿470余个，加上原有企业的扩建，新增资本达1.3亿元以上，8年的增长额相当于以前的50年......1913年全国面粉53家，资本862万元，1919年增至123家，资本1500万元，1918年中国免费由入超变为出超...煤产量1913年为1337万吨，1919年则达到2005万吨，增长49%，钨矿的开采居世界第二。”

　　在这些描述中，我看到了一个怎样的中国啊，那时的中国的确很穷，但确是一个充满了希望和未来的新兴国家，一切都有可能，一切都是全新的。而当时的统治者北洋军阀，也许并不是以前媒体妖魔化的那样独裁和腐败，至少那时候个人居然可以创办和发行杂志甚至组建政党，工人可以罢工，学生可以游行，这些都是现代人做梦也做不到的事情，因此北洋军阀不应该算最坏的政府。

　　仔细想想，北洋军阀其实因为很多原因被迫不敢乱来，杨支柱分析的也有道理，一个小的政府，并且有很多外部竞争者，那么他想去变坏都不容易。

　　可惜，历史是个任人打扮的小姑娘。现在想了解真实的历史实在是太难了。

文章来源：月光博客