MFC命令绕行读书笔记

原创 于 2018-09-18 22:37:19 发布 · 309 阅读 · 0 ·
CC 4.0 BY-SA版权
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。

BASETYPE_H

#pragma once
#define TRUE 1
#define FALSE 0
typedef char* LPSTR;
typedef const char* LPCSTR;
typedef unsigned long DWORD;
typedef int BOOL;
typedef unsigned char BYTE;
typedef unsigned short WORD;
typedef int INT;
typedef unsigned int UINT;
typedef long LONG;
typedef int HWND;
typedef UINT WPARAM;
typedef LONG LPARAM;
typedef LONG LRESULT;
#define PASCAL __stdcall

AFXMSG_H

#pragma once
enum AfxSig
{
	AfxSig_end = 0,
	AfxSig_vv//AfxSig_xx用来描述消息处理例程memberFxn的类型（参数与返回值）
};
#define ON_COMMAD(id,memberFxn) \
	{WM_COMMAND,0,(WORD)id,(WORD)id,AfxSig_vv,(AFX_PMSG)memberFxn},

MFC_H

#pragma once


#include <iostream>
#include "BaseType.h"
#include "AfxMsg.h"
#define WM_COMMAND 0x0111
#define WM_CREATE 0x0001
#define WM_PAINT 0x000F
#define WM_NOTIFY 0x004E
#define CObjectid 0xffff
#define CCmdTargetid 1
#define CWinThreadid 11
#define CWinAppid 111
#define CMyWinAppid 1111
#define CWndid 12
#define CFrameWndid 121
#define CMyFrameWndid 1211
#define CViewid 122
#define CMyViewid 1221
#define CDocumentid 13
#define CMyDocid 131

class CObject;
struct CRuntimeClass
{
	LPCSTR m_lpszClassName;
	int m_ObjectSize;
	UINT m_wSchema;
	CObject* (PASCAL* m_pfnCreateObject)();
	CRuntimeClass* m_pBaseClass;

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


	static CRuntimeClass* pFirstClass;
	CRuntimeClass* m_pNextClass;
};
struct AFX_CLASSINIT
{
	AFX_CLASSINIT(CRuntimeClass* pNewClass)
	{
		pNewClass->m_pNextClass = CRuntimeClass::pFirstClass;
		CRuntimeClass::pFirstClass = pNewClass;
	}
};
#define RUNTIME_CLASS(class_name) ((CRuntimeClass*)(&class_name::class##class_name))


/*
eg:
	DECLARE_DYNAMIC(CView)

	public:
		static CRuntimeClass classCView;
		virtual CRuntimeClass* GetRuntimeClass() const;

*/

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

#define DECLARE_DYNCREATE(class_name) \
	DECLARE_DYNAMIC(class_name) \
	static CObject* PASCAL CreateObject();

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


struct AFX_MSGMAP_ENTRY;

struct AFX_MSGMAP
{
	AFX_MSGMAP* pBaseMessageMap;
	AFX_MSGMAP_ENTRY* lpEntries;
};

#define DECLARE_MESSAGE_MAP() \
	static AFX_MSGMAP_ENTRY _messageEntries[]; \
	static AFX_MSGMAP messageMap; \
	virtual AFX_MSGMAP* GetMessageMap() const;



#define BEGIN_MESSAGE_MAP(theClass,baseClass) \
	AFX_MSGMAP* theClass::GetMessageMap() const \
	{return &theClass::messageMap;} \
	AFX_MSGMAP theClass::messageMap = \
	{&(baseClass::messageMap), \
		(AFX_MSGMAP_ENTRY*) &(theClass::_messageEntries)}; \
	AFX_MSGMAP_ENTRY theClass::_messageEntries[] = \
	{

#define END_MESSAGE_MAP() \
	{0,0,0,0,AfxSig_end,(AFX_PMSG)0} \
	};


