RT-Thread-rt thrad 源码笔记：rt thread中的面向对象RT-Thread问答社区

rt thrad 源码笔记：rt thread中的面向对象

发布于 2024-12-05 16:56:31 浏览：313 订阅该版

[tocm]

# 引言

看文档时看到一句：“RT-Thread 内核采用面向对象的设计思想进行设计”，内心就有了两个问题：

过程式的C语言程序中如何去应用面向对象的设计方法？
面向对象如何应用到操作系统？

# 过程式的C语言程序中如何去应用面向对象的设计方法？

c语言的strcut能把各项数据成员组织起来。至于成员函数，函数名称中添加前缀，约定俗成，说这些函数是某个sturct的成员。

最关键的成员函数是构建函数，析构函数，初始化函数。c语言能从面向对象的最大受益就是解决了对象的生存周期问题，能有效减小内存泄漏的风险。

rt thread也正是这么做的：

```C
struct rt_object
{
#if RT_NAME_MAX > 0
    char        name[RT_NAME_MAX];                       /**< dynamic name of kernel object */
#else
    const char *name;                                    /**< static name of kernel object */
#endif /* RT_NAME_MAX > 0 */
    rt_uint8_t  type;                                    /**< type of kernel object */
    rt_uint8_t  flag;                                    /**< flag of kernel object */

#ifdef RT_USING_MODULE
    void      * module_id;                               /**< id of application module */
#endif /* RT_USING_MODULE */

#ifdef RT_USING_SMART
    rt_atomic_t lwp_ref_count;                           /**< ref count for lwp */
#endif /* RT_USING_SMART */

rt_list_t   list;                                    /**< list node of kernel object */
    //? 一个对象，为何会有链表？
};
typedef struct rt_object *rt_object_t;                   /**< Type for kernel objects. */
```

```C
void rt_object_delete(rt_object_t object);
rt_object_t rt_object_allocate(enum  rt_object_class_type type ,
                               const  char*  name)

void rt_object_detach(rt_object_t object);
void rt_object_init(struct  rt_object*  object ,
                    enum rt_object_class_type  type ,
                    const char* name)

```

# 面向对象如何应用到操作系统？

rt thread把系统中需要控制，分配的一个个资源（如内存池，文件，锁，信号量）都看成对象。这些对象共享构建，析构函数。
这样对象的生存周期就可控制了。同时每出现一个新的抽象资源类，旧的设计系统也能融入。

![screenshot_image.png](https://oss-club.rt-thread.org/uploads/20241206/b20ee5a625cd00f31f01f1049ef5c438.png)

但系统对象绝不可在栈上创建，否则函数帧一没，对象内存就乱了。

# rt thread 一些有意思的点

## 容器管理

rt thread采用容器管理对象，每个对象应在对应类型的容器内。当对象被创建时，新对象在容器内。当对象被删除时即意味着对象被移除容器，内存被回收。

如信号量对象就会被挂在信号量容器里。

```C
void rt_object_detach(rt_object_t object)
{
    rt_base_t level;
    struct rt_object_information *information;

/* object check */
    RT_ASSERT(object != RT_NULL);

RT_OBJECT_HOOK_CALL(rt_object_detach_hook, (object));

information = rt_object_get_information((enum rt_object_class_type)object->type);
    RT_ASSERT(information != RT_NULL);

level = rt_spin_lock_irqsave(&(information->spinlock));
    /* remove from old list */
    rt_list_remove(&(object->list));
    rt_spin_unlock_irqrestore(&(information->spinlock), level);

object->type = RT_Object_Class_Null;
    //? 有必要改吗？
}
```

从deattch的最后一行代码可以看出，当对象被移出时，对象类型也被修改了。

容器的数据结构是队列，更内部的实现方式是双向链表。

`rtservice.h`实现了队列的常用接口。

## 链表节点无数据成员

查看object类成员的list，你会发现他只是一个含有两个指针的结构体。意义是方便容器跳转到前后节点的跳板。

![screenshot_image.png](https://oss-club.rt-thread.org/uploads/20241206/c14df314ce7500651f7847d11eee6211.png.webp)

为什么这样做？而不是像教科书一样，链表节点包含其他数据成员？

如果像后者那样，那么不同类容器就无法抽离出队列接口。每有一个类的容器，都需要写一个新的队列。因为链表跳板和对象的数据成员耦合了。

![screenshot_image.png](https://oss-club.rt-thread.org/uploads/20241206/5a745710e58bf4a6fb928dccb80530a7.png.webp)

而rt thread这样做，就能成功分离链表跳板和对象数据成员，也就能一个队列打遍天下所有对象啦。

那么新的问题来了，这样做之后，如果跳转到某个对象的list处，如何访问其他成员呢？

## container of

结构体的成员内存分布是像数组一样，按成员顺序连续分布的。结构体的地址也就是结构体第一个成员的地址。
当我们跳转到list成员，只需得知此时偏移量，然后算地址即可。

```C
/**
 * rt_container_of - return the start address of struct type, while ptr is the
 * member of struct type.
 */
#define rt_container_of(ptr, type, member) \
    ((type *)((char *)(ptr) - (unsigned long)(&((type *)0)->member)))

```

上图的宏就是通过list成员地址返回对象地址。

p→a就约等于*（p+offset(a)）。offset(a)为a成员地址离对象地址的偏移量。

因此`((type *)0)->member))`就等于 *(0+offset(member))。要访问的地址也就是偏移量。最后&取地址。

为什么没有触发空指针异常呢？因为没有访问地址，去读取值的过程。

# todo

- [ ] 不理解object类的flag成员作用

- [ ] 不理解`rtservice.h`为何又实现了单链表，此处无来龙去脉。