文中给出的是完整的,具体的,但又最基本最简单的实现,至于理论性的东西在网上很容易搜索的到.

一.通过处理被调用的C头文件

a.h:

#ifndef __A_H
#define __A_H

#ifdef __cplusplus
extern "C" {
#endif

int ThisIsTest(int a, int b);

#ifdef __cplusplus
}
#endif

#endif

a.c:

#include "a.h"

int ThisIsTest(int a, int b) {
  return (a + b);
}

aa.h:

class AA {
  public:
      int bar(int a, int b);
};

aa.cpp:

#include "a.h"
#include "aa.h"
#include "stdio.h"

int AA::bar(int a, int b){
    printf("result=%d\n", ThisIsTest(a, b));
    return 0;
}

main.cpp:

#include "aa.h"

int main(int argc, char **argv){
  int a = 1;
  int b = 2;
  AA* aa = new AA();
  aa->bar(a, b);
  delete(aa);
  return(0);
}

Makefile:

all:
        gcc -Wall -c a.c -o a.o
        gcc -Wall -c aa.cpp -o aa.o
        gcc -Wall -c main.cpp -o main.o
        g++ -o test *.o

二. 通过处理调用的C++文件

恢复a.h文件为一般性C头文件,在aa.cpp文件中extern包含a.h头文件或函数.

a.h:

#ifndef __A_H
#define __A_H
int ThisIsTest(int a, int b);
#endif

aa.cpp:

extern "C"
{
    #include "a.h"
}
#include "aa.h"
#include "stdio.h"

int AA::bar(int a, int b){
    printf("result=%d\n", ThisIsTest(a, b));
    return 0;
}

or

aa.cpp:

#include "aa.h"
#include "stdio.h"

extern "C"
{
    int ThisIsTest(int a, int b);
}

int AA::bar(int a, int b){
    printf("result=%d\n", ThisIsTest(a, b));
    return 0;
}

typedef const char* ShapeType;
typedef IShape* (*Creator)();


－－－－－－－－－－－－ShapeFactory.h－－－－－－－－－－－－－－－－－－－－

class ShapeFactory {
public:
    static ShapeFactory& Instance() {
        static ShapeFactory instance;
        return instance;
    }

    IShape* Create(ShapeType shapeType);
    bool RegisterShape(ShapeType shapeType, Creator creator);

private:
    ShapeFactory() {}
 std::map<ShapeType, Creator> shapeCreators;
};

－－－－－－－－－－－－ShapeFactory.cpp－－－－－－－－－－－－－－－－－－－－

#include "CFactory.h"

IShape* ShapeFactory::Create(ShapeType shapeType) {
      Creator creator = shapeCreators.find( shapeType )->second;
 
      if ( creator == NULL ) 
      { 
           return NULL; 
       }
       return creator();
}

bool ShapeFactory::RegisterShape( ShapeType shapeType, Creator creator ) {
       map<ShapeType, Creator>::iterator iter;
       iter = shapeCreators.find(shapeType);
       if(iter != shapeCreators.end())
       {
           return false;
       } else {
           shapeCreators[shapeType] = creator;
           return true;
    }
}

－－－－－－－－－－－－CCircle .h－－－－－－－－－－－－－－－－－－－－
#include<stdio.h>

#include "IShape.h"
#include "CFactory.h"
class CCircle : public IShape
{
public:
 CCircle()
 {
  printf("\n CCircle\n");
 }
 virtual ~CCircle()
 {
  printf("\n ~CCircle\n");
 }

 virtual void Draw();
};


－－－－－－－－－－－－CCircle .cpp－－－－－－－－－－－－－－－－－－－－
#include "CCircle.h"

IShape* Create() { return new CCircle(); }
static const bool RegisterShape__ = ShapeFactory::Instance().RegisterShape( "CCircle", Create);

void CCircle::Draw()
{
 printf("\n CCircle::Draw\n");
}


－－－－－－－－－－－－main.cpp－－－－－－－－－－－－－－－－－－－－
#include<stdio.h>
#include"CFactory.h"

#include "IShape.h"

int main() {
    IShape* line = ShapeFactory::Instance().Create("CCircle");
    line->Draw();    
    return 0;
}

有点小小的兴奋，大家积极发言哟！！！

