尽管MFC（Microsoft Foundation Classes）常被视为"过时"的遗留技术，但其设计思想对理解Windows编程本质和框架设计哲学仍具重要价值。作为一套经典的C++框架，MFC成功将过程式的Win32 API封装为面向对象的类库，其消息映射机制和文档/视图架构体现了早期框架设计者对软件复杂性的深刻思考。本文旨在系统性剖析MFC的核心架构，为开发者提供一个结构化的认知框架。
第一章：MFC的消息映射机制------Windows事件驱动的革命性封装
一、Win32 SDK的原始困境：集中式消息处理的复杂性
在深入理解MFC的消息映射之前，必须首先审视传统Win32 SDK编程的消息处理模式。这种模式的核心是一个集中式的窗口过程函数（Window Procedure，简称WndProc），它接收并处理发送到窗口的所有消息。
典型的Win32 SDK消息处理代码如下所示：
cpp
LRESULT CALLBACK WndProc(HWND hWnd, UINT message, WPARAM wParam, LPARAM lParam)
{
switch (message)
{
case WM_PAINT:
{
PAINTSTRUCT ps;
HDC hdc = BeginPaint(hWnd, &ps);
// 绘图代码...
EndPaint(hWnd, &ps);
}
break;
case WM_MOUSEMOVE:
{
int xPos = LOWORD(lParam);
int yPos = HIWORD(lParam);
// 处理鼠标移动...
}
break;
case WM_COMMAND:
{
int wmId = LOWORD(wParam);
switch (wmId)
{
case IDM_FILE_OPEN:
// 处理文件打开...
break;
case IDM_FILE_SAVE:
// 处理文件保存...
break;
// 更多菜单项...
}
}
break;
case WM_DESTROY:
PostQuitMessage(0);
break;
default:
return DefWindowProc(hWnd, message, wParam, lParam);
}
return 0;
}这种模式存在几个显著问题：
- 代码膨胀：随着消息类型的增加，switch-case语句变得异常庞大，一个成熟的应用程序可能处理数百种消息类型，导致代码可读性急剧下降。
- 高度耦合：所有消息处理逻辑集中在单一函数中，不同类型的消息处理代码相互交织，难以模块化。
- 维护困难：添加新消息处理或修改现有逻辑时，需要在庞大的switch-case结构中定位，容易引入错误。
二、MFC的解决方案：面向对象的消息映射机制
MFC的消息映射机制是对上述问题的革命性改进。它基于两个核心设计原则：
- 分散处理：将消息处理分散到各个窗口类中，每个类只处理与自己相关的消息。
- 编译时绑定：通过宏在编译时建立消息到处理函数的映射关系，避免运行时的类型判断开销。
2.1 消息映射的实现机制
消息映射的实现依赖于一组精心设计的宏和静态数据结构。以下是其核心实现机制：
cpp
// 典型的MFC类消息映射声明
class CMyWnd : public CWnd
{
public:
CMyWnd();
protected:
// 消息处理函数声明
afx_msg void OnPaint();
afx_msg void OnMouseMove(UINT nFlags, CPoint point);
afx_msg void OnFileOpen();
// 关键：声明消息映射
DECLARE_MESSAGE_MAP()
};
// 实现文件中的消息映射定义
BEGIN_MESSAGE_MAP(CMyWnd, CWnd)
ON_WM_PAINT()
ON_WM_MOUSEMOVE()
ON_COMMAND(ID_FILE_OPEN, &CMyWnd::OnFileOpen)
END_MESSAGE_MAP()2.2 消息映射表的内部结构
当编译器处理上述代码时，会生成类似下面的静态数据结构：
cpp
// 消息映射表条目结构（简化版本）
struct AFX_MSGMAP_ENTRY
{
UINT nMessage; // Windows消息ID
UINT nCode; // 控件通知码或其它
UINT nID; // 控件ID（命令消息用）
UINT nLastID; // 控件ID范围结束（用于范围映射）
UINT nSig; // 函数签名类型
AFX_PMSG pfn; // 指向成员函数的指针
};
// 为CMyWnd类生成的消息映射表
static const AFX_MSGMAP_ENTRY _messageEntries[] =
{
// 标准Windows消息
{ WM_PAINT, 0, 0, 0, AfxSig_vv, (AFX_PMSG)&CMyWnd::OnPaint },
{ WM_MOUSEMOVE, 0, 0, 0, AfxSig_vwp, (AFX_PMSG)&CMyWnd::OnMouseMove },
// 命令消息
{ WM_COMMAND, 0, ID_FILE_OPEN, ID_FILE_OPEN, AfxSig_vv,
(AFX_PMSG)&CMyWnd::OnFileOpen },
// 结束标记
{ 0, 0, 0, 0, AfxSig_end, (AFX_PMSG)0 }
};2.3 消息派发流程
MFC框架的消息派发过程遵循明确的算法：
cpp
// 伪代码展示MFC消息派发逻辑
LRESULT CWnd::WindowProc(UINT message, WPARAM wParam, LPARAM lParam)
{
// 1. 获取当前类的消息映射表
const AFX_MSGMAP* pMessageMap = GetMessageMap();
// 2. 沿着继承链向上查找消息处理函数
while (pMessageMap != NULL)
{
// 在当前类的消息映射表中查找
const AFX_MSGMAP_ENTRY* pEntries = pMessageMap->lpEntries;
for (; pEntries->nSig != AfxSig_end; pEntries++)
{
if (pEntries->nMessage == message)
{
// 找到匹配项，调用处理函数
union MessageMapFunctions mmf;
mmf.pfn = pEntries->pfn;
// 根据函数签名调用相应的处理函数
switch (pEntries->nSig)
{
case AfxSig_vv: // void func(void)
(this->*mmf.pfn_vv)();
return 0;
case AfxSig_vwp: // void func(UINT, CPoint)
(this->*mmf.pfn_vwp)(wParam,
CPoint(GET_X_LPARAM(lParam),
GET_Y_LPARAM(lParam)));
return 0;
// 更多函数签名处理...
}
}
}
// 3. 未找到则继续在基类中查找
pMessageMap = pMessageMap->pBaseMessageMap;
}
// 4. 未找到任何处理函数，调用默认窗口过程
return DefWindowProc(message, wParam, lParam);
}三、消息映射的分类与高级特性
3.1 四类消息及其处理方式
MFC将Windows消息系统性地分为四类，每类有不同的映射宏和处理模式：
| 消息类型 | 典型示例 | 映射宏 | 处理函数特征 | 应用场景 |
|---|---|---|---|---|
| 标准Windows消息 | WM_PAINT, WM_SIZE | ON_WM_XXXX() |
固定签名，如OnPaint() |
窗口绘制、大小调整等基础操作 |
| 命令消息 | 菜单点击、工具栏按钮 | ON_COMMAND(id, func) |
无参数void函数 | 用户命令响应 |
| 控件通知消息 | 按钮点击通知、列表项选择 | ON_NOTIFY(code, id, func) |
接收NMHDR结构体 | 复杂控件交互 |
| 反射消息 | WM_CTLCOLOR, WM_DRAWITEM | ON_WM_CTLCOLOR_REFLECT() |
子控件自我处理 | 控件自定义绘制 |
3.2 消息反射机制
消息反射是MFC中一个巧妙的设计，它允许子控件处理通常由父窗口处理的消息。这种机制通过以下步骤实现：
- 父窗口收到子控件的通知消息（如WM_CTLCOLOR）
- MFC框架检查子控件是否能处理反射消息
- 如果能，将消息反射回子控件
- 子控件在自己的消息映射表中处理反射消息
cpp
// 自定义按钮类处理反射消息的示例
class CMyButton : public CButton
{
DECLARE_MESSAGE_MAP()
public:
afx_msg HBRUSH CtlColor(CDC* pDC, UINT nCtlColor);
};
BEGIN_MESSAGE_MAP(CMyButton, CButton)
ON_WM_CTLCOLOR_REFLECT() // 反射消息处理
END_MESSAGE_MAP()
HBRUSH CMyButton::CtlColor(CDC* pDC, UINT nCtlColor)
{
// 按钮自行决定背景色，而不是由对话框统一控制
pDC->SetTextColor(RGB(255, 0, 0)); // 红色文字
pDC->SetBkColor(RGB(255, 255, 0)); // 黄色背景
static CBrush yellowBrush(RGB(255, 255, 0));
return yellowBrush;
}3.3 消息范围映射
对于处理一系列连续ID的相似命令，MFC提供了消息范围映射机制：
cpp
// 处理ID从ID_TOOL_BUTTON_FIRST到ID_TOOL_BUTTON_LAST的所有工具栏按钮
BEGIN_MESSAGE_MAP(CMyView, CView)
ON_COMMAND_RANGE(ID_TOOL_BUTTON_FIRST, ID_TOOL_BUTTON_LAST, OnToolButtonClicked)
END_MESSAGE_MAP()
void CMyView::OnToolButtonClicked(UINT nID)
{
// 根据具体ID执行相应操作
int buttonIndex = nID - ID_TOOL_BUTTON_FIRST;
// 处理逻辑...
}四、消息映射的性能与设计权衡
4.1 性能分析
MFC消息映射机制在性能上做出了以下权衡：
- 空间换时间：为每个窗口类生成静态消息映射表，占用额外内存，但避免了运行时的动态查找开销。
- 线性查找：消息映射表通常较小，线性查找效率可接受。对于有大量消息处理的大型类，查找效率可能成为瓶颈。
- 继承链查找：当消息在当前类未找到时，需要沿继承链向上查找，这增加了处理未处理消息的开销。
4.2 与替代方案的对比
与其它框架的消息/事件处理机制相比：
| 机制 | 代表框架 | 实现方式 | 优点 | 缺点 |
|---|---|---|---|---|
| 消息映射 | MFC | 编译时静态绑定，线性查找 | 类型安全，编译时检查 | 不够灵活，继承链查找开销 |
| 虚函数表 | 早期OWL | 每个消息对应虚函数 | 直接调用，性能高 | 虚函数表膨胀，二进制兼容性差 |
| 信号槽 | Qt | 运行时连接，字符串匹配 | 高度灵活，跨线程安全 | 运行时开销，类型安全检查弱 |
| 委托/事件 | .NET | 多播委托，引用计数 | 类型安全，支持多订阅者 | 垃圾回收依赖，非实时系统可能不适合 |
五、现代框架中的消息映射遗产
虽然MFC本身已不再是主流开发框架，但其消息映射的思想影响了后续众多UI框架：
- .NET WinForms：事件处理模型借鉴了消息映射的对象化思想
- WPF/UWP：路由事件概念可以视为消息映射的进化形式
- Qt信号槽：虽然实现机制不同，但解决的问题域高度相似
在现代C++ UI开发中，我们可以观察到类似的消息处理模式：
cpp
// 现代C++ UI框架中的类似模式（概念示例）
class ModernButton : public UIWidget
{
// 声明事件处理器
EventHandler<void()> onClick;
// 连接事件
void setupEventHandlers()
{
// 类似于MFC的消息映射，但更灵活
onMouseDown += [this](MouseEvent e) { this->handleMouseDown(e); };
onClick += []() { /* 处理点击 */ };
}
};六、总结：消息映射的设计哲学
MFC消息映射机制的核心价值在于它成功地将Windows API的过程式消息处理转化为面向对象的范式。这一转化基于以下设计哲学：
- 关注点分离：不同窗口类只处理自己的消息，符合单一职责原则。
- 编译时安全：通过宏在编译时建立映射，早期发现类型不匹配错误。
- 框架透明性：开发者只需关注处理函数本身，复杂的消息路由由框架处理。
然而，这一机制也有其历史局限性，特别是与现代反射和委托机制相比，它缺乏足够的灵活性和表达能力。理解MFC消息映射不仅有助于维护遗留代码，更重要的是，它展示了框架设计者如何通过抽象和封装来管理平台API的复杂性，这一设计思维对今天的软件开发依然具有启示意义。
第二章：MFC文档/视图架构------数据与界面的分离实践
一、设计起源：从单体应用到模块化架构的演进
在早期的Windows应用程序中，一个普遍的问题是数据管理、用户界面和业务逻辑高度耦合。以简单的文本编辑器为例，传统设计将文件操作、文本显示和用户输入处理全部混杂在窗口过程中，导致代码难以维护和扩展。
MFC文档/视图架构的提出，是为了解决这种"大泥球"架构问题。该架构的核心思想借鉴了软件工程中的模型-视图-控制器（MVC）模式，但根据Windows平台的特点和C++语言的特性进行了调整和优化。
二、架构组成：四大核心组件的协同工作
文档/视图架构由四个核心类构成，它们各自承担明确的职责：
cpp
// 架构核心类关系示意代码
class CDocument; // 数据管理层
class CView; // 数据显示与交互层
class CFrameWnd; // 窗口容器层
class CDocTemplate; // 工厂与协调层
// 应用程序初始化时的典型设置
BOOL CMyApp::InitInstance()
{
// 1. 创建文档模板（关键粘合剂）
CSingleDocTemplate* pDocTemplate;
pDocTemplate = new CSingleDocTemplate(
IDR_MAINFRAME, // 资源ID（菜单、图标等）
RUNTIME_CLASS(CMyDoc), // 文档类
RUNTIME_CLASS(CMainFrame), // 框架类
RUNTIME_CLASS(CMyView) // 视图类
);
// 2. 注册模板
AddDocTemplate(pDocTemplate);
// 3. 创建或打开文档
OnFileNew(); // 创建新文档
return TRUE;
}2.1 CDocument：数据的守护者
文档类是架构中的"模型"部分，负责所有与数据相关的操作：
cpp
class CMyDocument : public CDocument
{
protected:
CMyDocument();
// 属性
private:
CString m_strTitle; // 文档标题
CStringArray m_lines; // 文本行数据
BOOL m_bModified; // 修改标志
// 操作
public:
// 数据访问接口
const CString& GetLine(int nIndex) const { return m_lines[nIndex]; }
int GetLineCount() const { return m_lines.GetSize(); }
void AddLine(const CString& strLine);
void DeleteLine(int nIndex);
// 重写基类关键方法
virtual BOOL OnNewDocument();
virtual BOOL OnOpenDocument(LPCTSTR lpszPathName);
virtual BOOL OnSaveDocument(LPCTSTR lpszPathName);
virtual void DeleteContents();
// 序列化 - 核心数据持久化机制
virtual void Serialize(CArchive& ar);
// 视图通知
void UpdateAllViews(CView* pSender, LPARAM lHint = 0L, CObject* pHint = NULL);
DECLARE_DYNCREATE(CMyDocument)
DECLARE_MESSAGE_MAP()
};文档的关键职责包括：
- 数据存储与管理：维护应用程序的核心数据结构
- 持久化支持：通过Serialize方法实现文件读写
- 修改追踪：管理"脏标志"（修改状态）
- 视图协调：通知所有关联视图数据变更
2.2 CView：数据的观察者与交互界面
视图类是架构中的"视图"部分，负责数据的可视化呈现和用户交互：
cpp
class CMyView : public CView
{
protected:
CMyView();
// 属性
private:
int m_nCurrentLine; // 当前选中行
CFont m_fontText; // 显示字体
CSize m_sizeChar; // 字符尺寸
// 操作
public:
// 获取关联文档的强类型指针
CMyDocument* GetDocument() const
{
return (CMyDocument*)m_pDocument;
}
// 重写基类关键方法
virtual void OnDraw(CDC* pDC); // 绘制内容
virtual void OnUpdate(CView* pSender, LPARAM lHint, CObject* pHint);
virtual void OnInitialUpdate();
virtual BOOL PreCreateWindow(CREATESTRUCT& cs);
// 消息处理
afx_msg void OnLButtonDown(UINT nFlags, CPoint point);
afx_msg void OnKeyDown(UINT nChar, UINT nRepCnt, UINT nFlags);
afx_msg void OnEditCut();
afx_msg void OnEditCopy();
afx_msg void OnEditPaste();
DECLARE_DYNCREATE(CMyView)
DECLARE_MESSAGE_MAP()
};视图通过GetDocument()方法获取文档指针，这是文档与视图通信的主要桥梁。视图不直接存储数据，只持有对文档数据的引用。
三、文档/视图通信机制
3.1 数据流：文档到视图的更新
文档数据变化时，通过UpdateAllViews()方法通知所有关联的视图：
cpp
// 文档类中修改数据并通知视图
void CMyDocument::AddLine(const CString& strLine)
{
m_lines.Add(strLine);
m_bModified = TRUE;
// 通知所有视图数据已更新
UpdateAllViews(NULL, 0L, NULL);
// 或者携带提示信息，优化更新效率
// UpdateAllViews(NULL, UPDATE_LINE_ADDED, (CObject*)&strLine);
}视图接收更新通知并重绘：
cpp
// 视图类中响应更新通知
void CMyView::OnUpdate(CView* pSender, LPARAM lHint, CObject* pHint)
{
// 根据提示信息决定更新策略
if (lHint == UPDATE_LINE_ADDED)
{
// 局部更新：只更新新增行区域
CString* pNewLine = (CString*)pHint;
CRect rectUpdate = CalculateLineRect(m_lines.GetSize()-1);
InvalidateRect(&rectUpdate);
}
else
{
// 完全更新：重绘整个客户区
Invalidate();
}
}3.2 交互流：视图到文档的修改
用户通过视图界面修改数据时，视图调用文档的接口：
cpp
// 视图处理用户输入并修改文档
void CMyView::OnChar(UINT nChar, UINT nRepCnt, UINT nFlags)
{
CMyDocument* pDoc = GetDocument();
if (nChar == VK_RETURN) // 回车键
{
pDoc->AddLine(m_strCurrentLine); // 调用文档方法
m_strCurrentLine.Empty();
}
else
{
m_strCurrentLine += (TCHAR)nChar;
}
// 重绘当前行
CRect rectUpdate = CalculateCurrentLineRect();
InvalidateRect(&rectUpdate);
CView::OnChar(nChar, nRepCnt, nFlags);
}四、多视图支持：一档多视的实现
文档/视图架构最强大的特性之一是支持单个文档对应多个视图，这在CAD、图形编辑等应用中特别有用：
cpp
// 创建同一文档的第二个视图
void CMainFrame::OnWindowNewView()
{
CMyDocument* pDoc = (CMyDocument*)GetActiveDocument();
// 创建新的框架窗口
CChildFrame* pNewFrame = new CChildFrame;
// 动态创建新视图
CCreateContext context;
context.m_pCurrentDoc = pDoc;
context.m_pNewViewClass = RUNTIME_CLASS(CMyView);
// 创建视图并关联到新框架
if (!pNewFrame->LoadFrame(IDR_MYTYPE, WS_OVERLAPPEDWINDOW,
this, &context))
{
delete pNewFrame;
return;
}
// 显示新窗口
pNewFrame->InitialUpdateFrame(pDoc, TRUE);
}
// 不同类型的视图可以展示同一文档的不同方面
class CGraphView : public CView // 图形视图
{
virtual void OnDraw(CDC* pDC)
{
CMyDocument* pDoc = GetDocument();
// 将文本数据转换为图形展示
DrawTextAsGraph(pDC, pDoc->GetAllLines());
}
};
class CStatsView : public CView // 统计视图
{
virtual void OnDraw(CDC* pDC)
{
CMyDocument* pDoc = GetDocument();
// 显示文本的统计信息
DrawStatistics(pDC, pDoc->CalculateStats());
}
};五、序列化：文档持久化的核心机制
序列化是文档/视图架构的数据持久化基础，它通过CArchive类实现数据的二进制流式读写：
cpp
// 文档类的序列化实现
void CMyDocument::Serialize(CArchive& ar)
{
if (ar.IsStoring()) // 保存文档
{
// 写入版本标识
ar << (WORD)0x0001; // 版本1.0
// 写入文档属性
ar << m_strTitle;
ar << m_bModified;
// 写入数据内容
m_lines.Serialize(ar); // CStringArray支持序列化
// 写入自定义对象
if (m_pCustomObj != NULL)
{
ar << (WORD)1; // 标记有对象
ar.WriteObject(m_pCustomObj); // 写入可序列化对象
}
else
{
ar << (WORD)0; // 标记无对象
}
}
else // 加载文档
{
// 读取版本标识
WORD wVersion;
ar >> wVersion;
if (wVersion == 0x0001)
{
// 读取文档属性
ar >> m_strTitle;
ar >> m_bModified;
// 读取数据内容
m_lines.Serialize(ar);
// 读取自定义对象
WORD wHasObject;
ar >> wHasObject;
if (wHasObject == 1)
{
m_pCustomObj = (CCustomObject*)ar.ReadObject(
RUNTIME_CLASS(CCustomObject));
}
}
else
{
// 处理旧版本格式
LoadOldFormat(ar, wVersion);
}
}
}
// 自定义可序列化对象的实现
class CCustomObject : public CObject
{
DECLARE_SERIAL(CCustomObject)
private:
CString m_strData;
int m_nValue;
CPointArray m_points;
public:
virtual void Serialize(CArchive& ar)
{
CObject::Serialize(ar);
if (ar.IsStoring())
{
ar << m_strData << m_nValue;
m_points.Serialize(ar);
}
else
{
ar >> m_strData >> m_nValue;
m_points.Serialize(ar);
}
}
// 必须有无参构造函数
CCustomObject() { }
};
IMPLEMENT_SERIAL(CCustomObject, CObject, VERSIONABLE_SCHEMA | 1)六、与经典MVC架构的深度对比
6.1 相似性：分离关注点的共同追求
文档/视图架构与MVC都遵循了数据与显示分离的原则：
| 概念对应 | MVC组件 | 文档/视图组件 | 职责相似度 |
|---|---|---|---|
| 数据层 | Model | Document | 高：都负责数据管理和业务规则 |
| 显示层 | View | View | 高：都负责数据可视化 |
| 控制层 | Controller | 分散处理 | 低：MVC有独立控制器 |
6.2 差异性：架构完整性的本质区别
关键差异在于控制层的处理方式：
cpp
// MVC的明确控制流
// 1. 用户输入 -> Controller
// 2. Controller更新Model
// 3. Model通知View更新
// 文档/视图的混合控制流
// 1. 用户输入 -> View（直接处理）
// 2. View更新Document（直接调用）
// 3. Document通知所有View更新架构差异的具体表现：
-
控制器角色的缺失
- MVC：Controller是独立的协调者，决定如何响应输入
- 文档/视图：控制逻辑分散在View和Document中
-
通信模式的不同
cpp// MVC：观察者模式，松耦合 class Model { List<Observer> observers; void notifyObservers() { for (obs in observers) obs.update(); } }; // 文档/视图：直接调用，紧耦合 class Document { List<View*> views; void UpdateAllViews() { for (view in views) view->OnUpdate(this); } }; -
可测试性的影响
- MVC：Model和Controller可独立于View进行单元测试
- 文档/视图：View和Document紧密耦合，测试困难
七、架构的适用场景与局限性
7.1 理想适用场景
文档/视图架构特别适合以下类型的应用：
- 文档中心型应用：文字处理器、电子表格、代码编辑器
- 多视图数据展示：CAD系统、数据分析工具、数据库前端
- 需要完整文件支持的应用：支持打开、保存、另存为等标准操作
7.2 架构局限性
- 学习曲线陡峭：需要理解大量MFC特定概念和宏
- 过度设计简单应用：对于对话框应用过于复杂
- 平台锁定：深度绑定Windows和MFC框架
- 现代性不足：缺乏对触摸、手势等现代交互的支持
八、实际应用示例：简易文本编辑器
以下是文档/视图架构在文本编辑器中的完整实现示例：
cpp
// 文档类 - 管理文本数据
class CTextDocument : public CDocument
{
protected:
CTextDocument();
// 数据存储
CStringArray m_lines;
int m_nTotalChars;
public:
// 数据操作接口
BOOL InsertText(int nLine, int nPos, const CString& strText);
BOOL DeleteText(int nLine, int nPos, int nCount);
CString GetText(int nLine, int nPos, int nCount) const;
// 重写关键方法
virtual BOOL OnNewDocument();
virtual void Serialize(CArchive& ar);
virtual void DeleteContents();
DECLARE_DYNCREATE(CTextDocument)
};
// 视图类 - 显示和编辑文本
class CTextView : public CScrollView
{
protected:
CTextView();
// 编辑状态
int m_nCaretLine; // 光标所在行
int m_nCaretPos; // 光标在行中的位置
BOOL m_bSelecting; // 是否在选择文本
CPoint m_ptSelectStart; // 选择起始点
// 显示属性
CFont m_font;
CSize m_sizeChar; // 字符尺寸
int m_nLinesPerPage; // 每页行数
public:
CTextDocument* GetDocument() const;
// 重写关键方法
virtual void OnDraw(CDC* pDC);
virtual void OnInitialUpdate();
virtual void OnUpdate(CView* pSender, LPARAM lHint, CObject* pHint);
// 消息处理
afx_msg void OnLButtonDown(UINT nFlags, CPoint point);
afx_msg void OnMouseMove(UINT nFlags, CPoint point);
afx_msg void OnLButtonUp(UINT nFlags, CPoint point);
afx_msg void OnKeyDown(UINT nChar, UINT nRepCnt, UINT nFlags);
afx_msg void OnChar(UINT nChar, UINT nRepCnt, UINT nFlags);
afx_msg void OnVScroll(UINT nSBCode, UINT nPos, CScrollBar* pScrollBar);
// 计算辅助函数
CPoint CharPosFromPoint(CPoint point) const;
CPoint PointFromCharPos(int nLine, int nPos) const;
CRect GetLineRect(int nLine) const;
DECLARE_DYNCREATE(CTextView)
DECLARE_MESSAGE_MAP()
};九、现代框架中的演进与启示
虽然MFC文档/视图架构已逐渐退出主流，但其设计思想在现代框架中仍有体现：
- 数据绑定：WPF/XAML的数据绑定机制是文档/视图分离的进化
- MVVM模式：Model-View-ViewModel可视为文档/视图的现代化身
- 响应式编程：RxJS等库实现了更灵活的数据-视图同步
架构演进的启示：
- 关注点分离是永恒的设计原则
- 框架应该提供清晰的数据流指导
- 可测试性应该成为架构的核心考量
- 平台抽象层对于长期维护至关重要
文档/视图架构展示了在特定技术约束下（C++、Windows、90年代硬件）如何实现复杂应用的结构化组织。虽然具体技术已过时，但其背后的架构思维------如何管理复杂性、如何分离关注点、如何设计可扩展的系统------对今天的软件开发者仍有重要价值。
第三章：MFC对话框与DDX/DDV机制------用户界面的标准化封装
一、对话框编程的演进：从原始API到MFC封装
在原始的Windows SDK中，创建和管理对话框是一项繁琐且容易出错的工作。开发者需要手动处理对话框过程函数、控件消息、数据验证等一系列复杂任务。MFC的对话框类（CDialog及其派生类）通过面向对象的封装，极大地简化了这一过程。
1.1 原始Win32对话框编程的复杂性
cpp
// Win32 SDK中的对话框示例
BOOL CALLBACK DialogProc(HWND hwndDlg, UINT uMsg, WPARAM wParam, LPARAM lParam)
{
switch (uMsg)
{
case WM_INITDIALOG:
// 初始化控件
SetDlgItemText(hwndDlg, IDC_EDIT_NAME, "默认名称");
SetDlgItemInt(hwndDlg, IDC_EDIT_AGE, 25, FALSE);
return TRUE;
case WM_COMMAND:
switch (LOWORD(wParam))
{
case IDOK:
{
// 获取数据
TCHAR szName[100];
GetDlgItemText(hwndDlg, IDC_EDIT_NAME, szName, 100);
// 手动验证
if (lstrlen(szName) == 0)
{
MessageBox(hwndDlg, "姓名不能为空", "错误", MB_OK);
return TRUE;
}
int nAge = GetDlgItemInt(hwndDlg, IDC_EDIT_AGE, NULL, FALSE);
if (nAge < 0 || nAge > 150)
{
MessageBox(hwndDlg, "年龄必须在0-150之间", "错误", MB_OK);
return TRUE;
}
EndDialog(hwndDlg, IDOK);
return TRUE;
}
case IDCANCEL:
EndDialog(hwndDlg, IDCANCEL);
return TRUE;
}
break;
}
return FALSE;
}
// 调用对话框
DialogBox(hInstance, MAKEINTRESOURCE(IDD_MYDIALOG), hwndParent, DialogProc);这种模式存在明显问题：
- 代码冗长：每个控件都需要单独获取和设置
- 验证分散：验证逻辑与UI逻辑混杂
- 类型不安全：所有数据都是字符串或整数，需要手动转换
- 难以维护：添加新控件需要修改多个地方
二、MFC对话框类的封装架构
2.1 CDialog类层次结构
cpp
// MFC对话框类的基本层次
CObject
└── CCmdTarget
└── CWnd
└── CDialog
├── CCommonDialog (通用对话框基类)
│ ├── CFileDialog
│ ├── CColorDialog
│ ├── CFontDialog
│ └── ...
└── CDialogEx (增强功能)
// 典型的MFC对话框类定义
class CMyDialog : public CDialogEx
{
DECLARE_DYNAMIC(CMyDialog)
public:
// 标准构造函数
CMyDialog(CWnd* pParent = NULL);
// 对话框资源ID
enum { IDD = IDD_MYDIALOG };
protected:
// DDX/DDV支持
virtual void DoDataExchange(CDataExchange* pDX);
// 消息映射
DECLARE_MESSAGE_MAP()
public:
// 控件关联变量
CString m_strName;
int m_nAge;
BOOL m_bAgree;
CComboBox m_cboGender;
};2.2 对话框生命周期管理
MFC对话框的生命周期由以下关键方法控制：
cpp
// 对话框创建与销毁流程
BOOL CMyDialog::OnInitDialog()
{
CDialogEx::OnInitDialog();
// 1. 初始化控件
m_cboGender.AddString(_T("男"));
m_cboGender.AddString(_T("女"));
m_cboGender.SetCurSel(0);
// 2. 设置初始数据
m_strName = _T("张三");
m_nAge = 25;
m_bAgree = TRUE;
// 3. 更新控件显示
UpdateData(FALSE);
// 4. 其他初始化
CenterWindow(); // 居中显示
return TRUE;
}
void CMyDialog::OnOK()
{
// 1. 从控件获取数据并验证
if (!UpdateData(TRUE))
return; // 验证失败，不关闭对话框
// 2. 额外的业务逻辑验证
if (m_strName.GetLength() < 2)
{
MessageBox(_T("姓名至少需要2个字符"), _T("错误"), MB_ICONERROR);
GetDlgItem(IDC_EDIT_NAME)->SetFocus();
return;
}
// 3. 调用基类OnOK关闭对话框
CDialogEx::OnOK();
}
void CMyDialog::OnCancel()
{
// 取消前的确认
if (MessageBox(_T("确定要取消吗？"), _T("确认"),
MB_YESNO | MB_ICONQUESTION) == IDYES)
{
CDialogEx::OnCancel();
}
}三、DDX（对话框数据交换）机制详解
3.1 DDX的核心原理
DDX机制通过DoDataExchange函数和一组预定义的宏，在对话框控件和成员变量之间建立双向数据绑定：
cpp
// DoDataExchange函数的标准实现
void CMyDialog::DoDataExchange(CDataExchange* pDX)
{
CDialogEx::DoDataExchange(pDX);
// 文本控件交换
DDX_Text(pDX, IDC_EDIT_NAME, m_strName);
// 数值控件交换
DDX_Text(pDX, IDC_EDIT_AGE, m_nAge);
// 复选框交换
DDX_Check(pDX, IDC_CHECK_AGREE, m_bAgree);
// 单选按钮交换
DDX_Radio(pDX, IDC_RADIO_MALE, m_nGender);
// 组合框交换
DDX_CBIndex(pDX, IDC_COMBO_STATUS, m_nStatusIndex);
DDX_CBString(pDX, IDC_COMBO_STATUS, m_strStatus);
// 列表框交换
DDX_LBIndex(pDX, IDC_LIST_ITEMS, m_nSelectedItem);
// 控件对象交换
DDX_Control(pDX, IDC_COMBO_GENDER, m_cboGender);
}3.2 DDX宏的编译时展开
编译器会将DDX宏展开为具体的代码，以下是对DDX_Text宏展开的模拟：
cpp
// DDX_Text宏的近似展开（概念性代码）
#define DDX_Text(pDX, nIDC, value) \
do { \
if ((pDX)->m_bSaveAndValidate) { \
/* 从控件获取数据到变量 */ \
HWND hWndCtrl = ::GetDlgItem((pDX)->m_pDlgWnd->m_hWnd, nIDC); \
if (hWndCtrl != NULL) { \
int nLen = ::GetWindowTextLength(hWndCtrl); \
CString strTemp; \
::GetWindowText(hWndCtrl, strTemp.GetBuffer(nLen), nLen + 1); \
strTemp.ReleaseBuffer(); \
/* 类型转换和赋值 */ \
value = _ttoi(strTemp); /* 对于int类型 */ \
} \
} else { \
/* 从变量设置数据到控件 */ \
CString strTemp; \
strTemp.Format(_T("%d"), value); /* 对于int类型 */ \
::SetDlgItemText((pDX)->m_pDlgWnd->m_hWnd, nIDC, strTemp); \
} \
} while (0)3.3 完整DDX支持的数据类型
MFC为不同类型的数据提供了专门的DDX宏：
| 数据类型 | DDX宏 | 示例 | 适用控件 |
|---|---|---|---|
| CString | DDX_Text |
DDX_Text(pDX, IDC_EDIT, m_strValue) |
编辑框 |
| int | DDX_Text |
DDX_Text(pDX, IDC_EDIT, m_nValue) |
编辑框 |
| UINT | DDX_Text |
DDX_Text(pDX, IDC_EDIT, m_uValue) |
编辑框 |
| long | DDX_Text |
DDX_Text(pDX, IDC_EDIT, m_lValue) |
编辑框 |
| DWORD | DDX_Text |
DDX_Text(pDX, IDC_EDIT, m_dwValue) |
编辑框 |
| float | DDX_Text |
DDX_Text(pDX, IDC_EDIT, m_fValue) |
编辑框 |
| double | DDX_Text |
DDX_Text(pDX, IDC_EDIT, m_dValue) |
编辑框 |
| BOOL | DDX_Check |
DDX_Check(pDX, IDC_CHECK, m_bValue) |
复选框 |
| int (单选) | DDX_Radio |
DDX_Radio(pDX, IDC_RADIO1, m_nIndex) |
单选按钮组 |
| CComboBox | DDX_Control |
DDX_Control(pDX, IDC_COMBO, m_combo) |
组合框对象 |
| CListBox | DDX_Control |
DDX_Control(pDX, IDC_LIST, m_list) |
列表框对象 |
四、DDV（对话框数据验证）机制详解
4.1 DDV的工作原理
DDV在数据交换的同时进行验证，确保数据的有效性：
cpp
// 带有DDV验证的DoDataExchange示例
void CMyDialog::DoDataExchange(CDataExchange* pDX)
{
CDialogEx::DoDataExchange(pDX);
// 数据交换
DDX_Text(pDX, IDC_EDIT_NAME, m_strName);
// 数据验证
DDV_MaxChars(pDX, m_strName, 50); // 最多50个字符
// 数值交换与验证
DDX_Text(pDX, IDC_EDIT_AGE, m_nAge);
DDV_MinMaxInt(pDX, m_nAge, 0, 150); // 范围0-150
// 字符串非空验证
DDV_NonEmptyString(pDX, m_strName);
}4.2 DDV验证失败的处理机制
当DDV验证失败时，MFC会抛出异常并自动处理：
cpp
// DDV_MinMaxInt宏的内部实现逻辑（概念性）
#define DDV_MinMaxInt(pDX, value, minVal, maxVal) \
do { \
if ((pDX)->m_bSaveAndValidate && (value < minVal || value > maxVal)) { \
/* 准备错误信息 */ \
CString strError; \
strError.Format(_T("数值必须在%d和%d之间"), minVal, maxVal); \
\
/* 显示错误对话框 */ \
AfxMessageBox(strError, MB_ICONEXCLAMATION); \
\
/* 抛出异常停止后续处理 */ \
(pDX)->Fail(); \
} \
} while (0)
// CDataExchange::Fail()方法的简化实现
void CDataExchange::Fail()
{
// 设置焦点到问题控件
if (m_hWndLastControl != NULL && ::IsWindow(m_hWndLastControl))
{
::SetFocus(m_hWndLastControl);
}
// 抛出异常，被MFC框架捕获
throw new CUserException();
}4.3 自定义DDV验证
除了内置的DDV宏，还可以创建自定义验证：
cpp
// 自定义DDV验证宏
#define DDV_Email(pDX, value) \
do { \
if ((pDX)->m_bSaveAndValidate) { \
if (!IsValidEmail(value)) { \
AfxMessageBox(_T("请输入有效的电子邮件地址"), \
MB_ICONEXCLAMATION); \
(pDX)->Fail(); \
} \
} \
} while (0)
// 使用自定义验证
void CMyDialog::DoDataExchange(CDataExchange* pDX)
{
CDialogEx::DoDataExchange(pDX);
DDX_Text(pDX, IDC_EDIT_EMAIL, m_strEmail);
DDV_Email(pDX, m_strEmail); // 自定义验证
}
// 电子邮件验证函数
BOOL CMyDialog::IsValidEmail(const CString& strEmail)
{
// 简单的电子邮件验证逻辑
int nAtPos = strEmail.Find('@');
int nDotPos = strEmail.Find('.', nAtPos);
return (nAtPos > 0 && nDotPos > nAtPos + 1 &&
nDotPos < strEmail.GetLength() - 1);
}五、模态与非模态对话框的深入对比
5.1 模态对话框的完整生命周期
cpp
// 模态对话框的创建与使用
void CMyView::OnOpenSettings()
{
CMyDialog dlg(this); // 创建对话框对象
// 设置初始值
dlg.m_strName = m_strCurrentName;
dlg.m_nAge = m_nCurrentAge;
// 显示模态对话框
if (dlg.DoModal() == IDOK)
{
// 用户点击了确定
m_strCurrentName = dlg.m_strName;
m_nCurrentAge = dlg.m_nAge;
// 保存设置
SaveSettings();
// 更新显示
UpdateDisplay();
}
else
{
// 用户点击了取消
AfxMessageBox(_T("设置未保存"));
}
// 对话框对象自动销毁
}5.2 非模态对话框的特殊管理
非模态对话框需要不同的生命周期管理策略：
cpp
// 非模态对话框的创建与管理
class CMyView : public CView
{
private:
CMyModelessDialog* m_pModelessDlg; // 指针成员
public:
void OnOpenModelessDialog()
{
// 防止重复打开
if (m_pModelessDlg != NULL && m_pModelessDlg->GetSafeHwnd() != NULL)
{
m_pModelessDlg->SetActiveWindow();
m_pModelessDlg->ShowWindow(SW_SHOW);
return;
}
// 创建非模态对话框
m_pModelessDlg = new CMyModelessDialog(this);
// 必须指定WS_VISIBLE风格
if (!m_pModelessDlg->Create(IDD_MYDIALOG, this))
{
delete m_pModelessDlg;
m_pModelessDlg = NULL;
AfxMessageBox(_T("创建对话框失败"));
return;
}
// 显示对话框
m_pModelessDlg->ShowWindow(SW_SHOW);
}
// 对话框关闭时的清理
void OnModelessDialogClosed()
{
if (m_pModelessDlg != NULL)
{
// 注意：不能调用delete，对话框自己管理生命周期
m_pModelessDlg = NULL;
}
}
};
// 非模态对话框类
class CMyModelessDialog : public CDialogEx
{
private:
CMyView* m_pParentView;
public:
CMyModelessDialog(CMyView* pParent)
: CDialogEx(IDD_MYDIALOG, pParent), m_pParentView(pParent) {}
// 重写OnOK和OnCancel
virtual void OnOK()
{
if (!UpdateData(TRUE))
return;
// 通知父视图
if (m_pParentView != NULL)
{
m_pParentView->ApplyDialogSettings(m_strName, m_nAge);
}
// 不调用基类OnOK（不关闭对话框）
// 而是隐藏或执行其他操作
ShowWindow(SW_HIDE);
}
virtual void OnCancel()
{
// 通知父视图对话框已关闭
if (m_pParentView != NULL)
{
m_pParentView->OnModelessDialogClosed();
}
// 销毁窗口
DestroyWindow();
}
// 重写PostNcDestroy以删除对象
virtual void PostNcDestroy()
{
CDialogEx::PostNcDestroy();
delete this; // 自我删除
}
DECLARE_MESSAGE_MAP()
};六、属性表（Property Sheet）与属性页（Property Page）
对于复杂的设置对话框，MFC提供了属性表机制：
cpp
// 属性页基类的使用
class CGeneralPage : public CPropertyPage
{
DECLARE_DYNCREATE(CGeneralPage)
public:
CGeneralPage() : CPropertyPage(IDD_GENERAL_PAGE)
{
m_psp.dwFlags |= PSP_USETITLE;
m_psp.pszTitle = _T("常规设置");
}
// 数据成员
CString m_strUserName;
CString m_strCompany;
BOOL m_bAutoSave;
protected:
virtual void DoDataExchange(CDataExchange* pDX)
{
CPropertyPage::DoDataExchange(pDX);
DDX_Text(pDX, IDC_EDIT_USERNAME, m_strUserName);
DDX_Text(pDX, IDC_EDIT_COMPANY, m_strCompany);
DDX_Check(pDX, IDC_CHECK_AUTOSAVE, m_bAutoSave);
}
// 验证
virtual BOOL OnApply()
{
if (!UpdateData(TRUE))
return FALSE;
// 应用设置
AfxGetApp()->WriteProfileString(_T("Settings"), _T("UserName"), m_strUserName);
return CPropertyPage::OnApply();
}
};
// 属性表的创建与使用
void CMyApp::OnSettings()
{
// 创建属性表
CPropertySheet sheet(_T("应用程序设置"));
// 添加属性页
CGeneralPage pageGeneral;
CAdvancedPage pageAdvanced;
sheet.AddPage(&pageGeneral);
sheet.AddPage(&pageAdvanced);
// 设置初始值
pageGeneral.m_strUserName = GetCurrentUserName();
pageAdvanced.m_nTimeout = GetTimeoutValue();
// 显示模态属性表
if (sheet.DoModal() == IDOK)
{
// 保存所有设置
SaveSettings(pageGeneral, pageAdvanced);
}
}七、对话框数据交换的高级技巧
7.1 动态控件的数据交换
对于动态创建的控件，需要特殊处理DDX：
cpp
class CDynamicDialog : public CDialogEx
{
private:
// 动态控件ID起始值（必须大于系统ID）
enum { IDC_DYNAMIC_START = 0x8000 };
// 动态控件数组
CEdit* m_pDynamicEdits[10];
CStatic* m_pDynamicLabels[10];
int m_nDynamicValues[10];
int m_nControlCount;
public:
virtual void DoDataExchange(CDataExchange* pDX)
{
CDialogEx::DoDataExchange(pDX);
// 动态控件的DDX
for (int i = 0; i < m_nControlCount; i++)
{
if (m_pDynamicEdits[i] != NULL && m_pDynamicEdits[i]->GetSafeHwnd() != NULL)
{
DDX_Text(pDX, IDC_DYNAMIC_START + i, m_nDynamicValues[i]);
}
}
}
void CreateDynamicControls(int nCount)
{
m_nControlCount = nCount;
for (int i = 0; i < nCount; i++)
{
// 创建标签
m_pDynamicLabels[i] = new CStatic;
m_pDynamicLabels[i]->Create(_T("动态控件 ") + CString(char('A' + i)),
WS_CHILD | WS_VISIBLE,
CRect(10, 30 + i * 30, 100, 50 + i * 30),
this);
// 创建编辑框
m_pDynamicEdits[i] = new CEdit;
m_pDynamicEdits[i]->Create(WS_CHILD | WS_VISIBLE | WS_BORDER | ES_AUTOHSCROLL,
CRect(110, 30 + i * 30, 210, 50 + i * 30),
this, IDC_DYNAMIC_START + i);
}
}
};7.2 数据交换的性能优化
对于包含大量控件的对话框，可以优化DDX性能：
cpp
void COptimizedDialog::DoDataExchange(CDataExchange* pDX)
{
CDialogEx::DoDataExchange(pDX);
// 使用条件编译或标志控制DDX范围
#ifdef FULL_DATA_EXCHANGE
// 完整的数据交换
ExchangeAllData(pDX);
#else
// 部分数据交换（根据需求）
if (pDX->m_bSaveAndValidate)
{
// 只验证必要字段
ExchangeRequiredData(pDX);
}
else
{
// 只更新可见字段
ExchangeVisibleData(pDX);
}
#endif
}
// 分组数据交换示例
void COptimizedDialog::ExchangePersonalData(CDataExchange* pDX)
{
DDX_Text(pDX, IDC_EDIT_NAME, m_strName);
DDX_Text(pDX, IDC_EDIT_AGE, m_nAge);
DDX_Text(pDX, IDC_EDIT_PHONE, m_strPhone);
}
void COptimizedDialog::ExchangeWorkData(CDataExchange* pDX)
{
DDX_Text(pDX, IDC_EDIT_COMPANY, m_strCompany);
DDX_Text(pDX, IDC_EDIT_POSITION, m_strPosition);
}八、对话框与文档/视图架构的集成
对话框可以作为文档/视图架构的补充：
cpp
// 在文档/视图应用中使用对话框
void CMyView::OnEditPreferences()
{
CPreferencesDialog dlg;
// 从文档获取当前设置
CMyDocument* pDoc = GetDocument();
dlg.m_strDefaultPath = pDoc->GetDefaultPath();
dlg.m_nAutoSaveInterval = pDoc->GetAutoSaveInterval();
if (dlg.DoModal() == IDOK)
{
// 更新文档设置
pDoc->SetDefaultPath(dlg.m_strDefaultPath);
pDoc->SetAutoSaveInterval(dlg.m_nAutoSaveInterval);
// 标记文档为已修改
pDoc->SetModifiedFlag(TRUE);
// 更新所有视图
pDoc->UpdateAllViews(this);
}
}
// 对话框数据变化实时更新视图
void CRealTimeDialog::OnChangeEditValue()
{
// 获取当前值
UpdateData(TRUE);
// 实时更新预览
CPreviewDialog* pPreview = GetPreviewWindow();
if (pPreview != NULL)
{
pPreview->UpdatePreview(m_nValue, m_strText);
}
}九、常见问题与调试技巧
9.1 DDX/DDV常见问题排查
cpp
// 调试DDX问题的技巧
void CMyDialog::DoDataExchange(CDataExchange* pDX)
{
TRACE(_T("DoDataExchange called, m_bSaveAndValidate = %d\n"),
pDX->m_bSaveAndValidate);
CDialogEx::DoDataExchange(pDX);
#ifdef _DEBUG
// 调试模式下添加额外检查
if (pDX->m_bSaveAndValidate)
{
// 检查控件是否存在
if (GetDlgItem(IDC_EDIT_NAME) == NULL)
{
TRACE0("错误: IDC_EDIT_NAME 控件不存在!\n");
ASSERT(FALSE);
}
}
#endif
DDX_Text(pDX, IDC_EDIT_NAME, m_strName);
TRACE(_T("m_strName = %s\n"), (LPCTSTR)m_strName);
}9.2 内存泄漏检测
cpp
// 检测对话框相关的内存泄漏
#ifdef _DEBUG
void CMyDialog::OnDestroy()
{
CDialogEx::OnDestroy();
// 检查动态创建的控件是否被正确删除
for (int i = 0; i < m_nControlCount; i++)
{
// 这些指针应该在PostNcDestroy中删除
ASSERT(m_pDynamicEdits[i] == NULL);
}
}
// 重写PostNcDestroy确保资源清理
void CMyModelessDialog::PostNcDestroy()
{
// 清理动态控件
for (int i = 0; i < m_nControlCount; i++)
{
if (m_pDynamicEdits[i] != NULL)
{
delete m_pDynamicEdits[i];
m_pDynamicEdits[i] = NULL;
}
}
CDialogEx::PostNcDestroy();
delete this;
}
#endif十、现代替代方案与架构启示
虽然MFC对话框机制有其历史局限性，但其设计思想对现代UI框架仍有影响：
- 数据绑定模式：WPF/XAML的数据绑定是DDX的进化版本
- MVVM模式：ViewModel作为数据中介，类似于MFC对话框的数据层
- 响应式表单：Angular/React中的表单验证机制借鉴了DDV的思想
DDX/DDV机制的现代启示：
- 声明式数据绑定优于命令式数据操作
- 数据验证应该与UI逻辑分离
- 类型安全是框架设计的重要目标
- 开发者体验（DX）直接影响框架的采用率
MFC的对话框和DDX/DDV机制展示了如何在C++环境中实现类型安全的UI数据绑定。虽然具体实现已显陈旧，但其核心思想------通过元编程简化开发者工作、确保数据完整性、提供一致的编程模型------仍然是优秀框架设计的重要原则。
第四章：MFC图形设备接口(GDI)编程------Windows图形渲染的核心引擎
一、GDI系统架构：从硬件抽象到应用程序
Windows GDI（Graphics Device Interface）是Windows操作系统的图形核心子系统，MFC通过CDC类及其派生类对其进行面向对象封装。理解GDI的层次结构是掌握MFC绘图的基础：
二、设备上下文(CDC)的深入解析
2.1 CDC类的基本原理
设备上下文是GDI的核心概念，它代表了绘图表面的抽象，包含绘图所需的所有状态信息：
cpp
// CDC类的关键内部结构（概念性）
class CDC : public CObject
{
protected:
HDC m_hDC; // Windows设备上下文句柄
HDC m_hAttribDC; // 属性DC（用于打印等）
BOOL m_bPrinting; // 是否为打印DC
public:
// 构造函数与析构函数
CDC();
virtual ~CDC();
// 设备上下文操作
BOOL Attach(HDC hDC); // 关联现有HDC
HDC Detach(); // 分离HDC
HDC GetSafeHdc() const; // 安全获取HDC
// 绘图状态管理
int SaveDC(); // 保存DC状态
BOOL RestoreDC(int nSavedDC); // 恢复DC状态
// 坐标与映射模式
virtual CPoint GetViewportOrg() const;
virtual CSize GetViewportExt() const;
virtual int SetMapMode(int nMapMode);
// 绘图操作
virtual BOOL LineTo(int x, int y);
virtual BOOL Rectangle(int x1, int y1, int x2, int y2);
virtual BOOL Ellipse(int x1, int y1, int x2, int y2);
virtual BOOL TextOut(int x, int y, LPCTSTR lpszString, int nCount);
// GDI对象管理
virtual CGdiObject* SelectStockObject(int nIndex);
virtual CGdiObject* SelectObject(CGdiObject* pObject);
// 设备能力查询
int GetDeviceCaps(int nIndex) const;
DECLARE_DYNAMIC(CDC)
};2.2 不同CDC派生类的使用场景
MFC提供了多种CDC派生类以适应不同绘图需求：
cpp
// 1. CPaintDC - 用于WM_PAINT消息处理
void CMyView::OnPaint()
{
CPaintDC dc(this); // 自动调用BeginPaint
// 获取无效区域
CRect rectUpdate;
dc.GetClipBox(&rectUpdate);
// 执行绘图操作
OnDraw(&dc); // 通常调用OnDraw进行实际绘制
// 析构时自动调用EndPaint
}
// 2. CClientDC - 用于客户区即时绘图
void CMyView::OnMouseMove(UINT nFlags, CPoint point)
{
if (m_bDrawing)
{
CClientDC dc(this); // 获取客户区DC
// 实时绘制反馈
dc.MoveTo(m_ptLastPos);
dc.LineTo(point);
m_ptLastPos = point;
}
CView::OnMouseMove(nFlags, point);
}
// 3. CWindowDC - 绘制整个窗口（包括非客户区）
void CMyFrameWnd::OnDrawBorder()
{
CWindowDC dc(this); // 获取整个窗口DC
// 绘制自定义窗口边框
CRect rectWindow;
GetWindowRect(&rectWindow);
// 转换为客户区坐标
ScreenToClient(&rectWindow);
// 绘制边框
CPen pen(PS_SOLID, 3, RGB(255, 0, 0));
dc.SelectObject(&pen);
dc.SelectStockObject(NULL_BRUSH);
dc.Rectangle(rectWindow);
}
// 4. CMetaFileDC - 创建Windows图元文件
void CMyView::CreateMetaFile()
{
CMetaFileDC dcMeta;
// 创建图元文件DC
if (dcMeta.Create())
{
// 在图元文件中记录绘图命令
dcMeta.SetMapMode(MM_ANISOTROPIC);
dcMeta.SetWindowExt(1000, 1000);
dcMeta.SetViewportExt(100, 100);
// 记录绘图操作
dcMeta.Rectangle(10, 10, 500, 500);
dcMeta.Ellipse(100, 100, 400, 400);
// 关闭图元文件
HMETAFILE hMetaFile = dcMeta.Close();
if (hMetaFile != NULL)
{
// 可以保存或回放图元文件
CClientDC dc(this);
dc.PlayMetaFile(hMetaFile);
// 删除图元文件句柄
::DeleteMetaFile(hMetaFile);
}
}
}三、GDI对象管理与资源生命周期
3.1 GDI对象的基本使用模式
正确的GDI对象管理是防止资源泄漏的关键：
cpp
void CMyView::OnDraw(CDC* pDC)
{
// 1. 创建GDI对象
CPen newPen(PS_SOLID, 2, RGB(0, 0, 255));
CBrush newBrush(RGB(255, 255, 0));
CFont newFont;
// 创建字体
LOGFONT lf = {0};
lf.lfHeight = -16;
lf.lfWeight = FW_BOLD;
lstrcpy(lf.lfFaceName, _T("Arial"));
newFont.CreateFontIndirect(&lf);
// 2. 保存旧对象并选入新对象
CPen* pOldPen = pDC->SelectObject(&newPen);
CBrush* pOldBrush = pDC->SelectObject(&newBrush);
CFont* pOldFont = pDC->SelectObject(&newFont);
// 3. 执行绘图操作
pDC->Rectangle(10, 10, 200, 150);
pDC->Ellipse(50, 50, 150, 100);
pDC->TextOut(20, 20, _T("GDI绘图示例"));
// 4. 恢复旧对象（按相反顺序）
pDC->SelectObject(pOldFont);
pDC->SelectObject(pOldBrush);
pDC->SelectObject(pOldPen);
// 5. GDI对象在作用域结束时自动删除
// 注意：如果调用DeleteObject，需确保不再使用该对象
}3.2 GDI对象的创建工厂模式
对于需要频繁创建相同样式GDI对象的情况，可以使用工厂模式：
cpp
class CGdiObjectFactory
{
private:
static CMap<DWORD, DWORD, CPen*, CPen*> m_mapPens;
static CMap<DWORD, DWORD, CBrush*, CBrush*> m_mapBrushes;
static CCriticalSection m_cs; // 线程保护
public:
// 获取或创建指定样式的画笔
static CPen* GetPen(int nStyle, int nWidth, COLORREF crColor)
{
CSingleLock lock(&m_cs, TRUE);
// 创建唯一键
DWORD dwKey = (nStyle << 24) | (nWidth << 16) | crColor;
CPen* pPen = NULL;
if (!m_mapPens.Lookup(dwKey, pPen))
{
// 创建新画笔
pPen = new CPen(nStyle, nWidth, crColor);
m_mapPens.SetAt(dwKey, pPen);
}
return pPen;
}
// 清理所有GDI对象
static void Cleanup()
{
CSingleLock lock(&m_cs, TRUE);
// 删除所有画笔
POSITION pos = m_mapPens.GetStartPosition();
DWORD dwKey;
CPen* pPen;
while (pos != NULL)
{
m_mapPens.GetNextAssoc(pos, dwKey, pPen);
delete pPen;
}
m_mapPens.RemoveAll();
// 类似地清理画刷等
}
};四、高级绘图技术与优化
4.1 双缓冲绘图技术
双缓冲是消除绘图闪烁的关键技术：
cpp
class CDoubleBufferDC : public CDC
{
private:
CDC* m_pDC; // 原始设备上下文
CBitmap m_bitmap; // 内存位图
CBitmap* m_pOldBitmap; // 旧位图
CRect m_rect; // 绘制区域
public:
CDoubleBufferDC(CDC* pDC, const CRect& rect)
: m_pDC(pDC), m_rect(rect)
{
// 创建兼容的内存DC
CreateCompatibleDC(pDC);
// 创建兼容位图
m_bitmap.CreateCompatibleBitmap(pDC, rect.Width(), rect.Height());
// 选入位图
m_pOldBitmap = SelectObject(&m_bitmap);
// 设置原点偏移
SetViewportOrg(-rect.left, -rect.top);
}
virtual ~CDoubleBufferDC()
{
// 将内存位图拷贝到屏幕
m_pDC->BitBlt(m_rect.left, m_rect.top,
m_rect.Width(), m_rect.Height(),
this,
m_rect.left, m_rect.top,
SRCCOPY);
// 恢复原始位图
SelectObject(m_pOldBitmap);
// 位图对象自动删除
}
};
// 在视图类中使用双缓冲
void CMyView::OnDraw(CDC* pDC)
{
CRect rectClient;
GetClientRect(&rectClient);
// 创建双缓冲DC
CDoubleBufferDC dbDC(pDC, rectClient);
// 使用dbDC进行所有绘图操作
DrawBackground(&dbDC, rectClient);
DrawContent(&dbDC, rectClient);
DrawOverlay(&dbDC, rectClient);
// dbDC析构时自动刷新到屏幕
}4.2 路径与复杂区域操作
路径提供了一种记录和重用复杂绘图序列的方法：
cpp
void CMyView::DrawComplexShape(CDC* pDC)
{
// 开始路径定义
pDC->BeginPath();
// 定义路径形状
pDC->MoveTo(100, 100);
pDC->LineTo(200, 100);
pDC->LineTo(200, 200);
pDC->LineTo(100, 200);
pDC->LineTo(100, 100); // 闭合矩形
// 添加第二个形状
pDC->MoveTo(150, 50);
pDC->LineTo(250, 150);
pDC->LineTo(50, 150);
pDC->CloseFigure(); // 闭合三角形
// 结束路径定义
pDC->EndPath();
// 1. 绘制路径轮廓
CPen pen(PS_SOLID, 2, RGB(255, 0, 0));
CPen* pOldPen = pDC->SelectObject(&pen);
pDC->StrokePath();
pDC->SelectObject(pOldPen);
// 2. 填充路径
CBrush brush(RGB(0, 255, 0));
CBrush* pOldBrush = pDC->SelectObject(&brush);
pDC->FillPath();
pDC->SelectObject(pOldBrush);
// 3. 将路径转换为区域
CRgn region;
if (region.CreateFromPath(pDC))
{
// 使用区域进行点击测试
CPoint ptTest(120, 120);
if (region.PtInRegion(ptTest))
{
pDC->TextOut(10, 10, _T("点在区域内"));
}
// 区域也可以用于裁剪
pDC->SelectClipRgn(®ion);
// ... 在裁剪区域内绘图
pDC->SelectClipRgn(NULL); // 取消裁剪
}
}4.3 坐标系统与变换
MFC支持多种坐标映射模式和变换：
cpp
void CMyView::DemonstrateCoordinateSystems(CDC* pDC)
{
// 保存原始DC状态
int nOldMapMode = pDC->SaveDC();
// 示例1：逻辑坐标与设备坐标
pDC->SetMapMode(MM_TEXT); // 默认模式，1逻辑单位=1像素
// 设置窗口（逻辑）和视口（设备）范围
pDC->SetWindowExt(1000, 1000); // 逻辑范围
pDC->SetViewportExt(500, 500); // 设备范围
// 示例2：使用MM_ANISOTROPIC模式
pDC->SetMapMode(MM_ANISOTROPIC);
pDC->SetWindowExt(1000, 1000);
pDC->SetViewportExt(rectClient.Width(), rectClient.Height());
// 绘制随窗口大小缩放的图形
pDC->Rectangle(100, 100, 900, 900);
// 示例3：使用MM_HIMETRIC模式（物理尺寸）
pDC->SetMapMode(MM_HIMETRIC); // 0.01毫米单位
pDC->Rectangle(0, 0, 10000, -5000); // 10cm x 5cm矩形
// 坐标转换示例
CPoint ptLogical(500, 500);
CPoint ptDevice;
// 逻辑坐标转设备坐标
pDC->LPtoDP(&ptLogical);
// 设备坐标转逻辑坐标
pDC->DPtoLP(&ptDevice);
// 示例4：世界变换（Windows NT/2000+）
if (pDC->GetDeviceCaps(RASTERCAPS) & RC_TRANSFORM)
{
XFORM xform;
// 设置旋转矩阵（旋转30度）
float fAngle = 30.0f * 3.14159f / 180.0f;
xform.eM11 = cos(fAngle);
xform.eM12 = sin(fAngle);
xform.eM21 = -sin(fAngle);
xform.eM22 = cos(fAngle);
xform.eDx = 100.0f; // X方向平移
xform.eDy = 100.0f; // Y方向平移
// 设置世界变换
pDC->SetGraphicsMode(GM_ADVANCED);
pDC->SetWorldTransform(&xform);
// 绘制变换后的图形
pDC->Rectangle(0, 0, 100, 100);
// 恢复默认变换
pDC->ModifyWorldTransform(NULL, MWT_IDENTITY);
}
// 恢复原始DC状态
pDC->RestoreDC(nOldMapMode);
}五、字体与文本渲染
5.1 字体创建与文本度量
cpp
class CTextRenderer
{
private:
CFont m_fontNormal;
CFont m_fontBold;
CFont m_fontItalic;
public:
BOOL InitializeFonts()
{
// 创建不同风格的字体
LOGFONT lf = {0};
// 标准字体
lf.lfHeight = -16; // 16像素高（负值表示字符高度）
lf.lfWeight = FW_NORMAL;
lf.lfCharSet = DEFAULT_CHARSET;
lstrcpy(lf.lfFaceName, _T("微软雅黑"));
m_fontNormal.CreateFontIndirect(&lf);
// 粗体
lf.lfWeight = FW_BOLD;
m_fontBold.CreateFontIndirect(&lf);
// 斜体
lf.lfWeight = FW_NORMAL;
lf.lfItalic = TRUE;
m_fontItalic.CreateFontIndirect(&lf);
return TRUE;
}
void DrawTextWithMetrics(CDC* pDC, int x, int y, LPCTSTR lpszText)
{
CFont* pOldFont = pDC->SelectObject(&m_fontNormal);
// 获取文本度量信息
TEXTMETRIC tm;
pDC->GetTextMetrics(&tm);
// 计算文本宽度
CSize sizeText = pDC->GetTextExtent(lpszText, lstrlen(lpszText));
// 绘制背景
CRect rectText(x, y, x + sizeText.cx, y + tm.tmHeight);
CBrush brushBg(RGB(240, 240, 240));
pDC->FillRect(&rectText, &brushBg);
// 绘制文本
pDC->SetBkMode(TRANSPARENT);
pDC->TextOut(x, y, lpszText);
// 绘制基线
CPen penBaseline(PS_SOLID, 1, RGB(255, 0, 0));
CPen* pOldPen = pDC->SelectObject(&penBaseline);
pDC->MoveTo(x, y + tm.tmAscent);
pDC->LineTo(x + sizeText.cx, y + tm.tmAscent);
// 绘制边界框
CPen penBorder(PS_DOT, 1, RGB(0, 0, 255));
pDC->SelectObject(&penBorder);
pDC->SelectStockObject(NULL_BRUSH);
pDC->Rectangle(&rectText);
pDC->SelectObject(pOldPen);
pDC->SelectObject(pOldFont);
}
// 多行文本绘制
void DrawMultilineText(CDC* pDC, CRect rect, LPCTSTR lpszText)
{
CFont* pOldFont = pDC->SelectObject(&m_fontNormal);
// 设置文本格式
UINT uFormat = DT_LEFT | DT_WORDBREAK | DT_NOPREFIX | DT_EDITCONTROL;
// 计算需要的矩形高度
CRect rectCalc = rect;
pDC->DrawText(lpszText, -1, &rectCalc, uFormat | DT_CALCRECT);
// 绘制文本
pDC->DrawText(lpszText, -1, &rect, uFormat);
pDC->SelectObject(pOldFont);
}
};5.2 高级文本效果
cpp
void CMyView::DrawTextEffects(CDC* pDC)
{
CRect rectClient;
GetClientRect(&rectClient);
// 1. 阴影文字
DrawShadowText(pDC, _T("阴影效果"),
CPoint(50, 50),
RGB(0, 0, 0), RGB(255, 255, 255));
// 2. 渐变文字
DrawGradientText(pDC, _T("渐变文字"),
CPoint(50, 100),
RGB(255, 0, 0), RGB(0, 0, 255));
// 3. 轮廓文字
DrawOutlineText(pDC, _T("轮廓文字"),
CPoint(50, 150),
3, RGB(255, 255, 255), RGB(0, 0, 0));
}
void DrawShadowText(CDC* pDC, LPCTSTR lpszText, CPoint pt,
COLORREF crText, COLORREF crShadow)
{
CFont font;
LOGFONT lf = {0};
lf.lfHeight = -48;
lf.lfWeight = FW_BOLD;
lstrcpy(lf.lfFaceName, _T("Arial"));
font.CreateFontIndirect(&lf);
CFont* pOldFont = pDC->SelectObject(&font);
// 绘制阴影
pDC->SetTextColor(crShadow);
pDC->TextOut(pt.x + 3, pt.y + 3, lpszText);
// 绘制前景文字
pDC->SetTextColor(crText);
pDC->TextOut(pt.x, pt.y, lpszText);
pDC->SelectObject(pOldFont);
}
void DrawGradientText(CDC* pDC, LPCTSTR lpszText, CPoint pt,
COLORREF crStart, COLORREF crEnd)
{
// 创建字体
CFont font;
LOGFONT lf = {0};
lf.lfHeight = -48;
lf.lfWeight = FW_BOLD;
lstrcpy(lf.lfFaceName, _T("Arial"));
font.CreateFontIndirect(&lf);
CFont* pOldFont = pDC->SelectObject(&font);
// 获取文本尺寸
CSize sizeText = pDC->GetTextExtent(lpszText, lstrlen(lpszText));
// 创建渐变画刷
TRIVERTEX vert[2] = {0};
vert[0].x = pt.x;
vert[0].y = pt.y;
vert[0].Red = GetRValue(crStart) << 8;
vert[0].Green = GetGValue(crStart) << 8;
vert[0].Blue = GetBValue(crStart) << 8;
vert[0].Alpha = 0x0000;
vert[1].x = pt.x + sizeText.cx;
vert[1].y = pt.y + sizeText.cy;
vert[1].Red = GetRValue(crEnd) << 8;
vert[1].Green = GetGValue(crEnd) << 8;
vert[1].Blue = GetBValue(crEnd) << 8;
vert[1].Alpha = 0x0000;
GRADIENT_RECT gRect = {0, 1};
// 使用路径创建文本轮廓
pDC->BeginPath();
pDC->TextOut(pt.x, pt.y, lpszText);
pDC->EndPath();
// 用渐变填充文本路径
pDC->SelectClipPath(RGN_COPY);
pDC->GradientFill(vert, 2, &gRect, 1, GRADIENT_FILL_RECT_H);
pDC->SelectObject(pOldFont);
}六、位图操作与图像处理
6.1 位图加载与显示优化
cpp
class CBitmapManager
{
private:
CMap<UINT, UINT, CBitmap*, CBitmap*> m_mapBitmaps;
CSize m_sizeDisplay; // 显示尺寸缓存
public:
CBitmapManager() : m_sizeDisplay(0, 0) {}
virtual ~CBitmapManager()
{
Cleanup();
}
// 从资源加载位图
CBitmap* LoadBitmapFromResource(UINT nIDResource,
CSize sizeTarget = CSize(0, 0))
{
CBitmap* pBitmap = NULL;
if (m_mapBitmaps.Lookup(nIDResource, pBitmap))
return pBitmap;
// 加载原始位图
CBitmap bmpOriginal;
if (!bmpOriginal.LoadBitmap(nIDResource))
return NULL;
// 获取原始尺寸
BITMAP bmInfo;
bmpOriginal.GetBitmap(&bmInfo);
CSize sizeSource(bmInfo.bmWidth, bmInfo.bmHeight);
// 如果需要缩放
if (sizeTarget.cx > 0 && sizeTarget.cy > 0 &&
(sizeTarget != sizeSource))
{
pBitmap = ScaleBitmap(&bmpOriginal, sizeSource, sizeTarget);
}
else
{
pBitmap = new CBitmap;
pBitmap->Attach(bmpOriginal.Detach());
}
m_mapBitmaps.SetAt(nIDResource, pBitmap);
return pBitmap;
}
// 位图缩放函数
CBitmap* ScaleBitmap(CBitmap* pSrcBitmap, CSize sizeSrc, CSize sizeDst)
{
// 创建源DC和目标DC
CWindowDC dcScreen(NULL);
CDC dcSrc, dcDst;
dcSrc.CreateCompatibleDC(&dcScreen);
dcDst.CreateCompatibleDC(&dcScreen);
// 创建目标位图
CBitmap* pDstBitmap = new CBitmap;
pDstBitmap->CreateCompatibleBitmap(&dcScreen,
sizeDst.cx, sizeDst.cy);
// 选入位图
CBitmap* pOldSrcBitmap = dcSrc.SelectObject(pSrcBitmap);
CBitmap* pOldDstBitmap = dcDst.SelectObject(pDstBitmap);
// 设置拉伸模式
dcDst.SetStretchBltMode(HALFTONE);
dcDst.SetBrushOrg(0, 0);
// 执行缩放
dcDst.StretchBlt(0, 0, sizeDst.cx, sizeDst.cy,
&dcSrc, 0, 0, sizeSrc.cx, sizeSrc.cy,
SRCCOPY);
// 恢复并清理
dcSrc.SelectObject(pOldSrcBitmap);
dcDst.SelectObject(pOldDstBitmap);
return pDstBitmap;
}
// 透明位图绘制
void DrawTransparentBitmap(CDC* pDC, CBitmap* pBitmap,
CPoint ptDest, COLORREF crTransparent)
{
// 创建内存DC
CDC dcMem, dcMask;
dcMem.CreateCompatibleDC(pDC);
dcMask.CreateCompatibleDC(pDC);
// 获取位图尺寸
BITMAP bm;
pBitmap->GetBitmap(&bm);
// 创建掩码位图
CBitmap bmpMask;
bmpMask.CreateBitmap(bm.bmWidth, bm.bmHeight, 1, 1, NULL);
// 选入位图
CBitmap* pOldMemBitmap = dcMem.SelectObject(pBitmap);
CBitmap* pOldMaskBitmap = dcMask.SelectObject(&bmpMask);
// 设置透明色
COLORREF crOldBk = dcMem.SetBkColor(crTransparent);
// 创建掩码（透明区域为1，非透明区域为0）
dcMask.BitBlt(0, 0, bm.bmWidth, bm.bmHeight,
&dcMem, 0, 0, SRCCOPY);
// 在目标DC上使用掩码
pDC->BitBlt(ptDest.x, ptDest.y, bm.bmWidth, bm.bmHeight,
&dcMask, 0, 0, SRCAND);
// 设置背景色并绘制
dcMem.SetBkColor(RGB(0, 0, 0));
dcMem.SetTextColor(RGB(255, 255, 255));
dcMem.BitBlt(0, 0, bm.bmWidth, bm.bmHeight,
&dcMask, 0, 0, SRCAND);
// 合并结果
pDC->BitBlt(ptDest.x, ptDest.y, bm.bmWidth, bm.bmHeight,
&dcMem, 0, 0, SRCPAINT);
// 恢复
dcMem.SetBkColor(crOldBk);
dcMem.SelectObject(pOldMemBitmap);
dcMask.SelectObject(pOldMaskBitmap);
}
void Cleanup()
{
POSITION pos = m_mapBitmaps.GetStartPosition();
UINT nID;
CBitmap* pBitmap;
while (pos != NULL)
{
m_mapBitmaps.GetNextAssoc(pos, nID, pBitmap);
delete pBitmap;
}
m_mapBitmaps.RemoveAll();
}
};6.2 图像特效处理
cpp
// 简单的图像处理过滤器
class CImageFilter
{
public:
// 灰度化
static void ConvertToGrayScale(CDC* pDC, CBitmap* pBitmap,
const CRect& rect)
{
// 获取位图信息
BITMAP bm;
pBitmap->GetBitmap(&bm);
// 创建内存DC
CDC dcMem;
dcMem.CreateCompatibleDC(pDC);
CBitmap* pOldBitmap = dcMem.SelectObject(pBitmap);
// 逐像素处理
for (int y = rect.top; y < rect.bottom; y++)
{
for (int x = rect.left; x < rect.right; x++)
{
COLORREF cr = dcMem.GetPixel(x, y);
// 计算灰度值
BYTE r = GetRValue(cr);
BYTE g = GetGValue(cr);
BYTE b = GetBValue(cr);
BYTE gray = (BYTE)(0.299 * r + 0.587 * g + 0.114 * b);
// 设置灰度像素
dcMem.SetPixel(x, y, RGB(gray, gray, gray));
}
}
dcMem.SelectObject(pOldBitmap);
}
// 亮度调整
static void AdjustBrightness(CDC* pDC, CBitmap* pBitmap,
const CRect& rect, int nDelta)
{
CDC dcMem;
dcMem.CreateCompatibleDC(pDC);
CBitmap* pOldBitmap = dcMem.SelectObject(pBitmap);
for (int y = rect.top; y < rect.bottom; y++)
{
for (int x = rect.left; x < rect.right; x++)
{
COLORREF cr = dcMem.GetPixel(x, y);
BYTE r = Clamp(GetRValue(cr) + nDelta);
BYTE g = Clamp(GetGValue(cr) + nDelta);
BYTE b = Clamp(GetBValue(cr) + nDelta);
dcMem.SetPixel(x, y, RGB(r, g, b));
}
}
dcMem.SelectObject(pOldBitmap);
}
// 对比度调整
static void AdjustContrast(CDC* pDC, CBitmap* pBitmap,
const CRect& rect, double dContrast)
{
CDC dcMem;
dcMem.CreateCompatibleDC(pDC);
CBitmap* pOldBitmap = dcMem.SelectObject(pBitmap);
for (int y = rect.top; y < rect.bottom; y++)
{
for (int x = rect.left; x < rect.right; x++)
{
COLORREF cr = dcMem.GetPixel(x, y);
BYTE r = Clamp((int)((GetRValue(cr) - 128) * dContrast + 128));
BYTE g = Clamp((int)((GetGValue(cr) - 128) * dContrast + 128));
BYTE b = Clamp((int)((GetBValue(cr) - 128) * dContrast + 128));
dcMem.SetPixel(x, y, RGB(r, g, b));
}
}
dcMem.SelectObject(pOldBitmap);
}
private:
static BYTE Clamp(int value)
{
if (value < 0) return 0;
if (value > 255) return 255;
return (BYTE)value;
}
};七、打印与打印预览
7.1 打印架构的实现
cpp
// 支持打印的视图类
class CPrintableView : public CView
{
protected:
// 打印相关成员
CPrintInfo m_printInfo;
int m_nPageWidth;
int m_nPageHeight;
int m_nCurPage;
public:
virtual void OnPreparePrinting(CPrintInfo* pInfo)
{
// 设置打印对话框默认值
pInfo->SetMaxPage(10); // 假设最多10页
pInfo->SetMinPage(1);
// 调用DoPreparePrinting显示打印对话框
DoPreparePrinting(pInfo);
}
virtual void OnBeginPrinting(CDC* pDC, CPrintInfo* pInfo)
{
// 获取打印机DC能力
m_nPageWidth = pDC->GetDeviceCaps(HORZRES);
m_nPageHeight = pDC->GetDeviceCaps(VERTRES);
// 计算总页数
CMyDocument* pDoc = GetDocument();
int nTotalLines = pDoc->GetLineCount();
int nLinesPerPage = m_nPageHeight / 20; // 假设每行20像素
pInfo->SetMaxPage((nTotalLines + nLinesPerPage - 1) / nLinesPerPage);
// 创建打印字体
LOGFONT lfPrint = {0};
lfPrint.lfHeight = -15; // 打印字体稍小
lfPrint.lfWeight = FW_NORMAL;
lstrcpy(lfPrint.lfFaceName, _T("宋体"));
m_fontPrint.CreateFontIndirect(&lfPrint);
}
virtual void OnPrint(CDC* pDC, CPrintInfo* pInfo)
{
m_nCurPage = pInfo->m_nCurPage;
// 设置映射模式
pDC->SetMapMode(MM_TEXT);
// 设置字体
CFont* pOldFont = pDC->SelectObject(&m_fontPrint);
// 打印页眉
PrintHeader(pDC);
// 打印内容
PrintPageContent(pDC, pInfo->m_nCurPage);
// 打印页脚
PrintFooter(pDC);
pDC->SelectObject(pOldFont);
}
virtual void OnEndPrinting(CDC* /*pDC*/, CPrintInfo* /*pInfo*/)
{
// 清理打印资源
m_fontPrint.DeleteObject();
}
protected:
CFont m_fontPrint;
void PrintHeader(CDC* pDC)
{
CString strHeader;
strHeader.Format(_T("第 %d 页"), m_nCurPage);
pDC->TextOut(100, 50, strHeader);
// 绘制页眉线
pDC->MoveTo(50, 80);
pDC->LineTo(m_nPageWidth - 50, 80);
}
void PrintPageContent(CDC* pDC, int nPage)
{
CMyDocument* pDoc = GetDocument();
// 计算本页显示的行范围
int nLinesPerPage = (m_nPageHeight - 150) / 20; // 考虑页眉页脚
int nStartLine = (nPage - 1) * nLinesPerPage;
int nEndLine = min(nStartLine + nLinesPerPage,
pDoc->GetLineCount());
// 逐行打印
for (int i = nStartLine; i < nEndLine; i++)
{
int y = 100 + (i - nStartLine) * 20;
pDC->TextOut(100, y, pDoc->GetLine(i));
}
}
void PrintFooter(CDC* pDC)
{
CString strFooter = CTime::GetCurrentTime().Format(_T("%Y-%m-%d %H:%M:%S"));
// 绘制页脚线
pDC->MoveTo(50, m_nPageHeight - 70);
pDC->LineTo(m_nPageWidth - 50, m_nPageHeight - 70);
// 打印页脚文本
pDC->TextOut(100, m_nPageHeight - 50, strFooter);
}
};八、性能优化与最佳实践
8.1 GDI资源泄漏检测
cpp
#ifdef _DEBUG
class CGdiLeakDetector
{
private:
static int m_nGdiObjectsStart;
public:
CGdiLeakDetector()
{
// 记录初始GDI对象数量
m_nGdiObjectsStart = GetGuiResources(GetCurrentProcess(),
GR_GDIOBJECTS);
}
~CGdiLeakDetector()
{
// 检查GDI对象泄漏
int nGdiObjectsEnd = GetGuiResources(GetCurrentProcess(),
GR_GDIOBJECTS);
if (nGdiObjectsEnd > m_nGdiObjectsStart)
{
TRACE(_T("警告：检测到可能的GDI对象泄漏。\n"));
TRACE(_T("初始: %d, 结束: %d, 泄漏: %d\n"),
m_nGdiObjectsStart, nGdiObjectsEnd,
nGdiObjectsEnd - m_nGdiObjectsStart);
// 在调试时触发断点
if (IsDebuggerPresent())
{
DebugBreak();
}
}
}
};
// 在应用程序类中使用
class CMyApp : public CWinApp
{
private:
CGdiLeakDetector m_gdiDetector;
// ...
};
#endif8.2 绘图缓存与增量更新
cpp
class CDrawingCache
{
private:
CBitmap m_bmpCache; // 缓存位图
CRect m_rectCache; // 缓存区域
BOOL m_bCacheValid; // 缓存有效性标志
public:
CDrawingCache() : m_bCacheValid(FALSE) {}
// 更新缓存
void UpdateCache(CDC* pDC, const CRect& rect)
{
if (!m_bCacheValid || m_rectCache != rect)
{
// 创建或重新创建缓存位图
if (m_bmpCache.GetSafeHandle() == NULL ||
m_rectCache != rect)
{
m_bmpCache.DeleteObject();
m_bmpCache.CreateCompatibleBitmap(pDC,
rect.Width(),
rect.Height());
m_rectCache = rect;
}
// 绘制到缓存
CDC dcCache;
dcCache.CreateCompatibleDC(pDC);
CBitmap* pOldBmp = dcCache.SelectObject(&m_bmpCache);
// 绘制背景和内容到缓存
DrawToCache(&dcCache, rect);
dcCache.SelectObject(pOldBmp);
m_bCacheValid = TRUE;
}
}
// 从缓存绘制到屏幕
void RenderFromCache(CDC* pDC, const CPoint& ptDest)
{
if (m_bCacheValid)
{
CDC dcCache;
dcCache.CreateCompatibleDC(pDC);
CBitmap* pOldBmp = dcCache.SelectObject(&m_bmpCache);
pDC->BitBlt(ptDest.x, ptDest.y,
m_rectCache.Width(), m_rectCache.Height(),
&dcCache, 0, 0, SRCCOPY);
dcCache.SelectObject(pOldBmp);
}
}
// 使缓存失效
void InvalidateCache()
{
m_bCacheValid = FALSE;
}
// 部分缓存失效
void InvalidateCacheRect(const CRect& rectInvalid)
{
if (m_bCacheValid && m_rectCache.IntersectRect(&rectInvalid))
{
// 只重新绘制受影响的部分
CDC dcCache;
CClientDC dcScreen(NULL);
dcCache.CreateCompatibleDC(&dcScreen);
CBitmap* pOldBmp = dcCache.SelectObject(&m_bmpCache);
// 清除受影响区域
CBrush brushBg(RGB(255, 255, 255));
dcCache.FillRect(&rectInvalid, &brushBg);
// 重新绘制受影响区域
RedrawInvalidArea(&dcCache, rectInvalid);
dcCache.SelectObject(pOldBmp);
}
}
protected:
virtual void DrawToCache(CDC* pDC, const CRect& rect) = 0;
virtual void RedrawInvalidArea(CDC* pDC, const CRect& rect) = 0;
};九、与现代图形API的对比
虽然GDI已经逐渐被Direct2D、DirectWrite等现代图形API取代，但理解GDI的设计仍有价值：
- 设备抽象层：GDI的设备上下文概念影响了后续API的设计
- 资源管理模型：GDI对象的创建/选择/删除模式为后来的资源管理提供了参考
- 坐标系统：GDI的映射模式为图形变换奠定了基础
迁移策略：
- 对于新项目，推荐使用Direct2D/DirectWrite或跨平台图形库
- 对于现有MFC项目，可逐步替换绘图代码，同时保留业务逻辑
- GDI仍适用于简单的UI绘制和打印功能
MFC的GDI编程代表了Windows图形编程的一个时代，虽然技术已经演进，但其设计思想和问题解决方案仍对理解计算机图形学基本原理有重要价值。掌握GDI不仅有助于维护遗留代码，更能深刻理解图形系统的工作机制。