【60.MFC基础——单文档界面应用程序】

于 2024-04-12 21:09:41 发布
阅读量2.1k 收藏 50
点赞数 21
分类专栏： c++网络编程学习记录 文章标签： mfc c++
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/zzxsdu12345/article/details/137665072
版权
本文详细介绍了MFC中的基础概念，包括程序架构（如CObject、CWinThread、CWinApp等）、RTTI和CRuntimeClass的使用、消息映射的宏定义及其工作原理，以及文档/视图结构和可串行化类的序列化存储与读取流程。
摘要由CSDN通过智能技术生成

MFC基础——单文档界面应用程序

程序架构

首先创建一个MFC应用程序

在这里插入图片描述

它的类结构如下图（省略了Ex后缀的类）
CObject是所有类的基类，提供了MFC的一些机制，比如RTTI（简单理解为运行期类信息识别）、串行化（简单理解为将应用程序数据持久存储到硬盘或从硬盘读取数据的能力）等
CCmdTarget类，接收命令消息的类的基类
CWinThread是线程类，有一个重要的函数run，用于消息分发
CWinApp是应用程序类，负责管理应用程序的初始化、运行和结束
CWnd类提供窗口的基本功能
接下来是文档/视图结构的组成部分：CFrameWnd为窗口框架，是应用程序顶层窗口，并充当视图的容器；CView提供文档（这里指数据）的可视化；CDocument用来保存数据

在这里插入图片描述

RTTI

CRuntimeClass

RTTI是运行阶段类型识别（Runtime Type Identification）的简称
在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
#ifdef _AFXDLL
	CRuntimeClass* (PASCAL* m_pfnGetBaseClass)();
#else
	CRuntimeClass* m_pBaseClass;//基类
#endif

// Operations
	CObject* CreateObject();
	BOOL IsDerivedFrom(const CRuntimeClass* pBaseClass) const;

	// dynamic name lookup and creation
	static CRuntimeClass* PASCAL FromName(LPCSTR lpszClassName);
	static CRuntimeClass* PASCAL FromName(LPCWSTR lpszClassName);
	static CObject* PASCAL CreateObject(LPCSTR lpszClassName);
	static CObject* PASCAL CreateObject(LPCWSTR lpszClassName);

// 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
	const AFX_CLASSINIT* m_pClassInit;
};

组织成的链表结构如下：
在这里插入图片描述

相关宏

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

#define DECLARE_DYNAMIC(class_name) \
protected: \
	static CRuntimeClass* PASCAL _GetBaseClass(); \
public: \
	static const CRuntimeClass class##class_name; \
	static CRuntimeClass* PASCAL GetThisClass(); \
	__pragma(warning(suppress:26433)) \
	virtual CRuntimeClass* GetRuntimeClass() const; \

//实现
#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, NULL)

#define IMPLEMENT_RUNTIMECLASS(class_name, base_class_name, wSchema, pfnNew, class_init) \
	CRuntimeClass* PASCAL class_name::_GetBaseClass() \
		{ return RUNTIME_CLASS(base_class_name); } \   //#define RUNTIME_CLASS(class_name) (class_name::GetThisClass())
	AFX_COMDAT const CRuntimeClass class_name::class##class_name = { \
		#class_name, sizeof(class class_name), wSchema, pfnNew, \
			&class_name::_GetBaseClass, NULL, class_init }; \
	CRuntimeClass* PASCAL class_name::GetThisClass() \
		{ return _RUNTIME_CLASS(class_name); } \   //#define _RUNTIME_CLASS(class_name) ((CRuntimeClass*)(&class_name::class##class_name))
	CRuntimeClass* class_name::GetRuntimeClass() const \
		{ return _RUNTIME_CLASS(class_name); }



//CMySDIView宏展开
//声明
protected: 
static CRuntimeClass* __stdcall _GetBaseClass(); 
public: 
static const CRuntimeClass classCMySDIView; 
static CRuntimeClass* __stdcall GetThisClass(); 
__pragma(warning(suppress:26433)) 
virtual CRuntimeClass* GetRuntimeClass() const; 
static CObject* __stdcall CreateObject();

