C语言和C++都会经过汇编，生成汇编代码，在汇编代码的阶段，是分辨不出是C语言还是C++语言的。在早期C++还没有成熟的编译器的时候，C++通过先把程序翻译成C语言，然后使用C语言的编译器把程序编译成可执行文件。所以，面向对象只是一种思想，在不支持面向对象的语言中也可以使用这种思想。只不过，在C语言中，需要自己实现这些特性，而在C++中，是编译器在幕后做了一些工作。

数据抽象

数据抽象可以将类的接口和实现分开。C语言中有struct来定义新的数据类型，但没有实现数据类型和操作的绑定，要实现操作和数据类型的绑定，首先在传入参数的时候，需要把struct的地址传进去，然后把所有的操作都变成函数指针存储在结构体中。以一个简单的类为例：

#ifndef _POINT_H_
#define _POINT_H_
typedef struct point* Point;
struct point{
    int x;
    int y;
    double (*distance)(Point p1);
    void (*print)(Point p);
};

double distance(Point p1);
Point create_point(int x,int y);
void print_point(Point p);

#endif

#include "point.h"
#include <stdlib.h>
#include <math.h>
#include <stdio.h>

void print_point(Point p){
    printf("x = %d, y = %d.\n",p->x,p->y);
}

double distance(Point p1){
    return sqrt(pow(p1->x,2) + pow(p1->y,2));
}

Point create_point(int x,int y){
    Point p = (Point)malloc(sizeof(struct point));
    p->x = x;
    p->y = y;
    p->distance = distance;
    p->print= print_point;
    return p;
}

int main(int argc, char const *argv[])
{
    Point p = create_point(1,1);
    p->print(p);
    printf("p distance = %f\n",p->distance(p));
    free(p);
    return 0;
}

这样，对象的创建和方法的调用就有一点面向对象的感觉了。

继承

使用继承，可以定义相似地的类型并对其关系建模。继承就是对类的扩展，为了能够实现兼容，派生的类必须有基类的所有成员和函数。然后可以在其基础上增加一些功能，也可以改变原有的功能。这里我简单的把基类的函数指针和成员放在派生类的前面。

#ifndef _CIRCLE_H_
#define _CIRCLE_H_
#include "point.h"
typedef struct circle* Circle;
struct circle{
    int x;
    int y;
    double (*distance)(Point p1);
    void (*print)(Circle c);
    int r;
    double (*area)(Circle c);    
};
Circle create_circle(int x,int y,int r);
double area(Circle c);

#endif

#include "circle.h"

void print_circle(Circle c){
    printf("x = %d, y = %d, r = %d.\n",c->x,c->y,c->r);
}

Circle create_circle(int x,int y,int r){
    Circle c = (Point)malloc(sizeof(struct circle));
    c->x = x;
    c->y = y;
    c->distance = distance;
    c->print = print_circle;
    c->r = r;
    c->area = area;
    return c;
}

double area(Circle c){
    return 3.14 * c->r * c->r;
}

int main(int argc, char const *argv[])
{
    Circle c = create_circle(1,1,2);
    printf("c distance = %f\n",c->distance(c));
    c->print(c);
    printf("c area = %f\n",c->area(c));
    return 0;
}

这里可以发现，把point的成员放在前面，然后在初始化的时候，将函数指针赋值为point的函数地址，如果覆写了，就改为改过之后的函数地址。可以发现，能够调用原来的函数，也能够调用新增的函数。

动态绑定

动态绑定，可以在一定程度上忽略相似类型的区别，而以统一的方式使用它们的对象。看下面一个例子：

int main(int argc, char const *argv[])
{
    Circle c = create_circle(1,1,2);
    Point p = (Point)c;
    p->print(p);
    printf("p distace = %f\n",p->distance(p));
    return 0;
}

可以发现，可以把Circle转化为Point，并且可以正常的调用Point的方法。这里其实很简单，强制装换之后，其实和没有装换是没太大区别的，除了不能访问其扩展的成员。其实动态绑定不在调用的时候，而在初始化的时候，print函数在初始化的时候就变成了新的地址，所以这里调用的时候，会使用Circle的函数。

总结

最近在看《深度探索C++对象模型》，一方面感觉C++编译器的实现确实很巧妙，一方面又感觉C语言确实小巧精悍，即使不用C++，C语言本身也可以实现面向对象的东西。所以写了这一篇笔记，加深一下自己对面向对象的理解。个人水平有限，举的例子也许有一些问题，望大家见谅。