一、c语言面向对象

1.面向过程于面向对象

　　面向过程”(Procedure Oriented)是一种以过程为中心的编程思想

　　对象程序设计（Object Oriented Programming，OOP）是一种计算机编程架构。OOP的一条基本原则是计算机程序由单个能够起到子程序作用的单元或对象组合而成。

　　面向对象的三个目标：重用性、灵活性和扩展性，OOP=对象+类+继承+多态+消息；

　　面向对象的三大特性：封装、继承、多态，而封装加抽象则可以对外提供一个低耦合的模块。

　　无论是面向对象还是面向过程，低耦合，高聚和。这六个字就是亘古不变的真理。高聚和：各模块的相关特性数据和操作函数都封装在结构体（PO）/类（OOP）；

低耦合：不仅要做到各独立模块间的数据接口独立，同一个模块内的不同作用的接口也要独立出来。

2.分析rt-thread的对象就可以很好的理解，并写出一个demo

　　首先是对象，rt-thread内核有基类对象，并由此派生出了 线程对象、内存池对象、ipc通讯对象、定时器对象和设备对象，如下图所示：

在积累对象rt_object中定义了通用的数据结构用来保存各种对象的共同属性，各类具体对象只需要在加上自己所特有的属性丰富描述自己。而内核对象管理线条将所有的对象链接到各种类型的链表中，以后会详细讲解rt-thread的设备管理方式，并仿照这种方式实现自己freertos上编程。

struct rt_object
{
     /* 内核对象名称     */
     char      name[RT_NAME_MAX];
     /* 内核对象类型     */
     rt_uint8_t  type;
     /* 内核对象的参数   */
     rt_uint8_t  flag;
     /* 内核对象管理链表 */
     rt_list_t   list;
};

typedef struct rt_device *rt_device_t;                  /* 将结构体定义成指针类型，便于动态（malloc）分配，并由调用者删除*/

struct rt_device
{
    struct rt_object          parent;                   /**< inherit from rt_object 设备类继承内核对象基类 */

    enum rt_device_class_type type;                     /**< device type  区分对象类型 */
    rt_uint16_t               flag;                     /**< device flag  设备打开方式IRQ/DMA*/
    rt_uint16_t               open_flag;                /**< device open flag 设备权限，只读/只写/读写*/

    rt_uint8_t                ref_count;                /**< reference count 设备调用次数*/
    rt_uint8_t                device_id;                /**< 0 - 255 */

    /* device call back */ 
    rt_err_t (*rx_indicate)(rt_device_t dev, rt_size_t size);    /* 设备接受满回调函数 */
    rt_err_t (*tx_complete)(rt_device_t dev, void *buffer);      /* 发送完成回调函数 */

#ifdef RT_USING_DEVICE_OPS
    const struct rt_device_ops *ops;
#else
    /* common device interface */                                /* 每个设备都有的设备操作函数 */
    rt_err_t  (*init)   (rt_device_t dev);
    rt_err_t  (*open)   (rt_device_t dev, rt_uint16_t oflag);
    rt_err_t  (*close)  (rt_device_t dev);
    rt_size_t (*read)   (rt_device_t dev, rt_off_t pos, void *buffer, rt_size_t size);
    rt_size_t (*write)  (rt_device_t dev, rt_off_t pos, const void *buffer, rt_size_t size);
    rt_err_t  (*control)(rt_device_t dev, int cmd, void *args);
#endif

#if defined(RT_USING_POSIX)
    const struct dfs_file_ops *fops;
    struct rt_wqueue wait_queue;
#endif

    void                     *user_data;                /**< device private data */
};

rt_device_t rt_device_create(int type, int attach_size)
{
    int size;
    rt_device_t device;

    size = RT_ALIGN(sizeof(struct rt_device), RT_ALIGN_SIZE);
    attach_size = RT_ALIGN(attach_size, RT_ALIGN_SIZE);
    /* use the total size */
    size += attach_size;

    device = (rt_device_t)rt_malloc(size);
    if (device)
    {
        rt_memset(device, 0x0, sizeof(struct rt_device));
        device->type = (enum rt_device_class_type)type;
    }

    return device;
}

可以根据 rt_device_create 看出，创建一个设备就是从堆上分配一个设备大小的内存返回出来，注意函数内的栈空间（数组）不能返回出来，除非是编译器已经分配好的全局变量或静态变量。堆使用后可以由用户随时删除。内存删除后配合特定的内存算法，不至于分配到最后全是碎片。

根据设备类的操作接口函数可以看出，这是很标准的封装方法，相当于c++的类的方法。我们此次就是可以按照此种方式对一个长方形进行描述和设置。

#ifndef RECT_H
#define RECT_H
#include <rtthread.h>

typedef struct 
{
        char *object_name;
        int lenth;
        int width;
}Rect,*pRect;

typedef void* rt_handle_rect;

rt_handle_rect rect_creat(char *object_name);
void rect_set(rt_handle_rect rect, int len, int width);
int  rect_get_area(rt_handle_rect rect);
void rect_display(rt_handle_rect rect);
void rect_delete(rt_handle_rect rect);





#endif

#include "object.h"



rt_handle_rect rect_creat(char *object_name)
{

    pRect rect = rt_malloc(sizeof(rect));
    if (rect == RT_NULL)
    {
        rect = RT_NULL;
        rt_kprintf("rect object mallo err
");
        return RT_NULL;
    }

    rect->object_name = rt_malloc(rt_strlen(object_name) + 1);
    if (rect->object_name == RT_NULL)
    {
        rect->object_name = RT_NULL;
        rt_kprintf("rect object name mallo err
");
        return RT_NULL;
    }

    rt_memcpy(rect->object_name, object_name, rt_strlen(object_name) + 1);
    rect->lenth = 0;
    rect->width = 0;

    return (rt_handle_rect)rect;

}

void rect_set(rt_handle_rect rect, int len, int width)
{
    RT_ASSERT(rect);

    ((pRect)rect)->lenth = len;
    ((pRect)rect)->width = width;
}

int  rect_get_area(rt_handle_rect rect)
{
    RT_ASSERT(rect);

    return (((pRect)rect)->lenth * ((pRect)rect)->width);
}

void rect_display(rt_handle_rect rect)
{
    RT_ASSERT(rect);
    RT_ASSERT(((pRect)rect)->object_name);
    
        rt_kprintf("%s len:%d %d area:%d 
", ((pRect)rect)->object_name,
               ((pRect)rect)->lenth, ((pRect)rect)->width,rect_get_area(rect));
        
}

void rect_delete(rt_handle_rect rect)
{
    RT_ASSERT(rect);
    RT_ASSERT(((pRect)rect)->object_name);

    rt_free(((pRect)rect)->object_name);
    rt_free(rect);

    ((pRect)rect)->object_name = RT_NULL;
    rect = RT_NULL;
}

void rect_sample(void)
{
        rt_handle_rect rect = rect_creat("RECT");
        
        if(rect == RT_NULL)
        {
                rt_kprintf("rect creat err
");
                return;
        }
        
        rect_set(rect,10,20);
        rect_display(rect);
        
        rect_delete(rect);

}

MSH_CMD_EXPORT(rect_sample, rect sample);

这是一个很简单的demo,就是使用的面向对象编程的思想，很简单一看就会。这里不再赘述。