宏DECLARE_DYNAMIC和IMPLEMENT_DYNAMI

最新推荐文章于 2023-08-09 18:50:20 发布

头头

最新推荐文章于 2023-08-09 18:50:20 发布

阅读量1.2k

点赞数 1

分类专栏： VC 文章标签： class Class dynamic 宏

VC 专栏收录该内容

48 篇文章 0 订阅

订阅专栏

MFC中的RTTI

DECLARE_DYNAMIC和IMPLEMENT_DYNAMIC(用来在运行时，确定你运行时候，需要使用的类,可以先将你可能用到的类绑定到一个 CRunntimeclass对象上面，用的时候，在指定调用的类)
这一对宏能够提供运行是类型判断能力,它允许你在运行时处理类名和类层次中的位置，允许你做有意义的诊断Dump。

DECLARE_DYNAMIC和IMPLEMENT_DYNAMIC必须成对出现，作用是"可以在运行时确定类对象的类型",IMPLEMENT_DYNAMIC的作用是实现这种“确定对象类型”的目的。前者是声明动态识别，后者是动态实现，分别出现在.h文件和.cpp文件中。

这两个宏的主要目的，是在所指定的class（比如CView）的声明和实现里，加上一些静态成员函数和静态成员变量。所以，不要管“/”这个换行标志，就把里面的每一句话当作是在类里的声明或者是实现。

DECLARE_DYNAMIC/IMPLEMENT_DYNAMIC是为了确定运行时对象属于哪一个类而定义的宏。
DEClARE_DYNCREATE/IMPLEMENT_DYNCREATE是为了“动态创建"类的实例而定义的宏。new可以用来创建对象，但不是动态的。比如说，你要在程序中实现根据拥护输入的类名来创建类的实例，下面的做法是通不过的：
char szClassName[60];
cin >> szClassName;
CObject* pOb=new szClassName; //通不过
这里就要用到DEClARE_DYNCREATE/IMPLEMENT_DYNCREATE定义的功能了。

定义：

//
// Helper macros for declaring CRuntimeClass compatible classes

#ifdef _AFXDLL
#define DECLARE_DYNAMIC(class_name) /
protected: /
    static CRuntimeClass* PASCAL _GetBaseClass(); /
public: /
    static const CRuntimeClass class##class_name; /
    static CRuntimeClass* PASCAL GetThisClass(); /
    virtual CRuntimeClass* GetRuntimeClass() const; /

#define _DECLARE_DYNAMIC(class_name) /
protected: /
    static CRuntimeClass* PASCAL _GetBaseClass(); /
public: /
    static CRuntimeClass class##class_name; /
    static CRuntimeClass* PASCAL GetThisClass(); /
    virtual CRuntimeClass* GetRuntimeClass() const; /

#else
#define DECLARE_DYNAMIC(class_name) /
public: /
    static const CRuntimeClass class##class_name; /
    virtual CRuntimeClass* GetRuntimeClass() const; /

#define _DECLARE_DYNAMIC(class_name) /
public: /
    static CRuntimeClass class##class_name; /
    virtual CRuntimeClass* GetRuntimeClass() const; /

#endif

引用：

DECLARE_DYNAMIC/IMPLEMENT_DYNAMIC

#define DECLARE_DYNAMIC(class_name)/
public:/
    static CRuntimeClass class##class_name;/
    //声明一个类型为CRuntimeClass的静态public成员变量，变量名是由字符串"class"
    //与所指定的类的类名组成。举例而言，如果你写DECLARE_DYNAMIC(CMyView)，则等于声明了一个
    // static CRuntimeClass classCMyView静态变量

    virtual CRuntimeClass* GetRuntimeClass() const;/
    //声明一个虚函数，函数名为GetRuntimeClass，返回值为CRuntimeClass类型的指针
    //无参数，并且是个const函数

#define IMPLEMENT_DYNAMIC(class_name,bass_class_name)/
       _IMPLEMENT_RUNTIMECLASS(class_name,base_class_name,0xFFFF,NULL)