//实现
CObject* __stdcall CMySDIView::CreateObject() {
    return new("D:\\VS\\VSrepos\\MySDI\\MySDI\\MySDIView.cpp", 23) CMySDIView;
} //运行期动态生成对象
CRuntimeClass* __stdcall CMySDIView::_GetBaseClass() {
    return (CView::GetThisClass());
} 
__declspec(selectany) const CRuntimeClass CMySDIView::classCMySDIView = { "CMySDIView", sizeof(class CMySDIView), 0xFFFF, CMySDIView::CreateObject, &CMySDIView::_GetBaseClass, 0, 0 }; 
CRuntimeClass* __stdcall CMySDIView::GetThisClass() {
    return ((CRuntimeClass*)(&CMySDIView::classCMySDIView));
} 
CRuntimeClass* CMySDIView::GetRuntimeClass() const {
    return ((CRuntimeClass*)(&CMySDIView::classCMySDIView));
}

消息映射

消息映射是一个将消息和成员函数相互关联的表。消息映射是MFC避免使用冗长的虚表的一种方式

宏

#define DECLARE_MESSAGE_MAP() \
protected: \
	static const AFX_MSGMAP* PASCAL GetThisMessageMap(); \
	const AFX_MSGMAP* GetMessageMap() const override; \

#define BEGIN_MESSAGE_MAP(theClass, baseClass) \
	PTM_WARNING_DISABLE \
	const AFX_MSGMAP* theClass::GetMessageMap() const \
		{ return GetThisMessageMap(); } \
	const AFX_MSGMAP* PASCAL theClass::GetThisMessageMap() \
	{ \
		typedef theClass ThisClass;						   \
		typedef baseClass TheBaseClass;					   \
		__pragma(warning(push))							   \
		__pragma(warning(disable: 4640)) /* message maps can only be called by single threaded message pump */ \
		static const AFX_MSGMAP_ENTRY _messageEntries[] =  \
		{

#define END_MESSAGE_MAP() \
		{0, 0, 0, 0, AfxSig_end, (AFX_PMSG)0 } \
	}; \
		__pragma(warning(pop))	\
		static const AFX_MSGMAP messageMap = \
		{ &TheBaseClass::GetThisMessageMap, &_messageEntries[0] }; \
		return &messageMap; \
	}

//CMySDIView宏展开
protected: 
static const AFX_MSGMAP* __stdcall GetThisMessageMap(); 
const AFX_MSGMAP* GetMessageMap() const override;

//BEGIN_MESSAGE_MAP(CMySDIView, CView)
	//ON_WM_CONTEXTMENU()
	//ON_WM_RBUTTONUP()
//END_MESSAGE_MAP()
const AFX_MSGMAP* CMySDIView::GetMessageMap() const {
    return GetThisMessageMap();
} 
const AFX_MSGMAP* __stdcall CMySDIView::GetThisMessageMap() {
    typedef CMySDIView ThisClass; typedef CView TheBaseClass; 
    static const AFX_MSGMAP_ENTRY _messageEntries[] = {

	{ 0x007B, 0, 0, 0, AfxSig_vWp, (AFX_PMSG)(AFX_PMSGW)(static_cast< void (CWnd::*)	(CWnd*, CPoint) > (&ThisClass::OnContextMenu)) },
	{ 0x0205, 0, 0, 0, AfxSig_vwp, (AFX_PMSG)(AFX_PMSGW)(static_cast< void (CWnd::*)(UINT, CPoint) > (&ThisClass::OnRButtonUp)) },

	{0, 0, 0, 0, AfxSig_end, (AFX_PMSG)0 } }; 
	static const AFX_MSGMAP messageMap = { &TheBaseClass::GetThisMessageMap, &_messageEntries[0] }; 
	return &messageMap; }

消息映射结构体

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_PTR nSig;       // signature type (action) or pointer to message #
	AFX_PMSG pfn;    // routine to call (or special value)
};

