Module77:Yes,it is.

     好久没在这里写博客了，不知道为什么，也不知道在等待着什么。

     其间也想去别的地方写，但一直也没确定，博客本身写得质量就不高，换来换去更显得自己浮躁，而且这是我第二个博客（第一个是网易的），我怎么能轻易放弃。

     自己兴趣太广泛，总是有太多的事，想到就去做了，却都是浅尝辄止，没有深入研究。还有好多想做的事却没有去做，一直压在自己心里，一直拖着。是自己不敢去做，还是想把一件事做到更好，总之没有去做，或者还是没有做好。其实自己真的去做了，才发现自己做得并没有想像的糟糕。万事开关难，很多时候，我是缺少开始的勇气，只要开始了，就可以走下去。不管最初做得怎么样，事情总是可以改进的，而不是停留在脑子中设想。

     想想自己其实学了那么多东西，每学完一样，总是说要总结，但发现又有另一个好玩的东西可以学买，于是又以极高的热情去学那样东西，到头来，发现从来没有总结过，以前学的什么自己都不记得了。那些应该做，值得做的事，自己却总是拖着，有时候学东西简单，总结难，从某种意义上说，总结了才是学到了。心里还是不够踏实，太浮躁。
     总是说自己很忙，可是其实并没有那么忙。当小宝一次次跟我抱怨并带鄙夷地口气说“我其实根本就不忙”时，我心是虚的，因为很多时间都花在折腾+睡觉上，还有就是没目标地做这做那。。折腾了一天，还不如静静地散下步让我满足。

     拖沓绝对是个坏习惯。由于畏惧问题而拖沓更糟糕，尽快把一件搞定比花更多时间做得更好要划算得多，因为更多时间可能是无限的时间。折腾不可怕，瞎折腾就很可怕了，因为到头来，搞得头晕脑胀，自己都不知道干了什么。

     小宝总是抱怨我说：不要总是等我说过了，你再去做。说过了，是一种刺激，让你警觉，而再去做其实只是一个弥补，你怎么做都显得匆忙。其实我是可以早点去做的。想想大学的四年，有多少次临时抄别人的作业，哪次不是考试前看书，有时候为了不显得自己很慌，就干脆不做了，其实这样是欠了更多，迟早是要还的，那时更惨，可我还SB地觉得那样很NB。

     同学大多都毕业工作了，而我还在这苦逼地读研（读博更苦逼，还好我只读两年，我觉得很爽啦）。自己是想得到什么，还是在逃避？其实到目前为止，我都不知道自己的目标是什么，这也是我拖沓的原因吧！我现在挺自由，没有明确的任务，时间都自己安排，有时间我挺羡慕按部就班的生活，至少目标单一明确，容易执行。自己安排总是随意性太大，拖沓很难避免，很多时候无法执行。

    经过长时间地思想斗争，我做出了xx决定（我自己知道就行了吧）。

    未来，不用等我了。因为我也不知道你在哪，走哪算哪吧。

    睁开双眼，哪里都是未来。

typeof关键字是C语言中的一个新扩展。

typeof的参数可以是两种形式：表达式或类型。
下面是使用表达式的的例子：
    typeof(x[0](1)
这里假设x是一个函数指针数组，这样就可以得到这个函数返回值的类型了。
如果将typeof用于表达式，则该表达式不会执行。只会得到该表达式的类型。
以下示例声明了int类型的var变量，因为表达式foo()是int类型的。由于表达式不会被执行，所以不会调用foo函数。
   extern int foo();
   typeof(foo()) var;

下面是用类型作参数的例子：
   typeof(int *) a,b;
等价于：
   int *a,*b;

下面是两个等效声明，用于声明int类型的变量a。
   typeof(int) a; /*int类型*/
   typeof('b') a; /* GCC中这个表达式的类型是int(自动提升为int)，
                  注意typeof(char)和typeof('b')得到的不是一样的，这个用sizeof可以看出来*/

其实这里讲的不是用C语言来实现面向对象，只是用了一点点面向对象的思想，来进行分层的模块化设计与简单的封装。

这里把一个软件分成了三层，用户层，接口层与实现层。上面是我自己根据理解自己起的名字。

还可以进行一下类比，就是用户，品牌P collapsedC厂商和硬件生产商。下面详细讲解：

首先是用户层：

#include "stdio.h"
#include "stdlib.h"

int main(void)
{
    printf("system start...\n");
	if (mod_init("mod_finished")<0) {
		exit(0);
	}
	mod_operation_1(0,1,2);
	mod_operation_2(0,1,2);
	mod_operation_3(0,1,2);
    return 0;
} 

注：这个程序是在软件设计师教程上看到，并做了一点点修改得到。。

在一个简化的绘图程序中，支持点（point）和圆（circle）两种图形，在设计过程中采用面向对象思想，认为所有的点和圆都是一种图形（shape），

并定义类型shape_t、point_t、circle_t分别表示基本图形、点和圆，点和圆自然具有基本图形的所有特征。

下面是利用C语言，通过函数指针和可变参数机制实现上面的类层次关系：

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

// 程序中的两个图形：点和圆
typedef enum {point,circle}shape_type;
// 基本图形类型
typedef struct {
	shape_type type;
	void (*destroy)();
	void (*draw)();
}shape_t;
// 点类
typedef struct {
	shape_t common;
	int x,y;
}point_t;
// 圆类
typedef struct {
	shape_t common;
	point_t *center;
	int radius;
}circle_t;
/*

 // 一般使用方法
// #include <stdarg.h>
// void some_function(type1 var1,type2 last,...)
// {
//     va_list ap;
//     va_start(ap,last);
//     ...
//     typex var=va_arg(ap,typex);
//     ...
//     va_end;
//     return;
// }

// stdarg.h
// va_list 其实就是一个字节指针
typedef char *va_list;

// _va_size(type)总是4的倍数,因为系统在处理压栈的时候总是4字节对齐的。
#define	__va_size(type) \
	(((sizeof(type) + sizeof(long) - 1) / sizeof(long)) * sizeof(long))

// last是最后一个压栈的参数(也是第一个已知类型的参数),ap指向其后一个参数，即可变参数开始的地方。
#define	va_start(ap, last) \
	((ap) = (va_list)&(last) + __va_size(last))

// 得到类型为type的参数，并使ap指向下一个参数。
#define	va_arg(ap, type) \
	(*(type *)((ap) += __va_size(type), (ap) - __va_size(type)))

// 为了结构的完整性而定义。
#define	va_end(ap)	((void)0)

最近学习编译原理，正在学习文法，书上提到0型方法的描述能力相当于图灵机，
于是想验证一下，既然是相当于图灵机，那么应该可以仅通过方法规则来进行运算。。
我就来定义了一个二进制加法器：
P:
A->A0 | A1 | e
A+e->A
e+A->A
A0+A0->A+A0
A0+A1->A＋A1
A1+A0->A+A1
A1＋A1->A＋A＋10

如果我们要从111+11+1推导出1011
可以像这样: 111+11+1=>111+1+e+10
                                    =>111+1+10
                                    =>111+e+e+100
                                    =>111+e+100
                                    =>111+100
                                    =>11+101
                                    =>1+111
                                    =>e+e+1011
                                    =>e+1011
                                    =>1011
下面是我用python写的一个简单实现该转换的程序：