主要参考： http://blog.csdn.net/jicao/archive/2006/07/01/861343.aspx 
                     http://blog.csdn.net/hjsunj/archive/2008/01/07/2028597.aspx
                     《c++设计新思维》

         声明里面可以包括的元素有：类型说明符(int, void, char,struct...)，存储类型extern, static, register, 类型限定符(const, volatile), 变量名(标识符), 符号(*，圆括号和中括号)；

       总体原则是，找到标识符(即是我们平时叫的变量名)，从右向左解析；

       具体步骤如下：

       1. 找到声明中最左边的标识符,去掉标识符   => 变量是叫“标识符”

       2. 查看标识符右边的下一个符号，如果是方括号，取出可能的大小，去掉方括号 ＝>是一个数组。

    3. 查看标识符右边的下一个符号，

 如果是左圆括号，取出可能的参数，一直到右括号 ＝> 是一个函数

       4. 查看标识符左边的符号，如果是左括号，找到对应的右括号，并把括号中的声明组合在一起。回到第2步重新开始执行。

       5. 查看标识符左边的符号，如果是const, volatile,*, 继续向左读直到不是这三个类型为止。重复第4步。  =>解释为const, volatile,指向什么的指针

       6. 剩下的符号一并读入 =>static unsigned int

       你可能想问这几步就可以解决了? 是的，这就是所谓的神奇解码环。

    下面我来随便验证下这个算法:

       先来个简单的

int (*a)[10] 和 int* a[10];

   声明式       步骤               执行结果

int (*a)[10]    第1步           找到最左边的标识符a，表示a是一个…

int (*)[10]      第2，3步    不匹配

int (*)[10]      第4步          匹配(,直接读到),包括*，表示a是一个指向…指针.Step2

int [10]          第2步           匹配[10]，表示a是一个指向..size=10的数组的指针

int                 第3，4，5    不匹配

结束            第6步           表示a是一个指向int数组的指针

int* a[10]     第1步           a是一个

int* [10]       第2步           a是一个…size=10的数组

int*              第3步           不匹配

int                第4步           匹配，a是一个存放着指针，size=10的数组

int                第5步           匹配，a是一个存放着int指针，size=10的数组

       大家看的出两个声明的结果是一个是指针，一个是数组。

    int a1[10];

    int a2[20];

    int (*b)[10];

    int* c[10];

    a[0] = 10;

    b = &a2;    //报错，cannot convert from 'int (*)[20]' to 'int (*)[10]'

    b = &a1;    //b是指向size=10的数组的指针

    c[0] = &a1[0]; //c是一个数组，里面存放的是指针，指针指向int;

我的程序很简单，就是把之前通过一个结构体fwrite到文件A里的内容读出，然后转给另一个结构体保存。程序是简单，但我担心的是之前把结构体fwrite到文件A的程序对齐结构体规则是怎样的？一定要知道它吗? 当然了，如果那个程序结构体是按照1对齐写入的，我的程序结构体是按照4对齐读入，那不就糟了！

      这里我引入结构体对齐的概念，也可以说是内存对齐了。为什么要内存对齐呢，就是方便CPU寻址了，具体原因大家要参考计算机体系结构了。先看一个内存对齐的例子：

      struct example1{

           char a;

           double b;

           long l;

};

      struct example2{

           char a;

           long l;

           double b;

};

大家算算结构体大小，初次接触的博友可能对答案有点惊讶，VC编译， sizeof后结果分别是：24，16。 同样是的结构体，成员换了顺序，大小就不同了。其实内存对齐有个规则，只要知道了，就OK。那么以下5点是关键

1．          内存对齐与编译器设置有关，首先要搞清编译器这个默认值是多少

2．          如果不想编译器默认的话，可以通过#pragma pack(n)来指定按照n对齐

3．          每个结构体变量对齐，如果对齐参数n(编译器默认或者通过pragma指定)大于该变量所占字节数(m)，那么就按照m对齐，内存偏移后的地址是m的倍数，否则是按照n对齐，内存偏移后的地址是n的倍数。也就是最小化长度规则

4．          结构体总大小: 对齐后的长度必须是成员中最大的对齐参数的整数倍。最大对齐参数是从第三步得到的。

5．          补充：如果结构体A中还要结构体B，那么B的对齐方式是选它里面最长的成员的对齐方式

