概述
学习和理解任何框架或库,官方文档可能都是最权威、最有效的信息。Qt
也不例外,https://doc.qt.io/qt-5/index.html
在文档的Core Internals小节,阐述了Qt Core
模块是整个Qt
框架的基础,其中QObject
类构成了Qt
对象模型(object model)的基础,是许多Qt
类的父类。对象模型引入了许多机制,比如:
- 元对象系统(meta-object system)
- 属性系统(The Property System)
- 事件系统(event system)
- 信号和槽机制(signals and slots mechanism)
- 状态机框架(State Machine Framework)。
- ...
QObject
类是这个模型的基础也是绝大多数类的父类。既然这样,那我们就从一切故事的源头——QObject
类开始一探究竟。
直接找到QObject
的定义,总共300+行,有非常多的成员,浏览下来也可以看到一些熟悉的方法,但这里我们不能一一展开,它是大部分框架的基础,做了很多基础性的工作,我们目前还不清楚它们的作用,太过追求细枝末节只会让我们迷失在浩瀚的源码海洋里。根据前面官方文档获得的信息,我们排除和其他衍生机制相关的成员,只拿出QObject
的重要变量和构造函数,看看一个QObject
的主要数据结构和初始化都做了什么:
//qobject.h
class Q_CORE_EXPORT Qobject{
Q_OBJECT
Q_PROPERTY(QString objectName READ objectName WRITE setObjectName NOTIFY objectNameChanged)
Q_DECLARE_PRIVATE(QObject)
public:
Q_INVOKABLE explicit QObject(QObject *parent=nullptr);
virtual ~QObject();
//...
protected:
QObject(QObjectPrivate &dd, QObject *parent = nullptr);
//...
protected:
QScopedPointer<QObjectData> d_ptr;
static const QMetaObject staticQtMetaObject;
//...
private:
Q_DISABLE_COPY(QObject)
//...
}
可以看到,略去大部分virtual
和public
方法后,Qobject
内部没有很多变量。接下来我们来看看剩下的这些成员。
Q_OBJECT
查看Q_OBJECT
的定义:
//qobjectdefs.h
#define Q_OBJECT \
public: \
QT_WARNING_PUSH \
Q_OBJECT_NO_OVERRIDE_WARNING \
static const QMetaObject staticMetaObject; \
virtual const QMetaObject *metaObject() const; \
virtual void *qt_metacast(const char *); \
virtual int qt_metacall(QMetaObject::Call, int, void **); \
QT_TR_FUNCTIONS \
private: \
Q_OBJECT_NO_ATTRIBUTES_WARNING \
Q_DECL_HIDDEN_STATIC_METACALL static void qt_static_metacall(QObject *, QMetaObject::Call, int, void **); \
QT_WARNING_POP \
struct QPrivateSignal {}; \
QT_ANNOTATE_CLASS(qt_qobject, "")
我们先看一些宏的功能:
QT_WARNING_PUSH
和 QT_WARNING_POP
这两个宏用于保存和还原编译器的警告设置,保证两个宏内不会产生不必要的警告。
Q_OBJECT_NO_OVERRIDE_WARNING
和Q_OBJECT_NO_ATTRIBUTES_WARNING
这两个宏用于控制是否发出关于未覆盖(override)的警告或者关于某些属性的警告。
QT_TR_FUNCTIONS
这个宏用于启用Qt
的国际化(internationalization)功能,使得文本可以被翻译为不同的语言。
关于Q_DECL_HIDDEN_STATIC_METACALL
,找到定义:
//qobjectdefs.h
# define Q_DECL_HIDDEN_STATIC_METACALL Q_DECL_HIDDEN
使用 Q_DECL_HIDDEN
可以将类或函数标记为在外部接口中隐藏的,从而使它们对库的用户不可见。这对于避免一些链接时的符号冲突和提高库的封装性很有帮助。这个宏可能会被翻译成 __attribute__((visibility("hidden")))
。也就是说qt_static_metacall
这个函数没用到,我们忽略。
如果去除这些和编译器相关的宏,Q_OBJECT
剩下的关键部分:
//qobjectdefs.h
#define Q_OBJECT \
public: \
static const QMetaObject staticMetaObject; \
virtual const QMetaObject *metaObject() const; \
virtual void *qt_metacast(const char *); \
virtual int qt_metacall(QMetaObject::Call, int, void **); \
private: \
Q_DECL_HIDDEN_STATIC_METACALL static void qt_static_metacall(QObject *, QMetaObject::Call, int, void **); \
Q_OBJECT
宏声明了1个QMetaObject
变量和3个QMetaObject
相关的虚函数。QMetaObject
类非常重要,和前面提到的元对象系统相关,这里我们不展开讲解元对象系统,后面的文章会单独讲解。讲到Q_OBJECT
,我们可能熟悉——声明了Q_OBJECT
后——就可以使用signal&slot机制,其实还可以使用很多元对象系统提供的其他服务。总而言之,使用了Q_OBJECT
宏后,类具备了元对象的能力。
Q_PROPERTY
查看Q_PROPERTY(QString objectName READ objectName WRITE setObjectName NOTIFY objectNameChanged)
定义:
//qobjectdefs.h
#define Q_PROPERTY(...) QT_ANNOTATE_CLASS(qt_property, __VA_ARGS__)
#define QT_ANNOTATE_CLASS(type, ...)
在 qobjectdefs.h
中我们并没有看到 Q_PROPERTY
的准确定义,而是到最后戛然而止了。这里要引出moc(Meta-Object Compiler)
——元对象编译器,很多Qt
的宏和特殊功能是通过moc
生成的代码而不是在头文件中显式定义的。C++
编译器能够识别 Q_PROPERTY
宏,是因为moc
编译时生成了相应的代码。
我们利用官方文档搜索Q_PROPERTY
,可以看到文档说使用Q_PROPERTY
后,相当于把属性纳入了元对象系统,而且给出了一段Q_PROPERTY
更细致的声明,我猜测这个应该是moc
编译后的Q_PROPERTY
真正的声明:
Q_PROPERTY(type name
(READ getFunction [WRITE setFunction] |
MEMBER memberName [(READ getFunction | WRITE setFunction)])
[RESET resetFunction]
[NOTIFY notifySignal]
[REVISION int | REVISION(int[, int])]
[DESIGNABLE bool]
[SCRIPTABLE bool]
[STORED bool]
[USER bool]
[BINDABLE bindableProperty]
[CONSTANT]
[FINAL]
[REQUIRED])
这里就和我们熟悉的属性的定义结构相似了,我们一般将某个变量以Q_PROPERTY
声明为属性以后,会获得setter
和getter
方法,并且能在变量改变时,获得一个信号。以QObject
为例,它将objectName
纳入了元对象系统:
//qobject.h
Q_PROPERTY(QString objectName READ objectName WRITE setObjectName NOTIFY objectNameChanged)
Q_DECLARE_PRIVATE
查看Q_DECLARE_PRIVATE(QObject)
的定义:
//qglobal.h
#define Q_DECLARE_PRIVATE(Class) \
inline Class##Private* d_func() \
{ Q_CAST_IGNORE_ALIGN(return reinterpret_cast<Class##Private *>(qGetPtrHelper(d_ptr));) } \
inline const Class##Private* d_func() const \
{ Q_CAST_IGNORE_ALIGN(return reinterpret_cast<const Class##Private *>(qGetPtrHelper(d_ptr));) } \
friend class Class##Private;
加入参数并翻译过后:
inline QObjectPrivate* d_func()
{ Q_CAST_IGNORE_ALIGN(return reinterpret_cast<QObjectPrivate *>(qGetPtrHelper(d_ptr));) }
inline const QObjectPrivate* d_func() const
{ Q_CAST_IGNORE_ALIGN(return reinterpret_cast<const QObjectPrivate *>(qGetPtrHelper(d_ptr));) }
friend class QObjectPrivate;
首先看qGetPtrHelper()
方法的定义:
//qglobal.h
template <typename Ptr> inline auto qGetPtrHelper(Ptr &ptr) -> decltype(ptr.operator->()) { return ptr.operator->(); }
这是一个模板函数,返回的是指针 ptr
指向的对象。声明里-> decltype(ptr.operator->())
用于推断auto类型。
reinterpret_cast
是类型转换运算符,用于强制类型转换,不进行任何类型检查,仅仅对二进制数据重新解释。
Q_CAST_IGNORE_ALIGN
用于禁用GCC编译器的 -Wcast-align 警告。
那么qGetPtrHelper()
方法的目的是通过调用对象的 operator->()
来获取其指针。
Q_DECLARE_PRIVATE
宏定义了2个函数和1个友元类。2个d_func
只是签名不同,传入参数d_ptr
,都返回一个QObjectPrivate*
类型的指针,而且友元类的名称也是QObjectPrivate
。
d_func
的这种写法涉及到Qt
中的一种设计模式,称为 PIMPL (Pointer to Implementation)
或者d-pointer
。这种模式的目的是将类的实现细节(私有数据和实现函数)从类的接口中分离出来,以达到封装和信息隐藏的目的。这样做的好处显而易见:
更好的扩展性
面向接口编程,如果在不改变类的公共接口的情况下修改了私有实现,那么原有的代码仍然可以运行,不需要重新编译。这对于库的维护和扩展非常有用。
更好的封装
客户端代码不直接访问类的私有数据,这样可以有效隐藏实现的细节,使得类的接口更清晰,同时减小了对客户端代码的影响。
QObjectData和QObjectPrivate
关于变量QScopedPointer<QObjectData> d_ptr
:
QScopedPointer
类是用于存储指向动态分配对象的指针,并在其销毁时删除它,确保指向的对象在当前作用域消失时将被删除。
所以QScopedPointer<QObjectData>
是一个QObjectData的
指针。查看QObjectData
定义:
//qobject.h
class Q_CORE_EXPORT QObjectData {
//防止对象拷贝
Q_DISABLE_COPY(QObjectData)
public:
QObjectData() = default;
virtual ~QObjectData() = 0;
QObject *q_ptr;
QObject *parent;
QObjectList children;
uint isWidget : 1;
uint blockSig : 1;
uint wasDeleted : 1;
uint isDeletingChildren : 1;
uint sendChildEvents : 1;
uint receiveChildEvents : 1;
uint isWindow : 1; //for QWindow
uint deleteLaterCalled : 1;
uint unused : 24;
int postedEvents;
QDynamicMetaObjectData *metaObject;
QMetaObject *dynamicMetaObject() const;
#ifdef QT_DEBUG
enum { CheckForParentChildLoopsWarnDepth = 4096 };
#endif
};
类中定义了很多变量,我们可能熟悉的有parent
、children
、isWidget
等,这里其实将QObject
的变量存放在了QObjectData
中。
QObjectData() = default;
构造函数是默认构造函数,说明什么都不做。
virtual ~QObjectData() = 0;
析构函数是纯虚函数,说明这个类不能创造实例。
上一节我们说到d_func
函数传入参数d_ptr
,返回的QObjectPrivate*
类型的指针,而d_ptr
是QObjectData
,那也就是说QObjectPrivate
是QObjectData
的子类。我们看一看QObjectPrivate
的定义:
//qobject_p.h
class Q_CORE_EXPORT QObjectPrivate : public QObjectData
{
Q_DECLARE_PUBLIC(QObject)
public:
struct ExtraData{
//...
};
//和信号&槽相关
struct ConnectionOrSignalVector{
//...
};
//和信号&槽相关
struct Connection : public ConnectionOrSignalVector{
//...
};
//和信号&槽相关
struct Sender{
//...
};
//和信号&槽相关
struct ConnectionData{
//...
};
QObjectPrivate(int version = QObjectPrivateVersion);
virtual ~QObjectPrivate();
public:
ExtraData *extraData;
QAtomicPointer<QThreadData> threadData;
using ConnectionDataPointer = QExplicitlySharedDataPointer<ConnectionData>;
QAtomicPointer<ConnectionData> connections;
union {
QObject *currentChildBeingDeleted;
QAbstractDeclarativeData *declarativeData;
};
QAtomicPointer<QtSharedPointer::ExternalRefCountData> sharedRefcount;
}
QObjectPrivate
中声明了很多结构体,主要有一些和信号&槽机制相关的结构体,我们后面的文章再讲。
查看Q_DECLARE_PUBLIC(QObject)
定义:
//qglobal.h
#define Q_DECLARE_PUBLIC(Class) \
inline Class* q_func() { return static_cast<Class *>(q_ptr); } \
inline const Class* q_func() const { return static_cast<const Class *>(q_ptr); } \
friend class Class;
翻译过后:
inline QObject* q_func() { return static_cast<QObject *>(q_ptr); }
inline const QObject* q_func() const { return static_cast<const QObject *>(q_ptr); } \
friend class QObject;
这个宏实际上定义了2个签名不一样的函数q_func()
,返回q_ptr
指针,声明了QObject
是友元类。
QObjectPrivate
的构造器定义如下:
//qobject.cpp
QObjectPrivate::QObjectPrivate(int version)
: threadData(nullptr), currentChildBeingDeleted(nullptr)
{
checkForIncompatibleLibraryVersion(version);
// QObjectData initialization
q_ptr = nullptr;
parent = nullptr; // no parent yet. It is set by setParent()
isWidget = false; // assume not a widget object
blockSig = false; // not blocking signals
wasDeleted = false; // double-delete catcher
isDeletingChildren = false; // set by deleteChildren()
sendChildEvents = true; // if we should send ChildAdded and ChildRemoved events to parent
receiveChildEvents = true;
postedEvents = 0;
extraData = nullptr;
metaObject = nullptr;
isWindow = false;
deleteLaterCalled = false;
}
基本上是对继承下来的变量和自身变量进行初始化。
QObject()
当实例化一个继承自QObject
的对象时,首先会调用QObject
的构造器,构造器开始构造对象模型的世界,我们查看QObject
构造函数QObject()
的定义:
//qobject.cpp
QObject::QObject(QObject *parent)
: QObject(*new QObjectPrivate, parent)
{
}
//qobject.cpp
QObject::QObject(QObjectPrivate &dd, QObject *parent)
: d_ptr(&dd)
{
Q_ASSERT_X(this != parent, Q_FUNC_INFO, "Cannot parent a QObject to itself");
Q_D(QObject);
d_ptr->q_ptr = this;
auto threadData = (parent && !parent->thread()) ? parent->d_func()->threadData.loadRelaxed() : QThreadData::current();
threadData->ref();
d->threadData.storeRelaxed(
threadData);
if (parent) {
QT_TRY {
if (!check_parent_thread(parent, parent ? parent->d_func()->threadData.loadRelaxed() : nullptr,
threadData))
parent = nullptr;
if (d->isWidget) {
if (parent) {
d->parent = parent;
d->parent->d_func()->children.append(
this);
}
// no events sent here, this is done at the end of the QWidget constructor
} else {
setParent(parent);
}
} QT_CATCH(...) {
threadData->deref();
QT_RETHROW;
}
}
#if QT_VERSION < 0x60000
qt_addObject(this);
#endif
if (Q_UNLIKELY(qtHookData[QHooks::AddQObject]))
reinterpret_cast<QHooks::AddQObjectCallback>(qtHookData[QHooks::AddQObject])(this);
Q_TRACE(QObject_ctor, this);
}
public
的构造函数实际上是调用了protected
的构造函数。
默认新建了一个QObjectPrivate
并作为构造函数参数传入,赋值给了d_ptr
。结合我们上一节讲的,变量QScopedPointer<QObjectData> d_ptr
利用多态性,在构造函数里实际被赋值为其新建的子实例QObjectPrivate
。
Q_ASSERT_X(this != parent, Q_FUNC_INFO, "Cannot parent a QObject to itself");
断言,如果当前对象正在尝试设置自己为其父对象,就会触发断言失败,并输出相应的消息。这里避免对象设置为其自身的父对象。
接下来Q_D(QObject)
,查看定义:
//qglobal.h
#define Q_D(Class) Class##Private * const d = d_func()
调用d_func()
得到QObjectPrivate*
并赋值给d
,此时d
和d_ptr
都指向前面实例化的QObjectPrivate
。
d_ptr->q_ptr = this;
将QObjectPrivate->q_ptr
设置为自身。
//qobject.cpp
auto threadData = (parent && !parent->thread()) ? parent->d_func()->threadData.loadRelaxed() : QThreadData::current();
threadData->ref();
d->threadData.storeRelaxed(
threadData);
检查 parent
是否非空且它所属的线程是否为空,如果都不空的话,获取parent
的线程数据;否则获取当前的线程数据。将线程数据存储到对象内部的数据结构中。
//qobject.cpp
if (!check_parent_thread(parent, parent ? parent->d_func()->threadData.loadRelaxed() : nullptr,
threadData))
parent = nullptr;
检查parent
和当前对象是否在相同的线程中,如果不在相同线程中,将 parent
设置为 nullptr
。
//qobject.cpp
if (d->isWidget) {
if (parent) {
d->parent = parent;
d->parent->d_func()->children.append(
this);
}
}else{
//...
}
如果对象是一个QWidget
,parent
不空,则建立起对象和parent
的联系,对象的父对象就是parent
,parent
的children
添加该对象。
//qobject.cpp
if (d->isWidget) {
//...
} else {
setParent(parent);
}
如果对象不是QWidget
,通过setParent(parent)
设置父对象。我们看看setParent()
的定义:
//qobject.cpp
void QObject::setParent(QObject *parent)
{
Q_D(QObject);
Q_ASSERT(!d->isWidget);
d->setParent_helper(parent);
}
继续调用d->setParent_helper(parent)
,这个函数解释了不是QWidget
的普通对象是怎么设置parent
的,我们看看定义:
void QObjectPrivate::setParent_helper(QObject *o)
{
Q_Q(QObject);
Q_ASSERT_X(q != o, Q_FUNC_INFO, "Cannot parent a QObject to itself");
#ifdef QT_DEBUG
const auto checkForParentChildLoops = qScopeGuard(
[&](){
int depth = 0;
auto p = parent;
while (p) {
if (++depth == CheckForParentChildLoopsWarnDepth) {
qWarning(
"QObject %p (class: '%s', object name: '%s') may have a loop in its parent-child chain; "
"this is undefined behavior",
q, q->metaObject()->className(), qPrintable(q->objectName()));
}
p = p->parent();
}
});
#endif
if (o == parent)
return;
if (parent) {
QObjectPrivate *parentD = parent->d_func();
if (parentD->isDeletingChildren && wasDeleted
&& parentD->currentChildBeingDeleted == q) {
// don't do anything since QObjectPrivate::deleteChildren() already
// cleared our entry in parentD->children.
} else {
const int index = parentD->children.indexOf(
q);
if (index < 0) {
// we're probably recursing into setParent() from a ChildRemoved event, don't do anything
} else if (parentD->isDeletingChildren) {
parentD->children[index] = 0;
} else {
parentD->children.removeAt(
index);
if (sendChildEvents && parentD->receiveChildEvents) {
QChildEvent e(QEvent::ChildRemoved, q);
QCoreApplication::sendEvent(parent,
&e);
}
}
}
}
parent = o;
if (parent) {
// object hierarchies are constrained to a single thread
if (threadData != parent->d_func()->threadData) {
qWarning(
"QObject::setParent: Cannot set parent, new parent is in a different thread");
parent = nullptr;
return;
}
parent->d_func()->children.append(
q);
if(sendChildEvents && parent->d_func()->receiveChildEvents) {
if (!isWidget) {
QChildEvent e(QEvent::ChildAdded, q);
QCoreApplication::sendEvent(parent,
&e);
}
}
}
if (!wasDeleted && !isDeletingChildren && declarativeData && QAbstractDeclarativeData::parentChanged)
QAbstractDeclarativeData::parentChanged(declarativeData, q, o);
}
首先看Q_Q(QObject)
这个宏的定义:
//qglobal.h
#define Q_Q(Class) Class * const q = q_func()
通过q_func()
获取QObjectPrivate
的q_ptr
,在上面我们知道q_ptr
指向了QObject
,所以q
和q_ptr
都指向QObject
。
Q_ASSERT_X(q != o, Q_FUNC_INFO, "Cannot parent a QObject to itself");
不能将parent
设为对象本身。
#ifdef QT_DEBUG
const auto checkForParentChildLoops = qScopeGuard(
[&](){
int depth = 0;
auto p = parent;
while (p) {
if (++depth == CheckForParentChildLoopsWarnDepth) {
qWarning(
"QObject %p (class: '%s', object name: '%s') may have a loop in its parent-child chain; "
"this is undefined behavior",
q, q->metaObject()->className(), qPrintable(q->objectName()));
}
p = p->parent();
}
});
#endif
这一段通过warning
可以推断出是在检测父子关系链中是否存在循环,如果循环链深度超过阈值,则警告。
if (o == parent)
return;
如果已经设置过parent
且没变,直接返回。
//如果已经有parent
if (parent) {
//获取父对象的QObjectPrivate
QObjectPrivate *parentD = parent->d_func();
//检查父对象是否正在删除其子对象,当前对象是否已经被删除,前对象是否是父对象正在删除的子对象。
//如果这些条件都成立,就跳过后续的处理,因为在删除子对象的过程中已经做了清理工作。
if (parentD->isDeletingChildren && wasDeleted
&& parentD->currentChildBeingDeleted == q) {
// don't do anything since QObjectPrivate::deleteChildren() already
// cleared our entry in parentD->children.
} else {
//获取当前对象在其父对象的子对象列表中的索引
const int index = parentD->children.indexOf(q);
//如果索引为负数,可能表示正在从 ChildRemoved 事件中递归到 setParent(),这时不执行任何操作。
if (index < 0) {
// we're probably recursing into setParent() from a ChildRemoved event, don't do anything
} else if (parentD->isDeletingChildren) {//如果父对象正在删除其子对象,将相应的子对象指针更新为0。
parentD->children[index] = 0;
} else {//否则,从父对象的子对象列表中移除当前对象
parentD->children.removeAt(
index);
//发送一个 ChildRemoved 事件给父对象。
if (sendChildEvents && parentD->receiveChildEvents) {
QChildEvent e(QEvent::ChildRemoved, q);
QCoreApplication::sendEvent(parent,
&e);
}
}
}
}
上面这一段是在已有perent
的情况下,断开parent
和当前对象的联系,并确保在移除子对象时做了适当的清理和事件通知。实际上是为下面刷新parent
做准备。
parent = o;
真正将传入的参数赋值给parent
,相当于更新parent
。
//parent赋值后
if (parent) {
// object hierarchies are constrained to a single thread
// 对象层次结构受限于单个线程
// 比较当前对象的线程数据和父对象的线程数据,如果它们不一致
if (threadData != parent->d_func()->threadData) {
qWarning(
"QObject::setParent: Cannot set parent, new parent is in a different thread");
//父对象置空
parent = nullptr;
//直接返回
return;
}
//将当前对象添加到父对象的子对象列表中。
parent->d_func()->children.append(
q);
if(sendChildEvents && parent->d_func()->receiveChildEvents) {
if (!isWidget) {
//将这个事件发送给父对象
QChildEvent e(QEvent::ChildAdded, q);
QCoreApplication::sendEvent(parent,
&e);
}
}
}
上面这一段是在设置对象的父对象后进行一些检查,确保父对象线程数据和该对象的一致,否则将parent
设为nullptr
,随后发送相应的ChildAdded
事件给parent
。
setParent_helper
函数主要做了两件事:
- 确保旧
parent
安全撤离。 - 确保新
parent
正确设置。
我们可以看到对象层次结构(object hierarchies)中,对象和parent
必须在同一个线程。
到这里QObject
的构造函数QObject()
基本解释完了,简单概括一下构造函数QObject()
的内容:
- 新建
QObjectPrivate
并赋值给d_ptr
。 - 赋值
d_ptr->q_ptr
为对象本身。 - 初始化
threadData
。 - 检查当前对象和
parent
是否在同一线程。 - 为当前对象和
parent
设置关联。
Q_DISABLE_COPY()
查看Q_DISABLE_COPY(QObject)
定义:
//qglobal.h
#define Q_DISABLE_COPY(Class) \
Class(const Class &) = delete;\
Class &operator=(const Class &) = delete;
这里删除了拷贝构造函数和拷贝赋值操作符,确保QObject
不能被拷贝构造或赋值。
值得一提的是,官方文档在描述对象模型(Object Model
)的时候,特意提到了Qt
对象的身份和值(Identity vs Value)。大体意思是,我们需要将Qt
对象视为身份(identities),而不是值(values)。
值通常被复制或赋值。当你复制或赋值一个值时,你得到的是原始值的精确副本。而说到身份,我们说的是克隆,克隆并不意味着创建一个精确的副本,而是一个具有潜在不同特征的新身份。这涉及到特定的标识(如对象名称),位置关系(在对象层次结构中的位置),信号与槽的连接关系,以及在运行时动态添加的属性等等。
因此,QObject
及其所有的子类(无论是直接的还是间接的)都禁用了它们的复制构造函数和赋值运算符。
结尾
最后把出现的签名和头文件简单对应一下,因为我看的时候感觉有点乱。