MFC动态生成（侯捷MFC）

最新推荐文章于 2023-12-25 00:48:08 发布

翻译最新推荐文章于 2023-12-25 00:48:08 发布 · 639 阅读

文章标签：

#mfc

C/C++ 专栏收录该内容

48 篇文章

订阅专栏

MFC动态生成

思路

在RTTI的基础上加上一个函数指针，指向类的静态函数（该函数用于创建一个实例）就可以达到动态生成了。

CRuntimeClass


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;

   CObject* CreateObject();
   static CRuntimeClass* PASCAL Load();

   // 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 DECLARE_DYNCREATE(class_name) \
        DECLARE_DYNAMIC(class_name) \
        static CObject* PASCAL CreateObject();

#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)

#define IMPLEMENT_DYNCREATE(class_name, base_class_name) \
        CObject* PASCAL class_name::CreateObject() \
                { return new class_name; } \
        _IMPLEMENT_RUNTIMECLASS(class_name, base_class_name, 0xFFFF, \
                class_name::CreateObject)

这里写图片描述

mfc.h

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

#include <iostream>
#include <stdio.h>
#include <string.h>
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;

   CObject* CreateObject();
   static CRuntimeClass* PASCAL Load();

   // 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 DECLARE_DYNCREATE(class_name) \
        DECLARE_DYNAMIC(class_name) \
        static CObject* PASCAL CreateObject();

#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)

#define IMPLEMENT_DYNCREATE(class_name, base_class_name) \
        CObject* PASCAL class_name::CreateObject() \
                { return new class_name; } \
        _IMPLEMENT_RUNTIMECLASS(class_name, base_class_name, 0xFFFF, \
                class_name::CreateObject)

class CObject
{
public:
  CObject::CObject()  {
                      }
  CObject::~CObject() {
                      }

  virtual CRuntimeClass* GetRuntimeClass() const;
  BOOL IsKindOf(const CRuntimeClass* pClass) const;

public:
  static CRuntimeClass classCObject;
  virtual void SayHello() { cout << "Hello CObject \n"; }
};

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_DYNCREATE(CWnd)
public:
  CWnd::CWnd()   {
                    cout << "CWnd Constructor \n";
                 }
  CWnd::~CWnd()  {
                 }

  virtual BOOL Create();
  BOOL CreateEx();
  virtual BOOL PreCreateWindow();
  void SayHello() { cout << "Hello CWnd \n"; }
};

class CFrameWnd : public CWnd
{
        DECLARE_DYNCREATE(CFrameWnd)
public:
  CFrameWnd::CFrameWnd()   {
                             cout << "CFrameWnd Constructor \n";
                           }
  CFrameWnd::~CFrameWnd()  {
                           }
  BOOL Create();
  virtual BOOL PreCreateWindow();
  void SayHello() { cout << "Hello CFrameWnd \n"; }
};

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

// global function
CWinApp* AfxGetApp();

mfc.cpp

#include "my.h"  // it should be mfc.h, but for CMyWinApp definition, so...

extern CMyWinApp theApp;
CRuntimeClass* CRuntimeClass::pFirstClass = NULL;

AFX_CLASSINIT::AFX_CLASSINIT(CRuntimeClass* pNewClass)
{
    pNewClass->m_pNextClass = CRuntimeClass::pFirstClass;
    CRuntimeClass::pFirstClass = pNewClass;
}
static char szCObject[] = "CObject";
struct CRuntimeClass CObject::classCObject =
{ szCObject, sizeof(CObject), 0xffff, NULL, NULL, NULL };
static AFX_CLASSINIT _init_CObject(&CObject::classCObject);



CObject* CRuntimeClass::CreateObject()
{
        if (m_pfnCreateObject == NULL)
        {
                TRACE1("Error: Trying to create object which is not DECLARE_DYNCREATE or DECLARE_SERIAL: %s.\n",
                        m_lpszClassName);
                return NULL;
        }

        return (*m_pfnCreateObject)();
}