所以计算结构体大小要走三步，首先确定是当前程序按照几对齐(参照1，2点)，接着计算每个结构体变量的大小和偏移(参照3，5)，最后计算结构体总大小（参照4）。

      先算算example1吧，假设编译器是以16对齐的

      1．确定按照几对齐: 16;

      2．确定每个成员的偏移：a 占一个字节，16>1, 按照1对齐，起始位置0，0%1 = 0，那么a就存在0位置；b占8个字节，16>8，按照8对齐，起始位置就不能是1了，因为要按照8对齐，所以最近的偏移起始位置是8， 8%8 =0, 那么b就存在位置8-15的位置；l占4个字节，16>4，按照4对齐，起始位置16， 16%4=0，那么l就存在位置16-19的位置。所以结构体从0到19一共占用20个字节

      3．结构体总大小：成员中最大的对齐参数是b的8对齐，所以20％8!=0, 24刚好。

      真的很搞！同理计算example2应该是16；

     再举个结构体嵌套的例子吧，

#pragma pack(push)

#pragma pack(8)

struct test1{

      int a;

      char b;

      int c[20]

long l;

} ;

struct test2{

      char a1;

      char a2;

      struct test1 t1;

      double b1;

}

#pragma pack(pop)

先计算test1, 8对齐，a占用0-3，b占用4，c占用8－87，l占用88－91，一共92个字节。成员中最大的对齐参数是int了92%4=0;

再计算test2, a1z占用0，a2占用1，t1呢，4 % 4 (test1里面最长的成员的对齐方式) = 0, 4-95，b1占96到103；一共104个字节，成员中最大的对齐参数是double了104%8=0; 所以是104.

      那关于我文章开头提到的那个文件转换，我现在只要知道原始程序是按照什么对齐的，然后在新程序中指定按照几对齐就可以了，哈哈！            
      
      挤时间写的，有的地方有遗漏，请各位指正！

       void fn3() {printf("\n ClassA: fn3()\n");}
       void fn4(int i){printf("\n ClassA: fn4()\n");}
 };
int main()
{ 
Base* pBase1 = new ClassA(10, 20);
 pBase1->fn();              //OK，ClassA: fn()
 pBase1->fn(11);          //OK，ClassA: fn(INT)
 pBase1->fn2();            //OK，Base: void fn2(int)
 pBase1->fn2(2);          //NO, 不能访问
 pBase1->fn3();            //OK，Base: fn3()
 pBase1->fn4();            //OK，Base: fn4()
 pBase1->fn4(2);          //NO，不能访问
 printf("\n============================================\n");
 ClassA* pDerived = new ClassA(10, 20);
 pDerived->fn();            //OK，ClassA: fn()
 pDerived->fn(1);          //OK，ClassA: fn(INT)
 pDerived->fn2();          //NO，不能访问
 pDerived->fn2(2);        //OK，ClassA: fn2(INT)
 pDerived->fn3();          //OK，ClassA: fn3()
 pDerived->fn4();          //NO，不能访问
 pDerived->fn4(2);        //NO，ClassA: fn4(INT)
 printf("\n============================================\n");
 return 0;      
}

子类父类同名virtual函数(参数相同)， 用子类的指针，引用，对象访问时，子类会覆盖父类方法(只能访问子类方法)。
子类父类同名virtual函数(参数相同)， 用父类的指针，引用，对象访问时，子类会覆盖父类方法(只能访问子类方法)。
子类父类同名virtual函数(参数不同)， 用子类的指针，引用，对象访问时，子类会覆盖父类方法(只能访问子类方法)。
子类父类同名virtual函数(参数不同)， 用父类的指针，引用，对象访问时，父类会覆盖子类方法(只能访问父类方法)。
子类父类同名virtual函数(函数类型不同const/non-const)， 用子类的指针，引用，对象访问时，子类会覆盖父类方法(只能访问子类方法)。
子类父类同名virtual函数(函数类型不同const/non-const)， 用父类的指针，引用，对象访问时，父类会覆盖子类方法(只能访问父类方法)。

结论：参数和函数类型是c++编译器判断要不要多态的关键因素。注: 返回类型不同时，编译器会报错，virtual不能和static连用。静态成员函数，没有隐藏的this指针，virtual函数一定要通过对象来调用，既要this指针。
改进:：如果子类指针想访问到父类，可以在子类里加入:using 父类名::函数名；如pDerived->fn2(); 访问父类方法，在ClassA里面加入using Base::fn2，就可以访问了。如果父类指针想访问到子类，就需要指针转换了。