//#define BEGIN_MESSAGE_MAP(theClass, baseClass) \
//AFX_MSGMAP* theClass::GetMessageMap() const \
// { return &theClass::messageMap; } \
// AFX_MSGMAP theClass::messageMap = \
// { &(baseClass::messageMap), \
// (AFX_MSGMAP_ENTRY*) &(theClass::_messageEntries) }; \
// AFX_MSGMAP_ENTRY theClass::_messageEntries[] = \
// {
//
//#define END_MESSAGE_MAP() \
// { 0, 0, 0, 0, AfxSig_end, (AFX_PMSG)0 } \
// };

class CObject
{
public:
	CObject()
	{
		std::cout << "CObject Constructor" << std::endl;
	}
	~CObject()
	{
		std::cout << "CObject Destructor" << std::endl;
	}
public:
	virtual CRuntimeClass* GetRuntimeClass() const;
	static CRuntimeClass classCObject;
	BOOL IsKindOf(const CRuntimeClass* pClass) const;
};

class CCmdTarget :public CObject
{
	DECLARE_DYNAMIC(CCmdTarget)
public:
	
	CCmdTarget()
	{
		std::cout << "CCmdTarget Constructor" << std::endl;
	}
	~CCmdTarget()
	{
		std::cout << "CCmdTarget Destructor" << std::endl;
	}
	virtual BOOL OnCmdMsg(UINT nID, int nCode);
	DECLARE_MESSAGE_MAP()
};
class CWinThread :public CCmdTarget
{
	DECLARE_DYNAMIC(CWinThread)
public:
	CWinThread()
	{
		std::cout << "CWinThread Constructor" << std::endl;
	}
	~CWinThread()
	{
		std::cout << "CWinThread Destructor" << std::endl;
	}
	virtual BOOL InitInstance()
	{
		std::cout << "CWinThread::InitApplication()" << std::endl;
		return TRUE;
	}
	virtual int Run()
	{
		std::cout << "CWinThread::Run()" << std::endl;
		return 1;
	}
};
typedef void (CCmdTarget::*AFX_PMSG)(void);
struct AFX_MSGMAP_ENTRY
{
	UINT nMessage;// windows message
	UINT nCode;// control code or WM_NOTIFY code
	UINT nID;// control ID (or 0 for windows messages)
	UINT nLastID;// used for entries specifying a range of control id's
	UINT nSig;// signature type (action) or pointer to message #
	AFX_PMSG pfn;// routine to call (or special value)
};


class CWnd;
class CWinApp :public CWinThread
{
	DECLARE_DYNAMIC(CWinApp)
public:
	CWinApp* m_pCurrentWinApp;
	CWnd* m_pMainWnd;
public:
	CWinApp() :m_pCurrentWinApp(this)
	{
		std::cout << "CWinApp Constructor" << std::endl;

	}
	~CWinApp()
	{
		std::cout << "CWinApp Destructor" << std::endl;

	}
	virtual BOOL InitApplication() 
	{
		std::cout << "CWinApp::InitApplication()" << std::endl;
		return TRUE;
	}
	virtual BOOL InitInstance()
	{
		std::cout << "CWinApp::InitInstance()" << std::endl;
		return TRUE;
	}
	virtual int Run() 
	{
		std::cout << "CWinApp::Run()" << std::endl;
		return CWinThread::Run();
	}
	DECLARE_MESSAGE_MAP()
};

class CDocument :public CCmdTarget
{
	DECLARE_DYNAMIC(CDocument)
public:
	CDocument()
	{
		std::cout << "CDocument Constructor" << std::endl;

	}
	~CDocument()
	{
		std::cout << "CDocument Destructor" << std::endl;

	}
	virtual BOOL OnCmdMsg(UINT nID, int nCode);
	DECLARE_MESSAGE_MAP()
};

