cobject和cruntimeclass是mfc中两个非常重要的类/结构,绝大部分mfc类都是以cobject做为基类， cruntimeclass结构同cobject密不可分，了解它们对于深入理解mfc具有重要意义。
一、cruntimeclass结构
要理解cobject，我们先来看一下cruntimeclass这个在mfc中至关重要的一个结构。
每个从cobject中派生的类都有有一个cruntimeclass对象同它关联以完成在运行时得到类实例的信息或者是它的基类。 在afx.h中它的定义如下:
struct cruntimeclass
{
// attributes
lpcstr m_lpszclassname; //类名，一般是指包含cruntimeclass对象的类的名称
int m_nobjectsize; //包含cruntimeclass对象的类sizeof的大小，不包括它分配的内存
uint m_wschema; // schema number of the loaded class
cobject* (pascal* m_pfncreateobject)(); // null => abstract class 指向一个建立实例的构造函数

#ifdef _afxdll
cruntimeclass* (pascal* m_pfngetbaseclass)();
#else
cruntimeclass* m_pbaseclass;
#endif

//以上m_pbaseclass的指针(函数)是mfc运行时确定类层次的关键，它一个简单的单向链表

// operations
cobject* createobject(); //这个函数给予cobject 派生类运行时动态建立的能力
bool isderivedfrom(const cruntimeclass* pbaseclass) const;

//这个函数使用 m_pbaseclass或 m_pfngetbaseclass遍历整个类层次确定是否pbaseclass指向的类是基类，
//使用它可以判断某类是否是从pbaseclass指向的类在派生来。

// implementation
void store(carchive& ar) const;
static cruntimeclass* pascal load(carchive& ar, uint* pwschemanum);

// cruntimeclass objects linked together in simple list
cruntimeclass* m_pnextclass; // linked list of registered classes
};

二、cobject类
cobject是mfc类的大多数类的基类，主要是通过它实现：
(1)、运行类信息；(2)、序列化；(3)、对象诊断输出；(4)、同集合类相兼容；
(1)、运行时类信息:
注意：要想使用cruntimeclass结构得到运行时类信息，你必须在你的类中包括declare_dynamic/implement_dynamic、 declare_dyncreate/implement_dyncreate或declare_serial/implement_serial。但你的类必须是从cobject派生的才能使用这些宏， 因为通过declare_dynamic将定义一个实现如下的函数:
cruntimeclass* pascal b::_getbaseclass()
{
return runtime_class(base_name);
}

其中的runtime_class是这样定义的
#define runtime_class( class_name ) \
(cruntimeclass *)(&class_name::class##class_name);

即得到类中的cruntimeclass对象指针，显而易见，如果没有基类你用implement_dynamic时将得到一个编译错误。 除非你象cobject一样不用declare_dynamic而定义和实现了这些函数，cobject中的getbaseclass只是简单的返回null。 实际的declare_dynamic在afx.h中声明如下：
#define declare_dynamic(class_name) \
protected: \
static cruntimeclass* pascal _getbaseclass(); \
public: \
static const afx_data cruntimeclass class##class_name; \
virtual cruntimeclass* getruntimeclass() const; \

implement_dynamic在afx.h中定义如下：
#define implement_dynamic(class_name, base_class_name) \
implement_runtimeclass(class_name, base_class_name, 0xffff, null)

#define implement_runtimeclass(class_name, base_class_name, wschema, pfnnew) \
cruntimeclass* pascal class_name::_getbaseclass() \
{ return runtime_class(base_class_name); } \
afx_comdat const afx_datadef cruntimeclass class_name::class##class_name = { \
#class_name, sizeof(class class_name), wschema, pfnnew, \
&class_name::_getbaseclass, null }; \
cruntimeclass* class_name::getruntimeclass() const \
{ return runtime_class(class_name); } \

其中的cruntimeclass* getruntimeclass() const;被定义为虚函数，以完成在类层次上的重载。 这也是mfc利用多态实现运行时动态类信息的方法。
另外两个declare_dyncreate和declare_serial类似。只不过它们多定义和实现了一些函数，对于使用declare_dyncreate 要注意的是类必须要有一个无参数的缺省构造函数，因为在declare_dyncreate中定义了一个createobject函数 用以在动态的建立对象，它只是一条简单的return new class_name。
我们先来看一下序列化：
，cobject实现这些功能绝大部分是通过它里面的cruntimeclass对象classobject实现的,
cobject不支持多重继承，即表示以cobject为基类的类层次中只能有一个cobject基类。

之所以会这样，就是因为cruntimeclass对象的成员m_pbaseclass的关系。因为它只是一个单链表。
以下是它在afx.h中的定义：
/////////////////////////////////////////////////////////////////////////////
// class cobject is the root of all compliant objects

#ifdef _afxdll
class cobject
#else
class afx_novtable cobject
#endif
{
public:

// object model (types, destruction, allocation)

virtual cruntimeclass* getruntimeclass() const;

// 上面的函数的实现只是很简单的return runtime_class(classobject);

virtual ~cobject(); // virtual destructors are necessary

// diagnostic allocations
void* pascal operator new(size_t nsize);
void* pascal operator new(size_t, void* p);
void pascal operator delete(void* p);
#if _msc_ver >= 1200
void pascal operator delete(void* p, void* pplace);
#endif

#if defined(_debug) && !defined(_afx_no_debug_crt)
// for file name/line number tracking using debug_new
void* pascal operator new(size_t nsize, lpcstr lpszfilename, int nline);
#if _msc_ver >= 1200
void pascal operator delete(void *p, lpcstr lpszfilename, int nline);
#endif
#endif

// disable the copy constructor and assignment by default so you will get
// compiler errors instead of unexpected behaviour if you pass objects
// by value or assign objects.
protected:
cobject();
private:
cobject(const cobject& objectsrc); // no implementation
void operator=(const cobject& objectsrc); // no implementation

// attributes
public:
bool isserializable() const; // 对对象进行序列化
bool iskindof(const cruntimeclass* pclass) const; //判是否是

// overridables
virtual void serialize(carchive& ar);

#if defined(_debug) || defined(_afxdll)
// diagnostic support
virtual void assertvalid() const;
virtual void dump(cdumpcontext& dc) const;
#endif

// implementation
public:
static const afx_data cruntimeclass classcobject;
#ifdef _afxdll
static cruntimeclass* pascal _getbaseclass();
#endif
};

如果你在你的类的实现和定义中使用可选宏的其中一个，你必须了解从cobject派生的好处。
第一级的宏是declare_dynamic/implement_dynamic,它允许你在运行时处理类名和类层次中的位置，允许你做有意义的诊断dump。
第二级的宏是declare_serial/implement_serial,它包括第一级宏所有的功能，允许你进行对象的序列化。

要想彻底了解序列化，不得不了解archive类，我们将在下回详细论述这个类。希望感兴趣的朋友同我联系共同进步。