子类父类同名non-virtual函数(无论参数/返回/函数类型(const或static))，用子类的指针，引用，对象访问，子类会覆盖父类方法(只能访问子类方法)。
子类父类同名non-virtual函数(无论参数/返回/函数类型(const或static))，用父类的指针，引用，对象访问，父类会覆盖子类方法(只能访问父类方法)。

结论: non-virtual函数，既没有任何多态效果，如果父类要访问子类，只用指针转换。   

         所谓大道至简，想必大家看着这个都烦，我也是。想了想应该这样表达最简单：
 
         子类public继承父类的函数，唯有满足(参数，返回值，函数类型相同&父类是virtual)函数，父类的指针，引用(也指针实现的)能够多态的访问子类，否则父类指针只能访问父类的方法。 
         
         子类public继承父类的函数，子类的方法名会遮掩父类的相同名的方法。子类要想访问父类的方法，使用using 父类名::函数名。    
       
         具体的原因我觉得可能还是得找时间拜读下候杰译的《C++对象模型》，看看到底这个东西是怎么设计的。

　　举个例子，交通工具类可以派生出汽车和船两个子类，但拥有汽车和船共同特性水陆两用汽车就必须继承来自汽车类与船类的共同属性。

　　由此我们不难想出如下的图例与代码：

　当一个派生类要使用多重继承的时候，必须在派生类名和冒号之后列出所有基类的类名，并用逗好分隔。

   
 
#include <iostream> 
using namespace std; 
 
class Vehicle 
{ 
    public: 
        Vehicle(int weight = 0) 
        { 
            Vehicle::weight = weight; 
        } 
        void SetWeight(int weight) 
        { 
            cout<<"重新设置重量"<<endl; 
            Vehicle::weight = weight; 
        } 
        virtual void ShowMe() = 0; 
    protected: 
        int weight; 
}; 
class Car:public Vehicle//汽车 
{ 
    public: 
        Car(int weight=0,int aird=0):Vehicle(weight) 
        { 
            Car::aird = aird; 
        } 
        void ShowMe() 
        { 
            cout<<"我是汽车！"<<endl; 
        } 
    protected: 
        int aird; 
}; 
 
class Boat:public Vehicle//船 
{ 
    public: 
        Boat(int weight=0,float tonnage=0):Vehicle(weight) 
        { 
            Boat::tonnage = tonnage; 
        } 
        void ShowMe() 
        { 
            cout<<"我是船！"<<endl; 
        } 
    protected: 
        float tonnage; 
}; 
 
class AmphibianCar:public Car,public Boat//水陆两用汽车,多重继承的体现 
{ 
    public: 
        AmphibianCar(int weight,int aird,float tonnage) 
        :Vehicle(weight),Car(weight,aird),Boat(weight,tonnage) 
        //多重继承要注意调用基类构造函数 
        { 
         
        } 
        void ShowMe() 
        { 
            cout<<"我是水陆两用汽车！"<<endl; 
        } 
}; 
int main() 
{ 
    AmphibianCar a(4,200,1.35f);//错误 
    a.SetWeight(3);//错误 
    system("pause");  
}

　　上面的代码从表面看，看不出有明显的语发错误，但是它是不能够通过编译的。这有是为什么呢？
　　这是由于多重继承带来的继承的模糊性带来的问题。

 　先看如下的图示：

　　在图中深红色标记出来的地方正是主要问题所在，水陆两用汽车类继承了来自Car类与Boat类的属性与方法，Car类与Boat类同为AmphibianCar类的基类，在内存分配上AmphibianCar获得了来自两个类的SetWeight()成员函数，当我们调用a.SetWeight(3)的时候计算机不知道如何选择分别属于两个基类的被重复拥有了的类成员函数SetWeight()。

　　由于这种模糊问题的存在同样也导致了AmphibianCar a(4,200,1.35f);执行失败，系统会产生Vehicle”不是基或成员的错误。

　　以上面的代码为例，我们要想让AmphibianCar类既获得一个Vehicle的拷贝，而且又同时共享用Car类与Boat类的数据成员与成员函数就必须通过C++所提供的虚拟继承技术来实现。

　　我们在Car类和Boat类继承Vehicle类出，在前面加上virtual关键字就可以实现虚拟继承，使用虚拟继承后，当系统碰到多重继承的时候就会自动先加入一个Vehicle的拷贝，当再次请求一个Vehicle的拷贝的时候就会被忽略，保证继承类成员函数的唯一性。