class CWnd :public CCmdTarget
{
	DECLARE_DYNCREATE(CWnd)
public:
	CWnd()
	{
		std::cout << "CWnd Constructor" << std::endl;

	}
	~CWnd()
	{
		std::cout << "CWnd Destructor" << std::endl;

	}
	virtual BOOL Create();
	BOOL CreateEx();
	virtual BOOL PreCreateWindow();
	/*判断消息是否为WM_COMMAND。如果不是就把消息往父类推去，父类
	别再往祖父类别推去。每到一个类别的消息映射表，比对AFX_MSGMAP_ENTRY的每一个元素
	比对成功就调用对应的处理例程*/
	virtual LRESULT WindowProc(UINT message, WPARAM wParam, LPARAM lParam);
	virtual LRESULT DefWindowProc(UINT message, WPARAM wParam, LPARAM lParam);
	virtual BOOL OnCommand(WPARAM wParam, LPARAM lParam);
	DECLARE_MESSAGE_MAP()
};

class CView;
class CFrameWnd :public CWnd
{
	DECLARE_DYNCREATE(CFrameWnd)
public:
	CView* m_pViewActive;
public:
	CFrameWnd()
	{
		std::cout << "CFrameWnd Constructor" << std::endl;

	}
	~CFrameWnd()
	{
		std::cout << "CFrameWnd Destructor" << std::endl;

	}
	BOOL Create();
	CView* GetActiveView() const;
	virtual  BOOL PreCreateWindow();
	virtual BOOL OnCommand(WPARAM wParam, LPARAM lParam);
	virtual BOOL OnCmdMsg(UINT nID, int nCode);
	DECLARE_MESSAGE_MAP()
};

class CView :public CWnd
{
	DECLARE_DYNAMIC(CView)
public:
	CDocument* m_pDocument;
public:
	CView()
	{
		std::cout << "CView Constructor" << std::endl;

	}
	~CView()
	{
		std::cout << "CView Destructor" << std::endl;

	}
	virtual BOOL OnCmdMsg(UINT nID, int nCode);
	DECLARE_MESSAGE_MAP()
};

CWinApp* AfxGetApp();
LRESULT AfxCallWndProc(CWnd* pWnd, HWND hWnd, UINT nMSg, WPARAM wParam, LPARAM lParam);

LRESULT AfxWndProc(HWND hWnd, UINT nMSg, WPARAM wParam, LPARAM lParam, CWnd *pWnd);

MFC_CPP

#include "stdafx.h"
#include "MY.h"
extern CMyWinApp theApp;


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

BEGIN_MESSAGE_MAP(CWnd, CCmdTarget)
	ON_COMMAD(CWndid, 0)
END_MESSAGE_MAP()

BEGIN_MESSAGE_MAP(CFrameWnd, CWnd)
	ON_COMMAD(CFrameWndid, 0)
END_MESSAGE_MAP()

BEGIN_MESSAGE_MAP(CDocument, CCmdTarget)
	ON_COMMAD(CDocumentid, 0)
END_MESSAGE_MAP()

BEGIN_MESSAGE_MAP(CView, CWnd)
	ON_COMMAD(CViewid, 0)
END_MESSAGE_MAP()

BEGIN_MESSAGE_MAP(CWinApp, CCmdTarget)
	ON_COMMAD(CWinAppid, 0)
END_MESSAGE_MAP()

CRuntimeClass* CRuntimeClass::pFirstClass = nullptr;

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

CRuntimeClass * CRuntimeClass::Load()
{
	char szClassName[64] = { 0 };
	CRuntimeClass* pClass = nullptr;
	std::cout << "enter a class name..." << std::endl;
	std::cin >> szClassName;
	for (pClass = pFirstClass; pClass != nullptr; pClass = pClass->m_pNextClass)
	{
		if (strcmp(szClassName, pClass->m_lpszClassName) == 0)
		{
			return pClass;
		}
	}
	return nullptr;
}
/********************CObject********************/
CRuntimeClass* CObject::GetRuntimeClass() const
{
	return &CObject::classCObject;
}