CRuntimeClass* PASCAL CRuntimeClass::Load()
{
        char szClassName[64];
        CRuntimeClass* pClass;

        cout << "enter a class name:  ";
        cin >> szClassName;

        for (pClass = pFirstClass; pClass != NULL; pClass = pClass->m_pNextClass)
        {
                if (strcmp(szClassName, pClass->m_lpszClassName) == 0)
                        return pClass;
        }

        TRACE1("Error: Class not found: %s \n", szClassName);
        return NULL; // not found
}

CRuntimeClass* CObject::GetRuntimeClass() const
{
        return &CObject::classCObject;
}

BOOL CObject::IsKindOf(const CRuntimeClass* pClass) const
{
        CRuntimeClass* pClassThis = GetRuntimeClass();
        while (pClassThis != NULL)
        {
                if (pClassThis == pClass)
                        return TRUE;
                pClassThis = pClassThis->m_pBaseClass;
        }
        return FALSE;       // walked to the top, no match
}

BOOL CWnd::Create()
{
  return TRUE;
}

BOOL CWnd::CreateEx()
{
  PreCreateWindow();
  return TRUE;
}

BOOL CWnd::PreCreateWindow()
{
  return TRUE;
}

BOOL CFrameWnd::Create()
{
  CreateEx();
  return TRUE;
}

BOOL CFrameWnd::PreCreateWindow()
{
  return TRUE;
}

CWinApp* AfxGetApp()
{
  return theApp.m_pCurrentWinApp;
}

IMPLEMENT_DYNAMIC(CCmdTarget, CObject)
IMPLEMENT_DYNAMIC(CWinThread, CCmdTarget)
IMPLEMENT_DYNAMIC(CWinApp, CWinThread)
IMPLEMENT_DYNAMIC(CDocument, CCmdTarget)
IMPLEMENT_DYNCREATE(CWnd, CCmdTarget)
IMPLEMENT_DYNAMIC(CView, CWnd)
IMPLEMENT_DYNCREATE(CFrameWnd, CWnd)

my.h

#include <iostream>
#include "mfc.h"

class CMyWinApp : public CWinApp
{
public:
  CMyWinApp::CMyWinApp()   {
                           }
  CMyWinApp::~CMyWinApp()  {
                           }

  virtual BOOL InitInstance();
};

class CMyFrameWnd : public CFrameWnd
{
        DECLARE_DYNCREATE(CMyFrameWnd)
public:
  CMyFrameWnd();
  ~CMyFrameWnd()  {
                  }
  void SayHello() { cout << "Hello CMyFrameWnd \n"; }
};

class CMyDoc : public CDocument
{
        DECLARE_DYNCREATE(CMyDoc)
public:
  CMyDoc::CMyDoc()  {
                      cout << "CMyDoc Constructor \n";
                    }
  CMyDoc::~CMyDoc() {
                    }
  void SayHello() { cout << "Hello CMyDoc \n"; }
};

class CMyView : public CView
{
        DECLARE_DYNCREATE(CMyView)
public:
  CMyView::CMyView()   {
                      cout << "CMyView Constructor \n";
                       }
  CMyView::~CMyView()  {
                       }
  void SayHello() { cout << "Hello CMyView \n"; }
};

my.cpp

#include "my.h"

CMyWinApp theApp;

BOOL CMyWinApp::InitInstance()
{
    m_pMainWnd = new CMyFrameWnd;
    return TRUE;
}

CMyFrameWnd::CMyFrameWnd()
{
    cout << "CMyFrameWnd Constructor \n";
    Create();
}

IMPLEMENT_DYNCREATE(CMyFrameWnd, CFrameWnd)
IMPLEMENT_DYNCREATE(CMyDoc, CDocument)
IMPLEMENT_DYNCREATE(CMyView, CView)
//------------------------------------------------------------------
// main
//------------------------------------------------------------------
void main()
{
  CWinApp* pApp = AfxGetApp();

  pApp->InitApplication();
  pApp->InitInstance();
  pApp->Run();

  //Test Dynamic Creation
  CRuntimeClass* pClassRef;
  CObject* pOb;
  while(1)
  {
    if ((pClassRef = CRuntimeClass::Load()) == NULL)
        break;

    pOb = pClassRef->CreateObject();
    if (pOb != NULL)
        pOb->SayHello();
    delete pOb;
  }
}
//------------------------------------------------------------------