　　修改后的代码如下，注意观察变化：

#include <iostream> 
using namespace std; 
 
class Vehicle 
{ 
    public: 
        Vehicle(int weight = 0) 
        { 
            Vehicle::weight = weight; 
            cout<<"载入Vehicle类构造函数"<<endl; 
        } 
        void SetWeight(int weight) 
        { 
            cout<<"重新设置重量"<<endl; 
            Vehicle::weight = weight; 
        } 
        virtual void ShowMe() = 0; 
    protected: 
        int weight; 
}; 
class Car:virtual public Vehicle//汽车，这里是虚拟继承 
{ 
    public: 
        Car(int weight=0,int aird=0):Vehicle(weight) 
        { 
            Car::aird = aird; 
            cout<<"载入Car类构造函数"<<endl; 
        } 
        void ShowMe() 
        { 
            cout<<"我是汽车！"<<endl; 
        } 
    protected: 
        int aird; 
}; 
 
class Boat:virtual public Vehicle//船,这里是虚拟继承 
{ 
    public: 
        Boat(int weight=0,float tonnage=0):Vehicle(weight) 
        { 
            Boat::tonnage = tonnage; 
            cout<<"载入Boat类构造函数"<<endl; 
        } 
        void ShowMe() 
        { 
            cout<<"我是船！"<<endl; 
        } 
    protected: 
        float tonnage; 
}; 
 
class AmphibianCar:public Car,public Boat//水陆两用汽车,多重继承的体现 
{ 
    public: 
        AmphibianCar(int weight,int aird,float tonnage) 
        :Vehicle(weight),Car(weight,aird),Boat(weight,tonnage) 
        //多重继承要注意调用基类构造函数 
        { 
            cout<<"载入AmphibianCar类构造函数"<<endl; 
        } 
        void ShowMe() 
        { 
            cout<<"我是水陆两用汽车！"<<endl; 
        } 
        void ShowMembers() 
        { 
            cout<<"重量："<<weight<<"顿，"<<"空气排量："<<aird<<"CC，"<<"排水量："<<tonnage<<"顿"<<endl; 
        } 
}; 
int main() 
{ 
    AmphibianCar a(4,200,1.35f); 
    a.ShowMe(); 
    a.ShowMembers(); 
    a.SetWeight(3); 
    a.ShowMembers(); 
    system("pause");  
}

　　注意观察类构造函数的构造顺序。

　　虽然说虚拟继承与虚函数有一定相似的地方，但读者务必要记住，他们之间是绝对没有任何联系的！

            AOP技术在Java平台下是最先得到应用的。就在PARC对于面向方面编程进行研究的同时，美国Northeastern University的博士生Cristina Lopes和其同事也开始了类似的思考。最终，美国国防先进技术研究计划署（Defense Advanced Research Projects Agency即DARPA）注意到了这项工作，并提供了科研经费，鼓励将二者的工作成果结合起来。他们通过定义一套Java语言的扩展系统，使开发者可以方便的进行面向方面的开发，这套扩展系统被称为AspectJ。之后，AspectJ在2002年被转让给Eclipse Foundation，从而成为在开源社区中AOP技术的先锋，也是目前最为流行的AOP工具。

            那么对于C++技术来说，怎样来开展AOP呢，幸好有Olaf Spinczyk 这样的人存在，我们也有了aspect c++。它使用了插入代码的方法。一个典型的Aspect C++示例需要一个C++源文件(.cpp)、一个aspect C++源文件(.ah)，通过ac++编译器把C++源文件和aspect C++源文件转换成混合的C++源文件(如果有头文件也会转换)，最后通过普通的C++编译器编译出可执行文件。
 
            那么我现在如果不想用第三方编译器，自己去实现AOP，不知道CPPBLOG里的大虾有什么想法？

        我在用C/C++函数时，从没有全面考虑过该函数功能，只是知道它能做，基本对函数细节没有了解，就拿下面这个函数做个例子：

        char *inet_ntoa(struct in_addr in);

        struct in_addr {      unsigned long int s_addr; }

        看到这个我就能想到该函数是把一个unsigned long type的数转换成一个字符串。其它什么都不想。现在让我们来仔细品读里面的东西。

        我传入一个unsigned long type的数据，它给我传出一个char *，那这个char * 在函数里怎么分配空间的。首先不可能是堆分配，因为如果是那样的话，你用完这个函数后还要释放资源。其次不可能是栈分配，因为那样函数返回后栈也会跟着释放。那还有可能是全局变量，如果这样的话，C/C++中已经有好多全局了。那还有一种是static的可能，static不会随着函数的返回而释放，也就是说，它是一块长期被分配的内存空间，现在在假若我在程序中这样写：

        printf(“%s, %s”, inet_ntoa(a), inet_ntoa(b)); //a, b 是两个不相等的值

        输出会让我大吃一惊，输出结果一样。原因很简单，就是printf先求b，把值给了那个static，然后再求a, 把值又给了static，static的那块内存最终被写入了a的值，这个时候输出，那当然就输出的同一个值了。还有一种错误写法，如下：

        Char *tmp1 = inet_ntoa(a);

        Char *tmp2 = inet_ntoa(b);

        这样也是有问题的，因为tmp1和tmp2都指向了一块内存，当前的static的值就是b的值了。所以总结如下，使用这种函数一定要copy函数返回的值，而不能去保存其内存地址！