BOOL CObject::IsKindOf(const CRuntimeClass * pClass) const
{
	CRuntimeClass* pClassThis = GetRuntimeClass();
	while (pClassThis!=nullptr)
	{
		if (pClassThis == pClass)
			return TRUE;
		pClassThis = pClassThis->m_pBaseClass;
	}
	return FALSE;
}




CObject * CRuntimeClass::CreateObject()
{
	if (nullptr == m_pfnCreateObject)
	{
		return nullptr;
	}
	return (m_pfnCreateObject());
}
/********************CObject********************/

/********************CCmdTarget********************/
AFX_MSGMAP* CCmdTarget::GetMessageMap() const
{
	return &CCmdTarget::messageMap;
}
AFX_MSGMAP CCmdTarget::messageMap =
{
	nullptr,
	&CCmdTarget::_messageEntries[0]
};
AFX_MSGMAP_ENTRY CCmdTarget::_messageEntries[] =
{
	{0,0,CCmdTargetid,0,AfxSig_end,0}
};
BOOL CCmdTarget::OnCmdMsg(UINT nID, int nCode)
{
	std::cout << "CCmdTarget::OnCmdMsg()" << std::endl;
	AFX_MSGMAP* pMessageMap = nullptr;
	AFX_MSGMAP_ENTRY* lpEntry = nullptr;
	for (pMessageMap = GetMessageMap(); pMessageMap != nullptr; pMessageMap = pMessageMap->pBaseMessageMap)
	{
		lpEntry = pMessageMap->lpEntries;
		printlpEntries(lpEntry);
	}
	return FALSE;
}
/********************CCmdTarget********************/

/********************CWnd********************/
BOOL CWnd::Create()
{
	std::cout << "CWnd::Create()" << std::endl;
	return TRUE;
}
BOOL CWnd::CreateEx()
{
	std::cout << "CWnd::CreateEx()" << std::endl;
	PreCreateWindow();
	return TRUE;
}
BOOL CWnd::PreCreateWindow()
{
	std::cout << "CWnd::PreCreateWindow()" << std::endl;
	return TRUE;
}
LRESULT CWnd::WindowProc(UINT message, WPARAM wParam, LPARAM lParam)
{
	AFX_MSGMAP* pMessageMap = nullptr;
	AFX_MSGMAP_ENTRY* lpEntry = nullptr;
	if (WM_COMMAND == message)
	{
		if (OnCommand(wParam, lParam))
			return 1L;
		else
		{
			return (LRESULT)DefWindowProc(message, wParam, lParam);
		}
	}
	pMessageMap = GetMessageMap();
	for (; pMessageMap != nullptr; pMessageMap = pMessageMap->pBaseMessageMap)
	{
		lpEntry = pMessageMap->lpEntries;
		printlpEntries(lpEntry);
	}
	return 0;
}
LRESULT CWnd::DefWindowProc(UINT message, WPARAM wParam, LPARAM lParam)
{
	return TRUE;
}
BOOL CWnd::OnCommand(WPARAM wParam, LPARAM lParam)
{
	return OnCmdMsg(0, 0);
}
/********************CWnd********************/

/********************CFrameWnd********************/
BOOL CFrameWnd::OnCommand(WPARAM wParam, LPARAM lParam)
{
	std::cout << "OnCommand" << std::endl;
	return CWnd::OnCommand(wParam, lParam);
}
BOOL CFrameWnd::Create()
{
	std::cout << "CFrameWnd::Create()" << std::endl;
	CreateEx();
	return TRUE;
}
BOOL CFrameWnd::PreCreateWindow()
{
	std::cout << "CFrameWnd::PreCreateWindow()" << std::endl;
	return TRUE;
}
CView* CFrameWnd::GetActiveView() const
{
	return m_pViewActive;
}
BOOL CFrameWnd::OnCmdMsg(UINT nID, int nCode)
{
	std::cout << "CFrameWnd::OnCmdMsg()" << std::endl;
	CView* pView = GetActiveView();
	if (pView->OnCmdMsg(nID, nCode))
		return TRUE;
	if (CWnd::OnCmdMsg(nID, nCode))
		return TRUE;
	CWinApp* pApp = AfxGetApp();
	if (pApp->OnCmdMsg(nID, nCode))
		return TRUE;
	return FALSE;
}
/********************CFrameWnd********************/