#define _IMPLEMENT_RUNTIMECLASS(class_name,base_class_name,wSchema,pfnNew)/
    static char _lpsz##class_name[]= #class_name;/
    //定义一个C类型字符串静态变量，变量名由"_lpsz"和指定类的类名组成，变量值为该指定类型的名字
    //比如是CMyView，那么定义的就是static char _lpszCMyView="CMyView";

    CRuntimeClass class_name::class##class_name = {/
        _lpsz##class_name,sizeof(class_name),wSchema,pfnNew,/
            RUNTIME_CLASS(base_class_name),NULL};/
    //给之前在DECLARE_DYNAMIC里定义的CRuntimeClass类型的静态成员变量赋值
    //当然，除最后一个m_pNextClass没有赋值（赋值为NULL，它由下面的结构处理）

    static AFX_CLASSINIT _init_##class_name(&class_name::class##class_name);/
    //初始化一个名为"_init_##class_name"的AFX_CLASSINIT静态结构，主要作用是给指定的class_name的
    //class##class_name静态变量的最后一个成员m_pNextClass赋值，具体见下面解释AFX_CLASSINIT中

    CRuntimeClass* class_name::GetRuntimeClass() const/
        { return &class_name::class##class_name;}/
    //之前在DECLARE_DYNAMIC里定义的GetRuntimeClass的实现，很简单，就一个return语句。

#define RUNTIME_CLASS(class_name)/
        (&class_name::class##class_name)
//这部分之所以单独define出一个宏，主要是为了方便从某个指定的class直接得到它的CRuntimeclass静态成员

//以下是解释AFX_CLASSINIT结构，注意，这不是一个宏
//为了看得更加清楚，我按照struct定义的惯常格式来写这个struct的定义
struct AFX_CLASSINIT {
    AFX_CLASSINIT(CRuntimeClass *pNewClass);
};

AFX_CLASSINIT::AFX_CLASSINIT(CRuntimeClass *pNewClass)
{
    pNewClass->m_pNextClass = CRuntimeClass::pFirstClass;
    //让m_pNextClass指向pFirstClass所指的CRuntimeClass变量

    CRuntimeClass::pFirstClass = pNewClass;
    //让pFirstClass指向pNewClass所指的变量，也就是本class的CRuntimeClass静态变量
}

#define BOOL int
#define TRUE 1
#define FALSE 0
#define LPCSTR  LPSTR
typedef char*   LPSTR;
#define UINT int
#define PASCAL _stdcall

#include <iostream>
using namespace std;

class CObject;

struct CRuntimeClass
{
// Attributes
        LPCSTR m_lpszClassName;
        int m_nObjectSize;
        UINT m_wSchema; // schema number of the loaded class
        CObject* (PASCAL* m_pfnCreateObject)(); // NULL => abstract class
        CRuntimeClass* m_pBaseClass;

        // CRuntimeClass objects linked together in simple list
        static CRuntimeClass* pFirstClass; // start of class list
        CRuntimeClass* m_pNextClass;       // linked list of registered classes
};

struct AFX_CLASSINIT
        { AFX_CLASSINIT(CRuntimeClass* pNewClass); };

#define RUNTIME_CLASS(class_name) \
        (&class_name::class##class_name)

#define DECLARE_DYNAMIC(class_name) \
public: \
        static CRuntimeClass class##class_name; \
        virtual CRuntimeClass* GetRuntimeClass() const;

#define _IMPLEMENT_RUNTIMECLASS(class_name, base_class_name, wSchema, pfnNew) \
        static char _lpsz##class_name[] = #class_name; \
        CRuntimeClass class_name::class##class_name = { \
                _lpsz##class_name, sizeof(class_name), wSchema, pfnNew, \
                        RUNTIME_CLASS(base_class_name), NULL }; \
        static AFX_CLASSINIT _init_##class_name(&class_name::class##class_name); \
        CRuntimeClass* class_name::GetRuntimeClass() const \
                { return &class_name::class##class_name; } \

#define IMPLEMENT_DYNAMIC(class_name, base_class_name) \
        _IMPLEMENT_RUNTIMECLASS(class_name, base_class_name, 0xFFFF, NULL)

class CObject
{
public:
  CObject::CObject()  {
                      }
  CObject::~CObject() {
                      }
/*public:
   virtual CRuntimeClass* GetRuntimeClass() const;

public:
  static CRuntimeClass classCObject; *

};

class CCmdTarget : public CObject
{
        DECLARE_DYNAMIC(CCmdTarget)
public:
  CCmdTarget::CCmdTarget()  {
                            }
  CCmdTarget::~CCmdTarget() {
                            }
};

class CWinThread : public CCmdTarget
{
        DECLARE_DYNAMIC(CWinThread)
public:
  CWinThread::CWinThread()  {
                            }
  CWinThread::~CWinThread() {
                            }

  virtual BOOL InitInstance() {
                                return TRUE;
                              }
  virtual int Run() {
                      return 1;
                    }
};

class CWnd;

class CWinApp : public CWinThread
{
        DECLARE_DYNAMIC(CWinApp)
public:
  CWinApp* m_pCurrentWinApp;
  CWnd* m_pMainWnd;

public:
  CWinApp::CWinApp()  {
                        m_pCurrentWinApp = this;
                      }
  CWinApp::~CWinApp() {
                      }

  virtual BOOL InitApplication() {
                                   return TRUE;
                                 }
  virtual BOOL InitInstance()    {
                                   return TRUE;
                                 }
  virtual int Run() {
                      return CWinThread::Run();
                    }
};

class CDocument : public CCmdTarget
{
        DECLARE_DYNAMIC(CDocument)
public:
  CDocument::CDocument()   {
                           }
  CDocument::~CDocument()  {
                           }
};

class CWnd : public CCmdTarget
{
        DECLARE_DYNAMIC(CWnd)
public:
  CWnd::CWnd()   {
                 }
  CWnd::~CWnd()  {
                 }

  virtual BOOL Create();
  BOOL CreateEx();
  virtual BOOL PreCreateWindow();
};

class CFrameWnd : public CWnd
{
        DECLARE_DYNAMIC(CFrameWnd)
public:
  CFrameWnd::CFrameWnd()   {
                           }
  CFrameWnd::~CFrameWnd()  {
                           }
  BOOL Create();
  virtual BOOL PreCreateWindow();
};

class CView : public CWnd
{
        DECLARE_DYNAMIC(CView)
public:
  CView::CView()   {
                   }
  CView::~CView()  {
                   }
};

头头

关注

1
点赞
踩
4

收藏

觉得还不错? 一键收藏
0
评论
宏DECLARE_DYNAMIC和IMPLEMENT_DYNAMI

MFC中的RTTIDECLARE_DYNAMIC和IMPLEMENT_DYNAMIC(用来在运行时，确定你运行时候，需要使用的类,可以先将你可能用到的类绑定到一个 CRunntimeclass对象上面，用的时候，在指定调用的类)这一对宏能够提供运行是类型判断能力,它允许你在运行时处理类名和类层次中的位置，允许你做有意义的诊断Dump。DECLARE_DYNAMIC和IMPLEMENT_
复制链接

扫一扫

专栏目录