附inet_ntoa()源码：
#include <stdio.h>
#include <stdlib.h>
#include <arpa/inet.h>
#include <bits/libc-lock.h>

/* The interface of this function is completely stupid, it requires a
   static buffer.  We relax this a bit in that we allow at least one
   buffer for each thread.  */

/* This is the key for the thread specific memory.  */
static __libc_key_t key;

/* If nonzero the key allocation failed and we should better use a
   static buffer than fail.  */
static char local_buf[18];
static char *static_buf;                                //静态

/* Destructor for the thread-specific data.  */
static void init (void);
static void free_key_mem (void *mem);


char *
inet_ntoa (struct in_addr in)
{
  __libc_once_define (static, once);
  char *buffer;
  unsigned char *bytes;

  /* If we have not yet initialized the buffer do it now.  */
  __libc_once (once, init);

  if (static_buf != NULL)
    buffer = static_buf;
  else
    {
      /* We don't use the static buffer and so we have a key.  Use it
to get the thread-specific buffer.  */
      buffer = __libc_getspecific (key);
      if (buffer == NULL)
{
  /* No buffer allocated so far.  */
  buffer = malloc (18);
  if (buffer == NULL)
    /* No more memory available.  We use the static buffer.  */
    buffer = local_buf;
  else
    __libc_setspecific (key, buffer);
}
    }

  bytes = (unsigned char *) &in;
  __snprintf (buffer, 18, "%d.%d.%d.%d",
      bytes[0], bytes[1], bytes[2], bytes[3]);

  return buffer;
}


/* Initialize buffer.  */
static void
init (void)
{
  if (__libc_key_create (&key, free_key_mem))
    /* Creating the key failed.  This means something really went
       wrong.  In any case use a static buffer which is better than
       nothing.  */
    static_buf = local_buf;
}

C ：

  struct Node{              // 声明

       int node;

       struct Node *next;        // 定义

  };

  struct Node list;

  或者

  typedef  Node {         

   int node;

   struct Node *next;

}ListLink;

  ListLink list;

C++:

  struct Node{

    Int node;

    Node *next;

};

Node list;               // 搞定了

这样一看 C++ 的确实在代码的层面上简单了，但理解起来却不是很舒服！

今天刚接到任务做 Wireless-Lan ，好长时间没做正事了（这两天主要在写文档）东西还比较多，但是和我一组的 Danel人很好 ，给我讲了下整个 class diagram 的流程，虽没有 sequence 那么容易理解，但我还是懂了。而且我发现他写程序时特别开心，心态很好，这也是我在追求的，慢慢来吧。总监说这周五之前做出点东西，呵呵，不能让他失望呀，过会再看看代码， GUI ，我蛮喜欢写的。

再说说今天用的那个工具， SOURCE INSIGHT ，真爽。看代码的强有力工具。下次给 PASSION 的兄弟们介绍下。

1. 把多个源文件编译成目标代码。编译分为预处理器(把类似与#define的替换源文件)，然后解析，也就是来识别代码，大多数错误和警告产生在这步，最后目标代码便生成。这个过程中也可以加入优化器来优化代码。
2. 把目标代码与标准库函数用链接器捆绑在一起，用于执行。

执行：

1. 程序载入内存。
2. 程序执行。
3. 程序终止。