C语言的对象化模型
面向对象的特征主要包括：
.封装，隐藏内部实现
.继承，复用现有代码
.多态，改写对象行为
1.1 封装
封装是一种信息隐蔽技术，它体现于类的说明，是对象的重要特性。封装使数据和加工该数据的方法（函数）封装为一个整体，以实现独立性很强的模块，使得用户只能见到对象的外特性（对象能接受哪些消息，具有那些处理能力），而对象的内特性（保存内部状态的私有数据和实现加工能力的算法）对用户是隐蔽的。封装的目的在于把对象的设计者和对象者的使用分开，使用者不必知晓行为实现的细节，只须用设计者提供的消息来访问该对象。
在C语言中，大多数函数的命名方式是动词+名词的形式，例如要获取一个semaphore，会命名
成take_semaphore，重点在take这个动作上。面向对象编程中刚好相反，命名为rt_sem_take，即名词+动词的形式，重点在名词上，体现了一个对象的方法。另外对于某些方法，仅局限在对象内部使用，它们将采用static修辞把作用范围局限在一个文件的内部。通过这样的方式，把一些不想让用户知道的信息屏蔽在封装里，用户只看到了外层的接口，从而形成了面向对象中的最基本的对象封装实现。
一般属于某个类的对象会有一个统一的创建，析构过程。
对象内存数据块已经存在，需要对它进行初始化 – rt_sem_init;对象内存数据块还未分配，需要创建并初始化 – rt_sem_create。可以这么认为，对象的创建(create)是以对象的初始化(init)为基础的，创建动作相比较而言多了个内存分配的动作。
相对应的两类析构方式：
.由rt_sem_init初始化的semaphore对象 – rt_sem_detach;
.由rt_sem_create创建的semaphore对象 – rt_sem_delete.
1.2 继承
继承性是子类自动共享父类之间数据和方法的机制。它由类的派生功能体现。一个类直接继承其它类的全部描述，同时可修改和扩充。继承具有传递性。继承分为单继承（一个子类只有一父类）和多重继承（一个类有多个父类，当前RT-Thread的对象系统不能支持）。类的对象是各自封闭的，如果没继承性机制，则类对象中数据、方法就会出现大量重复。继承不仅支持系统的可重用性，而且还促进系统的可扩充性。
类似的实现代码如下程序清单：
/* 父类 */
struct parent_class
{
int a, b;
char *str;
};
/* 继承于父类的子类 */
struct child_class
{
struct parent class p;
int a, b;
};
/* 操作示例函数*/
void func()
{
struct child_class obj, *obj_ptr; /* 子类对象及指针 */
struct parent_class *parent_ptr; /* 父类指针 */
obj_ptr = &obj;
/* 取父指针 */
parent_ptr = (struct parent*) &obj;
/* 可通过转换过类型的父类指针访问相应的属性 */
parent ptr->a = 1;
parent ptr->b = 5;
/* 子类属性的操作 */
obj ptr->a = 10;
obj ptr->b = 100;
}
在上面代码中，注意child_class结构中第一个成员p，这种声明方式代表child_class类型的数据中开始的位置包含一个parent_class类型的变量。在函数func中obj是一个child_class对象，正像这个结构类型指示的，它前面的数据应该包含一个parent_class类型的数据。在第21行的强制类型赋值中parent_ptr指向了obj变量的首地址，也就是obj变量中的p对象。好了，现在parent_ptr指向的是
一个真真实实的parent类型的结构，那么可以按照parent的方式访问其中的成员，当然也包括可以使用和parent结构相关的函数来处理内部数据，因为一个正常的，正确的代码，它是不会越界访问parent结构体以外的数据。经过这基本的结构体层层相套包含，对象简单的继存关系就体现出来了：父对象放于数据块的最前方，代码中可以通过强制类型转换获得父对象指针。
1.3 多态
对象根据所接收的消息而做出动作。同一消息为不同的对象接受时可产生完全不同的行动，这种现象称为多态性。利用多态性用户可发送一个通用的信息，而将所有的实现细节都留给接受消息的对象自行决定，如是，同一消息即可调用不同的方法。例如：抽象设备具备接口统一的读写接口。串口是设备的一种，也应支持设备的读写。但串口的读写操作是串口所特有的，不应和其他设备
操作完全相同，例如操作串口的操作不应应用于SD卡设备中。多态性的实现受到继承性的支持，利用类继承的层次关系，把具有通用功能的协议存放在类层次中尽可能高的地方，而将实现这一功能的不同方法置于较低层次，这样，在这些低层次上生成的对象就能给通用消息以不同的响应。
对象模型采用结构封装中使用指针的形式达到面向对象中多态的效果，例如：
/* 抽象父类 */
struct parent_class
{
int a;
/* 反映不同类别属性的方法 */
void (*vfunc)(int a);
}
/* 抽象类的方法调用 */
void parent_class_vfunc(struct parent_class *self, int a)
{
assert(self != NULL);
assert(slef->vfunc != NULL);
/* 调用对象本身的虚拟函数 */
self->vfunc(a);
}
/* 继承自parent class的子类 */
struct child_class
{
struct parent_class parent;
int b;
};
/* 子类的构造函数 */
void child_class_init(struct child_class* self)
{
struct parent_class* parent;
/* 强制类型转换获得父类指针 */
parent = (struct base_class*) self;
assert(parent != NULL);
/* 设置子类的虚拟函数 */
parent->vfunc = child_class_vfunc;
}
/* 子类的虚拟函数实现 */
static void child class vfunc(struct child class*self, int a)
{
self->b = a + 10;
}
#include <stdio.h>
#include <stdlib.h>
//接口
#ifndef Interface
#define Interface struct
#endif
//类
#ifndef Class
#define Class struct
#endif
//抽象形状类
Class Shape;
typedef Class Shape shape;
//抽象形状类的方法声明
shape* Shape(int edges);
int shape_getEdges(shape *);
int shape_getArea(void);
void _Shape(shape *);
//三角形类
Class Triangle;
typedef Class Triangle triangle;
//三角形类的方法声明
triangle * Triangle(int bottom, int height);
int triangle_getEdges(triangle *);
int triangle_getArea(triangle *);
void _Triangle(triangle *);
//矩形类
Class Rectangle;
typedef Class Rectangle rectangle;
//矩形类的方法声明
rectangle * Rectangle(int bottom, int height);
int rectangle_getEdges(rectangle *);
int rectangle_getArea(rectangle *);
void _Rectangle(rectangle *);
//抽象形状类实现
Class Shape
{
int edges;
int (*getEdges)(shape*);
int (*getArea)(void);
};
//形状类构造函数
shape* Shape(int edges)
{
shape * obj = (shape *) malloc(sizeof(shape));
obj->edges = edges;
obj->getEdges = shape_getEdges;
obj->getArea = shape_getArea;
return obj;
}
int shape_getEdges(shape* obj)
{
return obj->edges;
}
int shape_getArea(void)
{
return -1;
}
//形状类析构函数
void _Shape(shape * obj)
{
if(obj == NULL)
return;
free(obj);
}
//三角形类实现
Class Triangle
{
shape * super;
int bottom;
int height;
int (*getEdges)(triangle *);
int (*getArea)(triangle *);
};
//三角形类构造函数
triangle * Triangle(int bottom, int height)
{
triangle* obj = (triangle*) malloc(sizeof(triangle));
//调用Shape构造函数用于实现继承
obj->super = Shape(3);
obj->bottom = bottom;
obj->height = height;
obj->getEdges = triangle_getEdges;
obj->getArea = triangle_getArea;
return obj;
}
int triangle_getEdges(triangle * obj)
{
return obj->super->edges;
}
int triangle_getArea(triangle * obj)
{
return (obj->bottom * obj->height) / 2;
}
//三角形类析构函数
void _Triangle(triangle * triangle)
{
_Shape(triangle->super);
if(triangle == NULL)
{
return;
}
free(triangle);
}
//矩形类实现
Class Rectangle
{
shape * super;
int bottom;
int height;
int (*getEdges)(rectangle *);
int (*getArea)(rectangle *);
};
//矩形类构造函数
rectangle * Rectangle(int bottom, int height)
{
rectangle * obj = (rectangle *)malloc(sizeof(rectangle));
//调用Shape构造函数用于实现继承
obj->super = Shape(4);
obj->bottom = bottom;
obj->height = height;
obj->getEdges = rectangle_getEdges;
obj->getArea = rectangle_getArea;
return obj;
}
int rectangle_getEdges(rectangle * obj)
{
return obj->super->edges;
}
int rectangle_getArea(rectangle * obj)
{
return (obj->bottom * obj->height);
}
//矩形类析构函数
void _Rectangle(rectangle * obj)
{
_Shape(obj->super);
if(obj == NULL)
{
return;
}
free(obj);
}
//测试
void main(){
shape* shapeObj = Shape(0);
printf("%d\n", shapeObj->getEdges(shapeObj));
printf("%d\n", shapeObj->getArea());
_Shape(shapeObj);
triangle* triangleObj = Triangle(4, 5);
printf("%d\n", triangleObj->getEdges(triangleObj));
printf("%d\n", triangleObj->getArea(triangleObj));
_Triangle(triangleObj);
rectangle* rectangleObj = Rectangle(4, 5);
printf("%d\n", rectangleObj->getEdges(rectangleObj));
printf("%d\n", rectangleObj->getArea(rectangleObj));
_Rectangle(rectangleObj);
}