struct AFX_MSGMAP
{
	const AFX_MSGMAP* (PASCAL* pfnGetBaseMap)();//父类映射表指针
	const AFX_MSGMAP_ENTRY* lpEntries;
};

消息流动

以CMySDIView::OnRButtonUp为例
在这里插入图片描述
框架调用了从CWnd继承下来的虚拟WindowProc函数。WindowProc 调用OnWndMsg，而OnWndMsg对于标准消息又调用GetMessageMap来获取一个指向 CMySDIView::messageMap的指针，并搜索 CMySDIView::lpEntries来获取一个其消息ID与当前正等待 处理的消息的ID相匹配的条目。如果找到了该条目，对应的CMySDIView 函数（其地址与该消息ID一同存储在lpEntries数组中）就被调用。否则，OnWndMsg参考 CMySDIView::pfnGetBaseMap获得一个指向CView::messageMap的指针并为基类重复该过程。如果 基类没有该消息的处理程序，则框架将上升一个级别，参考基类的基类，相当系统地沿着继承链向上走，直到它找到一个消息处理程序或者将该消息传递给 Windows进行默认处理为止

//部分代码
BOOL CWnd::OnWndMsg(UINT message, WPARAM wParam, LPARAM lParam, LRESULT* pResult)
{
	// special case for commands
	if (message == WM_COMMAND)
	{
		if (OnCommand(wParam, lParam))
		{
			lResult = 1;
			goto LReturnTrue;
		}
		return FALSE;
	}
	// special case for notifies
	if (message == WM_NOTIFY)
	{
		NMHDR* pNMHDR = (NMHDR*)lParam;
		if (pNMHDR->hwndFrom != NULL && OnNotify(wParam, lParam, &lResult))
			goto LReturnTrue;
		return FALSE;
	}
	const AFX_MSGMAP* pMessageMap; pMessageMap = GetMessageMap();
	UINT iHash; iHash = (LOWORD((DWORD_PTR)pMessageMap) ^ message) & (iHashMax-1);
	winMsgLock.Lock(CRIT_WINMSGCACHE);
	AFX_MSG_CACHE* pMsgCache; pMsgCache = &_afxMsgCache[iHash];
	const AFX_MSGMAP_ENTRY* lpEntry;
	if (message == pMsgCache->nMsg && pMessageMap == pMsgCache->pMessageMap)
	{
		// cache hit
		lpEntry = pMsgCache->lpEntry;
		winMsgLock.Unlock();
		if (lpEntry == NULL)
			return FALSE;

		// cache hit, and it needs to be handled
		if (message < 0xC000)
			goto LDispatch;
		else
			goto LDispatchRegistered;
	}
	else
	{
		// not in cache, look for it
		pMsgCache->nMsg = message;
		pMsgCache->pMessageMap = pMessageMap;

		for (/* pMessageMap already init'ed */; pMessageMap->pfnGetBaseMap != NULL;
			pMessageMap = (*pMessageMap->pfnGetBaseMap)())
		{
			// Note: catch not so common but fatal mistake!!
			//      BEGIN_MESSAGE_MAP(CMyWnd, CMyWnd)
			ASSERT(pMessageMap != (*pMessageMap->pfnGetBaseMap)());
			if (message < 0xC000)
			{
				// constant window message
				if ((lpEntry = AfxFindMessageEntry(pMessageMap->lpEntries,
					message, 0, 0)) != NULL)
				{
					pMsgCache->lpEntry = lpEntry;
					winMsgLock.Unlock();
					goto LDispatch;
				}
			}
			else
			{
				// registered windows message
				lpEntry = pMessageMap->lpEntries;
				while ((lpEntry = AfxFindMessageEntry(lpEntry, 0xC000, 0, 0)) != NULL)
				{
					UINT* pnID = (UINT*)(lpEntry->nSig);
					ASSERT(*pnID >= 0xC000 || *pnID == 0);
						// must be successfully registered
					if (*pnID == message)
					{
						pMsgCache->lpEntry = lpEntry;
						winMsgLock.Unlock();
						goto LDispatchRegistered;
					}
					lpEntry++;      // keep looking past this one
				}
			}
		}

		pMsgCache->lpEntry = NULL;
		winMsgLock.Unlock();
		return FALSE;
	}

如果消息类型是WM_COMMAND，消息流动如下

在这里插入图片描述
在CFrameWnd::OnCmdMsg函数中会分三路

BOOL CFrameWnd::OnCmdMsg(UINT nID, int nCode, void* pExtra,
	AFX_CMDHANDLERINFO* pHandlerInfo)
{
	CPushRoutingFrame push(this);

	// pump through current view FIRST
	CView* pView = GetActiveView();
	if (pView != NULL && pView->OnCmdMsg(nID, nCode, pExtra, pHandlerInfo))
		return TRUE;

	// then pump through frame
	if (CWnd::OnCmdMsg(nID, nCode, pExtra, pHandlerInfo))
		return TRUE;

	// last but not least, pump through app
	CWinApp* pApp = AfxGetApp();
	if (pApp != NULL && pApp->OnCmdMsg(nID, nCode, pExtra, pHandlerInfo))
		return TRUE;

	return FALSE;
}

在CView::OnCmdMsg函数中可以看出是先View后Document
在这里插入图片描述
CWnd::OnCmdMsg函数其实调用的是CCmdTarget::OnCmdMsg函数

//部分代码
BOOL CCmdTarget::OnCmdMsg(UINT nID, int nCode, void* pExtra,
	AFX_CMDHANDLERINFO* pHandlerInfo)
{
	// for backward compatibility HIWORD(nCode)==0 is WM_COMMAND
	if (nMsg == 0)
		nMsg = WM_COMMAND;

	// look through message map to see if it applies to us

	for (pMessageMap = GetMessageMap(); pMessageMap->pfnGetBaseMap != NULL;
	  pMessageMap = (*pMessageMap->pfnGetBaseMap)())
	{
		// Note: catches BEGIN_MESSAGE_MAP(CMyClass, CMyClass)!
		ASSERT(pMessageMap != (*pMessageMap->pfnGetBaseMap)());
		lpEntry = AfxFindMessageEntry(pMessageMap->lpEntries, nMsg, nCode, nID);
		if (lpEntry != NULL)
		{
			// found it
			return _AfxDispatchCmdMsg(this, nID, nCode,
				lpEntry->pfn, pExtra, lpEntry->nSig, pHandlerInfo);
		}
	}
	return FALSE;   // not handled
}

CDocument中的函数
在这里插入图片描述
命令消息的调用次序
在这里插入图片描述

文档/视图结构

文档/视图结构是一种将数据与视图分离的程序设计模型，使程序模块化
Document、 View、 Frame三部分由CDocTemplate类管理（单文档视图是其派生类CSingleDocTemplate管理），InitInstance函数中的操作如下

//部分代码
BOOL CMySDIApp::InitInstance()
{
	// 注册应用程序的文档模板。  文档模板
	// 将用作文档、框架窗口和视图之间的连接
	CSingleDocTemplate* pDocTemplate;
	pDocTemplate = new CSingleDocTemplate(
		IDR_MAINFRAME,
		RUNTIME_CLASS(CMySDIDoc),
		RUNTIME_CLASS(CMainFrame),       // 主 SDI 框架窗口
		RUNTIME_CLASS(CMySDIView));
	if (!pDocTemplate)
		return FALSE;
	AddDocTemplate(pDocTemplate);//CDocManager中维护着CDocTemplate的指针链表
	
	
	// 唯一的一个窗口已初始化，因此显示它并对其进行更新
	m_pMainWnd->ShowWindow(SW_SHOW);
	m_pMainWnd->UpdateWindow();
	return TRUE;
}

CDocument有一个成员变量CDocTemplate＊m＿pDocTemplate，回指其DocumentTemplate；另外有一个成员变量CPtrList m＿viewList，表示它可以同时维护一组Views
CFrameWnd有一个成员变量CView＊m＿pViewActive，指向当前活动 的View
CView有一个成员变量CDocument＊m＿pDocument，指向相关的Document

串行化（序列化）

序列化在面向对象的程序设计中出现的，它基于对象是可以连续的思想，在程序退出或者启动的时候，可以把对象顺序的存储在磁盘或者从磁盘读出，存储对象的过程叫做序列化，读出对象的过程叫反序列化

可串行化类

编写可串行化类的步骤：
继承自CObject
头文件中添加DECLARE_SERIAL宏
实现文件中添加 IMPLEMENT SERIAL宏
添加一个缺省构造函数
重写Serialize( CArchive& ar )函数

相关宏

#define DECLARE_SERIAL(class_name) \
	_DECLARE_DYNCREATE(class_name) \
	AFX_API friend CArchive& AFXAPI operator>>(CArchive& ar, class_name* &pOb);

//类名、基类名、模式号（版本号）
#define IMPLEMENT_SERIAL(class_name, base_class_name, wSchema) \
	CObject* PASCAL class_name::CreateObject() \
		{ return new class_name; } \
	extern AFX_CLASSINIT _init_##class_name; \
	_IMPLEMENT_RUNTIMECLASS(class_name, base_class_name, wSchema, \
		class_name::CreateObject, &_init_##class_name) \
	AFX_CLASSINIT _init_##class_name(RUNTIME_CLASS(class_name)); \
	CArchive& AFXAPI operator>>(CArchive& ar, class_name* &pOb) \
		{ pOb = (class_name*) ar.ReadObject(RUNTIME_CLASS(class_name)); \
			return ar; }

示例

#pragma once
#include <afx.h>
class MyClass:public CObject
{
DECLARE_SERIAL(MyClass)     
public:
	MyClass(){}
	MyClass(int i,float j):m_iVal(i),m_fVal(j){}
   virtual void Serialize(CArchive& ar);

public:
   int m_iVal=0;
   float m_fVal=0;

};

#include "MyClass.h"

IMPLEMENT_SERIAL(MyClass, CObject, 1)
//CObject* __stdcall MyClass::CreateObject() {
//    return new MyClass;
//} 
//extern AFX_CLASSINIT _init_MyClass; 
//__declspec(selectany) CRuntimeClass MyClass::classMyClass = { "MyClass", sizeof(class MyClass), 1, MyClass::CreateObject, ((CRuntimeClass*)(&CObject::classCObject)), 0, &_init_MyClass }; 
//CRuntimeClass* MyClass::GetRuntimeClass() const {
//    return ((CRuntimeClass*)(&MyClass::classMyClass));
//} 
//AFX_CLASSINIT _init_MyClass(((CRuntimeClass*)(&MyClass::classMyClass))); 
//CArchive& __stdcall operator>>(CArchive& ar, MyClass*& pOb) {
//    pOb = (MyClass*)ar.ReadObject(((CRuntimeClass*)(&MyClass::classMyClass))); return ar;
}

void MyClass::Serialize(CArchive& ar)
{
    if (ar.IsLoading())
    {
        //从文件中读取数据到内存中
        ar >> m_iVal;
        ar >> m_fVal;
    }
    else if (ar.IsStoring())
    {
        ar << m_iVal;
        ar << m_fVal;
    }
}

编写CMySDIDoc::Serialize函数

void CMySDIDoc::Serialize(CArchive& ar)
{
	if (ar.IsStoring())
	{
		// TODO: 在此添加存储代码
		ar << &myclass;
	}
	else
	{
		// TODO: 在此添加加载代码
		CObject* p;
		ar >> p;
		delete p;
	}
}

存储流程

点击保存后，调用堆栈如下
在这里插入图片描述

//部分代码
#define wNullTag        ((WORD)0)           // special tag indicating NULL ptrs
#define wNewClassTag    ((WORD)0xFFFF)      // special tag indicating new CRuntimeClass
#define wClassTag       ((WORD)0x8000)      // 0x8000 indicates class tag (OR'd)
#define dwBigClassTag   ((DWORD)0x80000000) // 0x8000000 indicates big class tag (OR'd)
#define wBigObjectTag   ((WORD)0x7FFF)      // 0x7FFF indicates DWORD object tag
#define nMaxMapCount    ((DWORD)0x3FFFFFFE) // 0x3FFFFFFE last valid mapCount

void CArchive::WriteObject(const CObject* pOb)
{
	// object can be NULL
	DWORD nObIndex;
	// make sure m_pStoreMap is initialized
	MapObject(NULL);

	if (pOb == NULL)
	
	else if ((nObIndex = (DWORD)(DWORD_PTR)(*m_pStoreMap)[(void*)pOb]) != 0)
	
	else
	{
		// write class of object first
		CRuntimeClass* pClassRef = pOb->GetRuntimeClass();
		WriteClass(pClassRef);//写入tag标记、版本号、类名大小、类名

		// enter in stored object table, checking for overflow
		CheckCount();
		(*m_pStoreMap)[(void*)pOb] = (void*)(DWORD_PTR)m_nMapCount++;

		// cause the object to serialize itself
		((CObject*)pOb)->Serialize(*this);//写入对象数据
	}
}

存储的数据如下
在这里插入图片描述

读取流程

点击打开最近文件
在这里插入图片描述

//部分代码
CObject* CArchive::ReadObject(const CRuntimeClass* pClassRefRequested)
{
	// attempt to load next stream as CRuntimeClass
	UINT nSchema;
	DWORD obTag;
	CRuntimeClass* pClassRef = ReadClass(pClassRefRequested, &nSchema, &obTag);

	// check to see if tag to already loaded object
	CObject* pOb=NULL;
	if (pClassRef == NULL)
	{
		
	}
	else
	{
		TRY
		{
			// allocate a new object based on the class just acquired
			pOb = pClassRef->CreateObject();
		 	if (pOb == NULL)
				AfxThrowMemoryException();

			// Serialize the object with the schema number set in the archive
			UINT nSchemaSave = m_nObjectSchema;
			m_nObjectSchema = nSchema;
			pOb->Serialize(*this);
			m_nObjectSchema = nSchemaSave;
			ASSERT_VALID(pOb);
		}
		
	}

	return pOb;
}

参考文档
MFC Windows程序设计（第2版）——Jeff Prosise
深入浅出MFC 第2版——侯捷

Lycoradia
关注
  • 21
    点赞
  • 踩
  • 50
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
源码：Visual c++ 开发——单文档启动界面
06-24
1.使MFC文档启动时具有图画效果 2.源码：Visual c++ 开发——单文档启动界面
从0开始创建一个MFC单文档工程
youlinhuanyan的博客
04-04 3608
MFC单文档快速入门教程 开发环境 win7+vs2019 如何创建一个新的MFC单文档项目 如何创建菜单添加点击事件 创建菜单我的->测试的菜单 修改测试的菜单ID为ID_MY_TEST如下 为菜单添加事件，选择菜->右键->添加事件处理 添加如下代码 void COcctMFCView::OnMyTest() { // TODO: 在此添加命令处理程序代码 MessageBox((LPCTSTR)"1"); } F5运行一下，点击 我的->测试的菜单，弹出1，
六、MFC文档类（单文档和多文档）
liutit的博客
07-30 2028
CSingleDocTemplate（单文档模板类）（4）创建字符串资源，创建（AFX_IDS_UNTITLED），否则程序无法运行。（3）参与架构的四个类，除了应用程序类，其余单个类均支持动态创建机制。（3）添加菜单项（IDR_MENU1，IDR_MENU2）（4）添加字符串资源（AFX_IDS_UNTITLED）CDocTemplate（文档模板类）CDocTemplate（文档模板类）（3）创建资源（.rc文件）与菜单。（1）创建项目（MFCSdi）（1）创建项目（MFCMdi）......
MFC---单个文档、多个文档和基于对话框的应用程序之间的区别
最新发布
Frank---7的博客
03-13 615
总的来说，单个文档、多个文档和基于对话框的应用程序在设计和用途上有着明显的区别，开发者可以根据应用程序的需求选择合适的架构来实现所需的功能。例如，一个图片查看器就是一个典型的多个文档应用程序，用户可以同时打开多个图片文件，并在单个应用程序窗口中查看它们。每个文档通常是单独的窗口，可以在应用程序的主窗口内部进行管理。例如，一个简单的设置窗口就是一个典型的基于对话框的应用程序，用户可以在对话框中更改应用程序的设置。基于对话框的应用程序通常没有文档和视图的概念，而是直接与用户进行交互并执行相应的操作。
MFC应用程序框架-文档/视结构
GTC的博客
10-25 1900
MFC应用程序框架-文档/视结构1.MFC单文档应用程序结构2.文档对象2.1基类CDocument2.2在应用程序中使用文档类的典型步骤3.视的对象3.1基类CView3.2常用的CView派生类3.3在应用程序中使用视类的典型步骤4.文档和视的联系4.1逻辑关系4.2调用关系4.2.1从文档中获得视4.2.2从视中获得文档5.框架窗口5.1基类 CFrameWnd5.2框架窗口的构造方法6.文档模板6.1基类CDocTemplate6.2文档模板的创建6.3Decument Template 产生三位一
MFC单文档应用程序的基础
weixin_65935351的博客
05-18 6982
MFC单文档应用程序的基础
24 MFC文档串行化和单文档应用程序
weixin_45672157的博客
07-15 3147
在单文档应用程序中，用户可以打开一个文档，对其进行编辑并将其保存。当用户打开同一个文档时，应用程序会将其加载到内存中供用户编辑。用户可以对文档进行各种操作，如添加、删除、修改和移动文档中的内容。单文档应用程序（SDI应用程序）是一种基于文档的应用程序，它允许用户打开、编辑和保存单个文档。这种类型的应用程序通常用于文本编辑器、图像编辑器、绘图工具等。与多文档应用程序（MDI应用程序）不同，单文档应用程序只允许用户同时打开一个文档。这意味着用户必须先关闭当前文档，然后才能打开另一个文档。结论：视图在框架之上。
MFC 单文档模式
PtaQ的博客
07-05 838
【解决方案资源管理器】->【类向导】->【消息】Doc和View两个文件中的数据交互。Doc类利用自带框架存数据。设置Esc的响应函数。
MFC 学习笔记（一）：MFC单文档程序运行流程梳理与总结
Leon_Chen的博客
08-06 1732
MFC 学习笔记（一）：MFC单文档程序运行流程梳理 1.首先利用全局变量对象 theApp 启动应用程序 （这是因为这个全局对象，基类CWinApp中 this 的指针才能指向这个对象。） 2.调用全局应用程序对象 theApp 的构造函数 （需要先调用其基类CWinApp的构造函数， 完成应用程序的一些初始化工作，并将应用程序对象的指针保存起来。） 3.进入WinMain函数 （CWinApp...
【MFC系列】MFC单文档应用程序要点(一)
业精于勤，荒于嬉
05-03 646
那么，当第一个线程到达，信号量为FALSE，线程打开文件进行访问，并将信号量置为TRUE；当人工重置的事件得到通知时，等待该事件的所有线程均变为可调度线程，且在一个线程得到该事件对象后并不会将该对象设置为非信号状态，也就是说人工重置的事件对象，除非显式得调用ResetEvent，否则始终处于有信号状态。可以看出，由于主线程初始化hMutex为有信号状态，所以线程1和线程2刚开始时会发生“争抢”，在hMutex第一次被置为无信号状态的过程中，两个线程的WaitForSingleObject语句同时执行了！
MFC基于单文档的文本文件程序
08-25
刚开始学MFC，用单文档建了一个简单的文本程序，实现的功能有：输入，回车换行，删除功能，还可以用鼠标左键点击变换光标位置。未实现的功能有：超过窗体宽度换行，将鼠标左键点进一串已写好的字符里面再加入字符会出现重叠覆盖的情况。
MFC基础——计算机图形学
12-04
在文档/视图体系中，文档（Document）是应用程序的数据模型，视图（View）是应用程序的用户界面。 绘图的实现 在 MFC 中，绘图是通过继承 CView 类实现的。CView 类提供了基本的绘图功能，我们可以通过继承 ...
MFC 课程设计 ——简易计算器程序设计.doc.doc
06-14
MFC（Microsoft Foundation Classes）是微软提供的一组C++类库，用于简化Windows应用程序的开发。在本课程设计中，我们将利用MFC构建一个简易计算器，该计算器具备基本的数学运算以及一些高级函数如正弦、余弦、正切...
读我.doc————电子版_doc版
09-15
6. **驱动工程属性**：驱动项目的属性界面与常规的MFC或Win32控制台项目有很大区别，特别是存在“NMake”属性项。用户可以通过右键点击工程名打开属性查看具体配置。 7. **my_build命令**：`my_build`批处理文件在...
[IT/计算机]MFC 课程设计 ——简易计算器程序设计.doc
06-14
1.3 基于对话框设计的技术在 MFC 中，基于对话框的应用程序通常用于创建简单的、一次性使用的界面，如设置窗口或配置工具。对话框类 CDialog 包含了一系列控件，如按钮、文本框、编辑框等，这些控件可以通过资源编辑...
mfc入门基础（一）-单文档应用程序框架
Littlehero_121的博客
10-28 2516
学习
MFC 单文档应用程序 CListView 以管理系统为例
m0_72895175的博客
08-09 190
CListView中内置了CListCtrl，所以对CListView的操作实际上就是对内置CListCtrl的操作。为对话框创建类 右击对话框-》添加类（CAddDlg和CModifyDlg）给edit控件添加关联变量 右击对应的文本编辑框-》添加变量。添加两个对话框分别用来添加学生信息，修改学生信息。的ID修改为ID_BTN_MODIFY。修改 ID_EDIT_MODIFY。删除 ID_EDIT_DELETE。的ID修改为ID_BTN_ADD。添加 ID_EDIT_ADD。读取 ID_OP_READ。
MFC单文档应用程序基础训练——文本输出、绘图等
yfhy2014的专栏
01-14 8131
MFC单文档 基础训练——文本输出、绘图等   平台为：VS2010 1.   一个简单的单文档应用程序 文件->新建项目->MFC应用程序 ，出现窗口按“下一步”，出现下面窗口选择单文档   点 "调试—>运行"，最后运行界面为下图：     一个简单的单文档应用程序向导自动建立五个类: 向导自动建立的类 相应源文件 其
基于mfc的单文档应用程序
11-23
MFC（Microsoft Foundation Class）是一套用于开发Windows应用程序的类库，在MFC中可以创建单文档应用程序。单文档应用程序指的是一种只能打开一个文档的应用程序，通常用于编辑文本、图像等内容。 基于MFC的单文档应用程序开发一般包括以下步骤： 首先，在Visual Studio中创建一个新的MFC应用程序项目，选择单文档应用程序模板。这将自动生成一些基本的代码框架，包括主窗口、文档类、视图类等。 接下来，可以根据实际需求对程序进行定制化开发，比如添加菜单栏、工具栏、对话框等用户界面元素，以及编写对文档内容进行管理和操作的相关代码。 在MFC中，文档类负责管理应用程序中的文档数据，视图类则负责显示和用户交互。通过重载文档类和视图类的成员函数，可以实现文档的打开、保存，以及对文档内容的编辑和显示等功能。 另外，MFC提供了丰富的控件库和类库，可以方便地实现各种功能，比如文件操作、绘图、打印等。 在开发完整的单文档应用程序之后，可以进行调试和测试，并最终发布应用程序供用户使用。 总的来说，基于MFC的单文档应用程序开发相对比较简单，而且能够充分利用Windows平台的各种功能和资源，是一种常见的Windows应用程序开发方式。

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值