/********************CView********************/
BOOL CView::OnCmdMsg(UINT nID, int nCode)
{
	std::cout << "CView::OnCmdMsg()" << std::endl;
	if (CWnd::OnCmdMsg(nID, nCode))
		return TRUE;
	BOOL bHandled = FALSE;
	bHandled = m_pDocument->OnCmdMsg(nID, nCode);
	return bHandled;
}
/********************CDocument********************/
BOOL CDocument::OnCmdMsg(UINT nID, int nCode)
{
	std::cout << "CDocument::OnCmdMsg()" << std::endl;
	if (CCmdTarget::OnCmdMsg(nID, nCode))
		return TRUE;
	return FALSE;
}
/********************CDocument********************/

CWinApp * AfxGetApp()
{
	return theApp.m_pCurrentWinApp;
}
LRESULT AfxWndProc(HWND hWnd, UINT nMSg, WPARAM wParam, LPARAM lParam, CWnd *pWnd)
{
	std::cout << "AfxWndProc" << std::endl;
	return AfxCallWndProc(pWnd, hWnd, nMSg, wParam, lParam);
}
LRESULT AfxCallWndProc(CWnd* pWnd, HWND hWnd, UINT nMSg, WPARAM wParam, LPARAM lParam)
{
	std::cout << "AfxCallWndProc" << std::endl;
	LRESULT lResult = pWnd->WindowProc(nMSg, wParam, lParam);
	return lResult;
	
}

MY_H

#pragma once
#include "MFC.h"
class CMyFrameWnd :public CFrameWnd
{
	DECLARE_DYNCREATE(CMyFrameWnd)
public:
	CMyFrameWnd()
	{
		std::cout << "CMyFrameWnd Constructor" << std::endl;
		Create();
	}
	~CMyFrameWnd()
	{
		std::cout << "CMyFrameWnd Destructor" << std::endl;

	}
	DECLARE_MESSAGE_MAP()
};
class CMyWinApp :public CWinApp
{
	DECLARE_DYNCREATE(CMyWinApp)
public:
	CMyWinApp()
	{
		std::cout << "CMyWinApp Constructor" << std::endl;

	}
	~CMyWinApp()
	{
		std::cout << "CMyWinApp Destructor" << std::endl;

	}
	virtual BOOL InitInstance() 
	{
		std::cout << "CMyWinApp::Create()" << std::endl;
		m_pMainWnd = new CMyFrameWnd;
		return TRUE;
	}
	DECLARE_MESSAGE_MAP()
};
class CMyDoc :public CDocument
{
public:
	CMyDoc() {}
	~CMyDoc() {}
	DECLARE_MESSAGE_MAP()
};
class CMyView:public CView
{
public:
	CMyView() {}
	~CMyView() {}
	DECLARE_MESSAGE_MAP()
};
void printlpEntries(AFX_MSGMAP_ENTRY* lpEntry);
void MsgMapPrinting(AFX_MSGMAP* pMessageMap);

MY_CPP

#include "stdafx.h"
#include "MY.h"
CMyWinApp theApp;


IMPLEMENT_DYNCREATE(CMyFrameWnd,CFrameWnd)
IMPLEMENT_DYNCREATE(CMyWinApp, CWinApp)

BEGIN_MESSAGE_MAP(CMyWinApp,CWinApp)
	ON_COMMAD(CMyWinAppid,0)
END_MESSAGE_MAP()

