引言
面向对象是一个老生常谈的话题，其基本思想为封装、继承、多态。
最近在学习 Linux 系统源码时，发现虽然系统是使用面向过程的 C 语言编写，但是还是可以体现出面向对象的思想，如文件系统中的文件操作 file_operation 结构，每种 inode 都有其对应的操作结构，这正是面向对象中多态的体现。
所以，经过小小的研究，我使用 C 语言成功实现了类似面向对象化的编程。
这也充分说明，面向对象的编程思想和范式，可以不受语言的拘泥。正所谓金庸笔下的独孤求败，「四十岁後，不滞於物，草木竹石均可为剑。自此精修，渐进於无剑胜有剑之境。」
不多废话，我们一起来看是如何实现的吧。
封装
封装也叫作信息隐藏或者数据访问保护。类通过暴露有限的访问接口，授权外部仅能通过类提供的方式来访问内部信息或者数据。
封装特性存在的意义，一方面是保护数据不被随意修改，提高代码的可维护性；另一方面是仅暴露有限的必要接口，提高类的易用性。
我们尝试封装一个简单的Point“类”，并且定义相关的 getter/setter 方法。当然 C语言没有办法在声明中隐藏其数据结构，并且由于没有访问控制功能，没有办法做到完美的封装。
//Point.h
typedef struct{
int x;
int y;
}Point;
int Point_getX(Point const p);
int Point_getY(Point const p);
void Point_init(Point *p, int x, int y);
然后我们在 .c 文件中实现前面定义的方法。
//Point.c
#include "Point.h"
int Point_getX(Point const p) {
return p.x;
}
int Point_getY(Point const p) {
return p.y;
}
void Point_init(Point *p, int x, int y) {
p->x = x;
p->y = y;
}
大功告成！
我们来体验一下刚才封装的 Point “类”。
创建一个 Point “对象”，使用 setter 设置它的“属性”，然后通过 getter 将值取出打印出来。
//main.c
#include <stdio.h>
#include "Point.h"
int main(int argc, const char * argv[]) {
Point p;
Point_init(&p, 10, 20);
printf("point x:%d,y:%d\n", Point_getX(p), Point_getY(p));
return 0;
}
控制台输出
point x:10,y:20
继承
继承是用来表示类之间的 is-a 关系，用于解决代码复用的问题。
那 C 语言如何实现继承呢？其实在 C 语言里面实现继承也非常简单，只要把基类放到继承类的数据成员中就行了。
我们来实现一个 Square “类”，添加一个边长的“属性”。
//Square.h
#include "Point.h"
typedef struct {
Point super;
int sideLen;
}Square;
int Square_getSideLen(Square const s);
void Square_init(Square *s, int x, int y, int sideLen);
//Square.c
#include "Square.h"
int Square_getSideLen(Square const s) {
return s.sideLen;
}
void Square_init(Square *s, int x, int y, int sideLen) {
//Point_init((Point*)s, x, y);
Point_init(&(s->super), x, y);
s->sideLen = sideLen;
}
实现完毕，赶快来体验一下。
//main.c
int main(int argc, const char * argv[]) {
Square s;
Square_init(&s, 10, 20, 10);
printf("square x:%d,y:%d,sideLen:%d\n", s.super.x, s.super.y, s.sideLen);
return 0;
}
控制台输出
square x:10,y:20,sideLen:10
可能会有人对上面的实现有疑问，为什么 //Point_init((Point*)s, x, y); 这句也可以生效呢？那就要从结构体的内存布局说起了。
//Point内存布局
┏━━━━━━┳━━━━━━┓
┃int x ┃int y ┃
┗━━━━━━┷━━━━━━┛
//Square内存布局
┏━━━━━━┳━━━━━━┳━━━━━━━━━━━┓
┃int x ┃int y ┃int sideLen┃
┗━━━━━━┷━━━━━━┷━━━━━━━━━━━┛
Square 的首个成员是 Point，然后是边长，则其内存布局如上。
因为有这样的内存布局，所以你可以很安全的传一个指向 Square 对象的指针到一个期望传入 Point 对象的指针的函数中，就是一个函数的参数是 Point *，你可以传入 Square *，并且这是非常安全的。这样的话，基类的所有属性和方法都可以被继承类继承！
多态
多态是指子类可以替换父类，在实际的代码运行过程中，调用子类的方法实现。多态可以提高代码的扩展性和复用性，是很多设计模式、设计原则、编程技巧的代码实现基础。
我们在 Point 类中，添加方法列表 Operations，然后在初始化时绑定 print 方法。同样的，要实现多态的效果，我们需要在 Square 初始化时，替换原来的方法。
//Point.h
struct Operations;
typedef struct{
int x;
int y;
struct Operations *op;
}Point;
struct Operations{
void (*print)(Point*);
};
int Point_getX(Point const p);
int Point_getY(Point const p);
void Point_init(Point *p, int x, int y);
//Point.c
#include "Point.h"
#include <stdio.h>
int Point_getX(Point const p) {
return p.x;
}
int Point_getY(Point const p) {
return p.y;
}
void Point_print(Point *p) {
printf("point x:%d,y:%d\n", Point_getX(*p), Point_getY(*p));
}
void Point_init(Point *p, int x, int y) {
p->x = x;
p->y = y;
static struct Operations op = {Point_print};
p->op = &op;
}
//Square
#include "Square.h"
#include <stdio.h>
int Square_getSideLen(Square const s) {
return s.sideLen;
}
void Square_print(Square *s) {
printf("square x:%d,y:%d,sideLen:%d\n", Point_getX((*s).super), Point_getY((*s).super), Square_getSideLen(*s));
}
void Square_init(Square *s, int x, int y, int sideLen) {
// Point_init((Point*)s, x, y);
Point_init(&(s->super), x, y);
s->sideLen = sideLen;
struct Operations op = {(void (*)(Point*))Square_print};
s->super.op = &op;
}
大功告成！试一下是否真的可以有多态的效果。
int main(int argc, const char * argv[]) {
Point p;
Point_init(&p, 10, 20);
p.op->print(&p);
Square s;
Square_init(&s, 10, 20, 10);
Point* _s = (Point *)&s;
s.super.op->print(_s);
return 0;
}
控制台输出
point x:10,y:20
square x:10,y:20,sideLen:10