BEGIN_MESSAGE_MAP(CMyFrameWnd, CFrameWnd)
	ON_COMMAD(CMyFrameWndid, 0)
END_MESSAGE_MAP()

BEGIN_MESSAGE_MAP(CMyView, CView)
	ON_COMMAD(CMyViewid, 0)
END_MESSAGE_MAP()

BEGIN_MESSAGE_MAP(CMyDoc, CDocument)
	ON_COMMAD(CMyDocid, 0)
END_MESSAGE_MAP()
//BOOL CMyWinApp::InitInstance()
//{
//	return 0;
//}

void printlpEntries(AFX_MSGMAP_ENTRY* lpEntry)
{
	struct  
	{
		int classid;
		char* classname;
	}classinfo[]=
	{
		CCmdTargetid,"CCmdTarget",
		CWinThreadid,"CWinThread",
		CWinAppid,"CWinApp",
		CMyWinAppid,"CMyWinApp",
		CWndid,"CWnd",
		CFrameWndid,"CFrameWnd",
		CMyFrameWndid,"CMyFrameWnd",
		CViewid,"CView",
		CDocumentid,"CDocument",
		0," "
	};
	for (unsigned i = 0; classinfo[i].classid != 0; ++i)
	{
		if (classinfo[i].classid == lpEntry->nID)
		{
			std::cout << lpEntry->nID << " ";
			std::cout << classinfo[i].classname << std::endl;
			break;
		}
	}
}
void MsgMapPrinting(AFX_MSGMAP* pMessageMap)
{
	for (; pMessageMap != nullptr; pMessageMap = pMessageMap->pBaseMessageMap)
	{
		AFX_MSGMAP_ENTRY* lpEntry = pMessageMap->lpEntries;
		printlpEntries(lpEntry);
	}
}

MFC_Simulat.cpp

// MFC_Simulat.cpp : 定义控制台应用程序的入口点。
//

#include "stdafx.h"

#include "MY.h"
using namespace std;
/*main 函数调用全域函数AfxGetApp 以取得theApp 的对象指针*/
int main()
{
	CWinApp* pApp = AfxGetApp();
	CRuntimeClass* prun = &CObject::classCObject;
	pApp->InitApplication();
	pApp->InitInstance();
	pApp->Run();
	CMyDoc* pMyDoc = new CMyDoc;
	CMyView* pMyView = new CMyView;
	CFrameWnd* pMyFrame = (CFrameWnd*)pApp->m_pMainWnd;
	
	cout << endl << "pMyFrame received a WM_CREATE, routing path :" << endl;
	AfxWndProc(0, WM_CREATE, 0, 0, pMyFrame);
	/*cout << endl << "pMyView received a WM_PAINT, routing path :" << endl;
	AfxWndProc(0, WM_PAINT, 0, 0, pMyView);
	cout << endl << "pMyView received a WM_COMMAND, routing path :" << endl;
	AfxWndProc(0, WM_COMMAND, 0, 0, pMyView);
	cout << endl << "pMyFrame received a WM_COMMAND, routing path :" << endl;
	AfxWndProc(0, WM_COMMAND, 0, 0, pMyFrame);*/
	getchar();
    return 0;
}

解读图

 

 

kingbrown1234
关注
深入浅出MFC：MFC中的的RTTI实现
qq_30168505的博客
09-29 1872
在了解了MFC的基本运行的流程之后，让我们再来看看一个特殊的问题：如何在运行的过程中动态地保存一个对象的类型信息并判断得到其类型 虽然在很早之前，C++就已经原生的实现了RTTI特性，只需要通过使程序包含该头文件 ,然后使用typeid 运算符即可直接获取对象的类型，但是对于更早出现的MFC，一开始没有RTTI，所以MFC只好自身内部实现了一套“运行时自动类型识别的机制”。 对于RTTI的实现
MFC：MFC六大核心机制之—运行时类型识别RTTI
最新发布
qq_42279379的博客
07-31 568
MFC六大核心机制之—运行时类型识别RTTI：1.介绍了RTTI；2.为什么RTTI能成为MFC的六大核心机制之一；3.MFC是如何实现RTTI机制的；4.两个重要的宏宏DECLARE_DYNAMIC和宏IMPLEMENT_DYNAMIC
MFC运行时类型识别(MFC RTTI)与动态创建.doc
04-24
MFC运行时类型识别(MFC RTTI)与动态创建.doc
MFC六大核心机制之二：运行时类型识别（RTTI）
周小宇的专栏
12-06 828
上一节讲的是MFC六大核心机制之一：MFC程序的初始化，本节继续讲解MFC六大核心机制之二：运行时类型识别（RTTI）。        typeid运算子        运行时类型识别（RTTI）即是程序执行过程中知道某个对象属于某个类，我们平时用C++编程接触的RTTI一般是编译器的RTTI，即是在新版本的VC++编译器里面选用“使能RTTI”，然后载入typeinfo.h文件，就可
MFC中的运行时类型识别(RTTI)
sanqima的专栏
01-01 1223
RTTI是Runtime Type Identification的缩写，中文名为“运行时类型识别”。       MFC早在编译器支持RTTI之前，就有了这种能力。我们现在要以相同的手法，在Console程序中仿真出来。我希望我的类库具备IsKindOf 的能力，能在执行期侦测到某个对象是否属于某个类，并传回TRUE 或 FALSE。以形状 Shape为例 ，我希望：     即 长方
深入浅出MFC读书笔记3
08-28
深入浅出MFC读书笔记3 在MFC中，Document-View架构是一个非常重要的概念。本文将对Document-View架构中的关键组件进行深入探讨，并对其实现思路进行详细的解析。 首先，让我们来看一下Document的概念。在MFC中，...
深入浅出MFC读书笔记2
08-28
深入浅出MFC读书笔记2是对MFC框架的进一步学习和理解，主要涵盖了MFC的基础概念、类库结构以及程序构建的关键要素。MFC（Microsoft Foundation Classes）是微软为Windows平台开发的应用程序提供的一种类库，它基于...
MFC笔记 MFC笔记 MFC笔记 MFC笔记 MFC笔记 MFC笔记
04-20
从给定的信息中，我们可以提炼出关于MFC（Microsoft Foundation Classes）的重要知识点，以及与之相关的C++编程、Visual Studio环境设置、Windows API使用、内存管理等关键概念。以下是对这些知识点的详细解释： ##...
VC++ MFC绘图类实战笔记源代码
03-15
摘要:VC/C++源码,系统相关,MFC,绘图　1 添加数据类 　CShapeBase 　2 添加绘制图形的命令 　3 添加线色/填充色的命令 　4 鼠标支持 　5 多个图的支持 　6 选择 　7 橡皮条绘图 　int nOld = dc.SetROP2( R2_...
《MFC游戏开发》笔记三 透明贴图 配套源代码
07-17
在本文中，我们将深入探讨《MFC游戏开发》笔记三中的关键知识点——透明贴图技术。MFC（Microsoft Foundation Classes）是微软提供的一种C++库，用于构建Windows应用程序，包括游戏开发。透明贴图是游戏图形编程中...
MFC六大关键技术之运行时类型识别
un_loading的专栏
09-27 712
        运行时类型识别（RTTI）(Run-Time Type Identification)即是程序执行过程中知道某个对象属于某个类，我们平时用C++编程接触的RTTI一般是编译器的RTTI，即是在新版本的VC++编译器里面选用“使能RTTI”，然后载入typeinfo.h文件，就可以使用一个叫typeid（）的运算子，它的地位与在C++编程中的sizeof()运算子类似的地方（
MFC中的运行时类型识别(第二篇)
sanqima的专栏
01-01 1408
按照Frame3中的图（3-1）“类别型录”网，要实现 IsKindOf功能，再轻松不过了。  1）为CObject 加上一个 IsKindOf 函数，于是此函数将被所有类继承。它将把参数所指定的某个 CRuntimeClass对象拿来与类别型录中的元素一一比较。如果比较成功（即在类别型录里有存在），就传回TRUE；否则，传回FALSE。    // in header file c
MFC中的RTTI(Runtime Type Identification, 运行时类型识别)详解(参考《深入浅出MFC》)
热门推荐
杨领well的专栏
07-23 4万+
在MFC中的RTTI的实现，主要是利用一个名为CRuntimeClass的结构来链接各个“有关系的类”的信息来实现的。简单来说，就是在需要用到RTTI技术的类内建立CRuntimeClass的静态变量，来储存该类的相关信息(包括类名、基类的CRuntimeClass结构的指针、让“有关系的类”的信息形成链表的next指针、以及链表的首指针(静态)等信息)。
MFC的RTTI实现机制！
quasiceo
09-06 484
MFC的RTTI实现机制！       怎么设计RTTI呢？让我们想想，当你看到一种颜色，想知道的它的RGB成分比，不查色表行吗？当你持有一种产品，想知道它的型号，不查型录行吗？要到达RTTI的能力，我们（类库的设计者）一定要在类 构建 起来的时候，记录必要的信息，以建立型录。型录中的类信息，最好以链表方式连接起来，将来方便一一比较。       我们这份“类别型录”的 链表元素 将以CRun
MFC 六大机制 (2) RTTI(运行时类型识别)
?.?的专栏
06-20 4257
RTTI(Runtime Type Identification，运行时类型识别) 程序能够使用基类的指针或引用来检查这些指针或引用所指的对象的实际派生类型。MFC 早在编译器支持 RTTI 之前，就具有了这项能力。承接上一章，我们现在要在 Console 程序中将 RTTI 仿真出来。我希望我的类库具备 IsKindOf() 的能力，能够在执行器检查某个对象是否"属于某种类"，并传回 TRUE 或 FALSE。
命令绕行（侯捷MFC）
李习的博客
07-31 384
命令绕行 思路 应用程序类（含有指向应用程序的指针，指向窗口类的指针）； 文档类； 窗口类（含有指向视图类的指针）； 视图类（含有指向文档类的指针）。 普通WM_开头的消息有消息映射从子类到父类流串，但是对于命令消息，他的流串不仅仅是子类到父类，还有横向的（这里虚函数和上面类的指针起到了决定性的作用） -视图接收到命令消息的处理： CView-&gt;CCmdTarget然...
MFC的RTTI实现
CSDN_LBW的专栏
03-09 412
http://www.cnblogs.com/dsky/archive/2012/05/28/2520968.html   C++设计者在C++使用的早期并没有意识到RTTI（运行时类型检查）的重要性，后来随作框架结构的类库出现及其应用越来越广泛，RTTI就变得越来越重要了。例如下面的这个语句： 　　CWnd *pWnd； 任何人都知道对象pWnd是CWnd类型的指针。但是如果有一个类
MFC－RTTI
colin
12-15 4398
关于RTTI       正如侯杰所说，文档视图是MFC进化为应用程序框架的灵魂，不可否认，这是MFC最为精炒的设计，十多年前数据与表现分离的思想就被应用在这个框架之上。而在文档视图之下，支撑着它的是运行时类型信息(RTTI)。       RTTI允许程序在运行时刻获得类乃至普通类型的信息，这是怎么做到的，其实原理很简单，就是事先将这些信息保存为某种数据结构，保存的工作或由编译器帮你
MFC学习笔记：VS2008安装与定时器功能解析
"MFC学习笔记2.0.pdf - MFC学习过程中的问题和疑难点总结" 这篇MFC学习笔记主要涵盖了作者在学习C++及MFC框架时遇到的问题和解决方案，特别关注了定时器功能的使用。MFC，即Microsoft Foundation Classes，是微软...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值