MFC四大关键技术
MFC 游戏 常用技术
半透明处理4-1
半透明在游戏中通常用来呈现若隐若现的特殊 效果。事实上这种效果的运用相当频繁，比如 雾气、鬼魂或隐形人物等，有时会以半透明的 手法来表现 先分析下不透明处理，可以认为原来不透明处 理的前景图不透明度为100%，而背景的在这 块区域上的不透明度则为0%（完全透明，所 不到背景），也就是背景在这块区域中色彩完 全没有
双缓冲实现2-1
实现双缓冲可以由四个步骤完成：
1. 为屏幕 DC 创建兼容的内存 DC ,使用CDC成员函 数：CDC::CreateCompatibleDC()； 2. 创建内存位图： CBitmap::CreateCompatibleBitmap() ； 3. 把内存位图选入设备环境：CDC::SelectObject()， 可以理解为选择画布 ,然后开始绘图操作； 4. 把绘制好的图形“拷贝“到屏幕上： CDC::BitBlt() 。
半透明处理4-2
可是如果想要有半透明效果，设确定不透 明度是60%，也就是说前景图像素颜色在显示位置 上的比例是60%，而剩下的40%当然就是背景像素 的RGB颜色 如果可以将要显示区域的每一个像素颜色按照一定 的不透明度比例进行合成，那么最后整个区域所呈 现出来的就是所要的半透明效果了。综上述可以得 出一个简单的公式：
位图透明处理5-4
屏蔽图背景是白色 去背部分必需是黑色 屏蔽图精灵部分是黑色
上图左边为前景图，右边黑白图称为“屏蔽 图”，在透明的过程会用到它。 实现步骤：
1. 首先将整个背景图贴到目的地DC中 2. 将屏蔽图与背景图做“AND”（Raster值为 SRCAND）运算，贴到目的地DC中 3. 将前景图与背景图做“OR”（Raster值SRCPAINT） 运算，贴到目的地DC中
MFC六大关键技术
MFC六大关键技术是什么？1MFC程序的初始化过程2RTTI 动态类型标识3Dynamic Creation 动态生成4Persistence 永久保留5Message Mapping 信息映射6Message Routing 信息传递怎样自制RTTI？我们作为类库的设计者要在类构造起来的时候，记录必要的信息，以建立型录。
型录中的类的信息，最好以链表方式连接起来。
一般“类别型录”是一个结构，其中至少需要类名字，链表的Next 指针，以及链表的First指针。
First属于整体变量，一份就好，所以用static修饰。
为了将每一个类都能拥有成员变量集合，并且最好有一定的命名规则，然后经某种手段将整个类库构造好之后，“类别型录”（就是各个CRuntimeClass对象）则能呈现为：什么是DECLARE_DYNAMIC/IMPLEMENT_DYNAMIC 宏？作用就是完成RTTI的“类别型录”。
为了将一个类对象塞到类之中，并定义一个可以捕捉到该对象地址的函数，定义一个宏为：#define DECLARE_DYNAMIC(class_name)public:static CRuntimeClass class##class_name;virtual CRuntimeClass* GetRuntimeClass()const;比如我使用了DECLARE_DYNAMIC(CView)编译器预处理器为我做出的代码是：public:static CRuntimeClass classCView;virtual CRuntimeClass * GetRuntimeClass()const;也就是定义类时，将类放入DECLARE_DYNAMIC宏就是把要放的对象放到了里边。
具体连接工作是由IMPLEMENT_DYNAMIC宏来实现：#define IMPLEMENT_DYNAMIC(class_name,base_class_name)_IMPLEMENT_RUNTIMECLASS(class_name,base_class_name,0xFFFF,NULL)这里不做扩展，总之，IMPLEMENT_DYNAMIC内容不仅制定初值，它使用了一个struct AFX_CLASSINIT {AFX_CLASSINTI(CRuntimeClass * pNewClass);};(c++的struct和class都有构造函数)：AFX_CLASSINIT::AFX_CLASSINIT(CRuntimeClass*pNewClass){ pNewClass->m_NextClass = CRuntimeClass::pFirstClass; CRuntimeClass::pFirstClass = pNewClass;}就是上边的这个构造函数完成了连接工作。
MFC中的DC、CDC、HDC、句柄、设备
MFC中的DC、CDC、HDC、句柄、设备上下文究竟是什么意思？在MFC程序中,我们并不经常直接调用Windows API,而是从MFC类创建对象并调用属于这些对象的成员函数.也就是说MFC封装了Windows API 你说你喜欢C++而MFC换一种说法就是一个用C++写的一个函数库然后你来调用只不过这个类不是你写的MFC提供数百个类，最重要的、也是编写任何VC++应用程序都必不可少的两个类CWinApp和CFrameWnd,这两个类是编写复杂庞大应用程序的基石。
1>封装特性：构成MFC框架的是MFC类库而MFC类库又是C++的一个类库。
这些类封装WIN32应用程序编程接口，OLE(Object Link Embed 对象链接嵌入)特性，ODBC和DAO数据访问的功能。
2>继承特性：MFC抽象出了众多类的共同特性，并设计出一些基类作为实现其他类的基础，这些类中最重要的类是CObject类和CCmdTarget类，程序员可以从适当的MFC类中派生出自己的类，实现特定的功能达到编程的目的。
3>虚拟和消息映射：MFC是以C++为基础，当然支持虚函数，但作为一个编程框架必须要解决的是效率问题：如果MFC仅仅通过虚函数来支持动态约束必然会产生大量的虚函数表这样编程框架过于臃肿而且消耗更多的内存。
但是MFC建立了消息映射机制这样降低了内存的使用却大大提高了效率消息映射是一个将消息和成员函数相互关联的表,当应用程序的框架窗口接收到一个消息时,MFC将搜索该窗口的消息映射,如果存在一个处理消息的处理程序,那么就调用该处理程序.它通过宏来实现消息到成员函数的映射，而且这些函数不必是虚拟的成员函数，这样不需要为消息映射函数生成一个很大的虚拟函数表(V表)，节省内存。
MFC消息映射机制:将消息与消息处理函数联系起来，形成一一对应的机制。
消息映射宏声明：DECLARE_MESSAGE_MAP定义：BEGIN_MESSAGE_MAPON_COMMANDON_CONTROLON_MESSAGEEND_MESSAGE_MAPMFC主要组成部分：类、宏和全局函数。
MFC技术知识
MFC技术知识1. 什么是质量流量计？什么是质量流量控制器？质量流量计，即Mass Flow Meter （缩写为MFM ）, 是⼀种精确测量⽓体流量的仪表，其测量值不因温度或压⼒的波动⽽失准，不需要温度压⼒补偿。
质量流量控制器, 即Mass Flow Controller （缩写为MFC ）, 不但具有质量流量计的功能，更重要的是，它能⾃动控制⽓体流量，即⽤户可根据需要进⾏流量设定，MFC ⾃动地将流量恒定在设定值上，即使系统压⼒有波动或环境温度有变化，也不会使其偏离设定值。
简单地说,质量流量控制器就是⼀个稳流装置, 是⼀个可以⼿动设定或与计算机联接⾃动控制的⽓体稳流装置。
2. 质量流量控制器的原理是什么？质量流量控制器由流量传感器、分流器通道、流量调节阀门和放⼤控制器等部分组成。
质量流量控制器的剖⾯结构图见图1。
⽓体流量传感器采⽤⽑细管传热温差量热法原理测量⽓体的质量流量(⽆需温度压⼒补偿)。
将传感器加热电桥测得的流量信号送⼊放⼤器放⼤, 放⼤后的流量检测电压与设定电压进⾏⽐较, 再将差值信号放⼤后去控制调节阀门，闭环控制流过通道的流量使之与设定的流量相等。
分流器决定主通道的流量。
与质量流量控制器配套的流量显⽰仪上设置有稳压电源,数字电压表, 设定电位器, 外设、内设转换和三位阀控开关等。
⽓体质量流量控制器与流量显⽰仪连接后的⼯作原理如图2所⽰。
图1. 质量流量控制器结构图图2. 质量流量控制器原理图3. 怎么理解质量流量计/质量流量控制器的流量单位？⽓体质量流量单位⼀般以sccm （Standard Cubic Centimeter per Minute,每分钟标准毫升）和slm （Standard Liter per Minute,每分钟标准升）来表⽰。
这意味着，这种仪表在不同的使⽤条件下，指⽰的流量均是标准状态下的流量。
标准状态规定为: ⽓压—101325Pa (760mm Hg); 温度—0℃ (273.15K)。
臭氧在污水处理中的应用
臭氧在污水处理中的应用随着工业和城市的快速发展，污水的处理问题越来越受到人们的。
传统的物理、化学或生物处理方法虽然在一定程度上能够解决污水问题，但它们的局限性也日益凸显。
此时，臭氧作为一种强氧化剂，以其独特的优势在污水处理领域开始受到重视。
臭氧是一种由三个氧原子组成的分子，在常温常压下为蓝色气体。
它的强氧化性使其在许多化学反应中作为催化剂，从而在污水处理中发挥重要作用。
臭氧能够分解有机物、杀灭细菌和病毒，并且对环境无害。
臭氧可以用于污水灭菌。
许多病菌和病毒在污水中生存并繁殖，对环境和人类健康构成威胁。
臭氧的强氧化性能有效地破坏这些微生物的细胞壁和DNA，从而杀死这些病菌和病毒。
经过臭氧处理的污水，其卫生状况可以得到显著改善。
臭氧可以用于污水中有机物的分解。
在污水中，存在着许多有机物质，如纤维素、脂肪和蛋白质等。
这些物质如果未经处理直接排放，可能会对环境和生态系统产生负面影响。
臭氧可以有效地分解这些有机物质，将其转化为无害的物质，如二氧化碳和水。
臭氧还可以用于污水的脱色和除臭。
有些污水含有色素和有机酸，这些物质的存在会使污水变色并产生异味。
臭氧可以氧化这些物质，从而起到脱色和除臭的作用。
虽然臭氧在污水处理中具有许多优点，但它的应用也存在一些限制。
例如，臭氧的处理效率受限于它的分解速度和扩散效果。
臭氧的处理费用相对较高，可能会增加污水处理的成本。
因此，在实际应用中，需要根据实际情况进行综合考虑。
臭氧在污水处理中具有显著的优势和潜力。
随着科学技术的进步和新材料的应用，我们有理由相信，臭氧在污水处理中的应用将会得到更广泛的发展。
臭氧催化氧化法是一种在污水处理中常用的高级氧化技术。
这种技术利用臭氧的强氧化性，将废水中的有机污染物转化为无害或低毒性的物质，从而实现废水的净化。
在过去的几十年中，臭氧催化氧化法在污水处理领域取得了显著的进展。
研究人员发现，通过添加催化剂，可以显著提高臭氧的氧化效率。
这些催化剂包括金属氧化物、金属离子、活性炭等。
MFC关键技术
一、MFC初始化过程1、构造全局对象CWinApp2、WinMain中通过AfxGetApp()得到指向该全局对象的指针pApp（CWinApp* pApp = AfxGetApp();）3、调用pApp->InitApplication()4、调用pApp->InitInstance() 在InitInstance中注册、显示窗口5、调用run()函数开始消息循环其中，CWinApp中有一个成员变量m_pMainWnd,在InitInstance中会new一个CWnd类给这个指针，然后会register并Create这个窗口。
在Create中会先调用preCreateWindow函数来根据客户需求设置窗口参数。
再细节一点，在InitInstance中先调用AfxEndDeferRegisterClass注册窗口，然后再调用preCreateWindow。
根据孙鑫的视频所讲，一般的顺序应是在preCreateWindow里注册窗口，但是MFC为了一些需要先注册的窗口再调用preCreateWindow。
当然这是不影响结果的。
二、RTTI运行时类型识别文档视图之下，支撑着它的是运行时类型信息(RTTI)。
RTTI允许程序在运行时刻获得类乃至普通类型的信息，这是怎么做到的，其实原理很简单，就是事先将这些信息保存为某种数据结构，保存的工作或由编译器帮你做，或由程序自己完成。
程序运行的时候通过某种途径取得这些信息，然后根据这些信息来做运行时判断。
MFC中保存类型信息的是一个叫CRuntimeClass的结构体。
struct CRuntimeClass{//类名LPCSTR m_lpszClassName;//类实例大小int m_nObjectSize;//是否支持序列化的标志UINT m_wSchema;//创建类实例的函数指针CObject* (PASCAL* m_pfnCreateObject)();//指向基类的运行时结构CRuntimeClass* m_pBaseClass;//创建类实例CObject* CreateObject();//判断是否从某个类继承而来BOOL IsDerivedFrom(const CRuntimeClass* pBaseClass) const;//序列化支持void Store(CArchive& ar) const;static CRuntimeClass* PASCAL Load(CArchive& ar, UINT* pwSchemaNum);//组成运行时结构链表CRuntimeClass* m_pNextClass;};一个具备类型信息的类都必须生成这个运行时结构，并将它保存为自己的静态成员。
MFC基础知识概述
MFC基础知识概述MFC（Microsoft Foundation Classes）是微软公司开发的基于C++的类库，用于Windows操作系统下的图形用户界面（GUI）应用程序开发。
MFC是Windows的主要开发框架，提供了一系列的类和函数，可以用于创建窗口、控件、对话框、菜单等。
本文将对MFC的基础知识进行概述，包括MFC的结构、类层次结构、消息和事件处理、资源管理等内容。
一、MFC的结构MFC的结构主要由四个层次构成：应用程序对象、窗口对象、视图对象和文档对象。
应用程序对象继承自CWinApp类，用于创建和初始化应用程序的整个过程。
窗口对象继承自CWnd类，用于创建和管理窗口。
视图对象继承自CView类，用于显示和处理用户界面上的一部分，通常与窗口对象对应。
文档对象继承自CDocument类，用于管理应用程序中的数据。
二、MFC的类层次结构MFC提供了众多的类和函数，可以用于创建各种窗口、控件、对话框等。
类层次结构是指这些类的继承关系。
MFC的类层次结构非常庞大，以CObject类为基类，派生出众多的中间类，再由这些中间类派生出更具体的类。
例如，CObject派生出CWnd，CWnd派生出CFrameWnd，CFrameWnd派生出CView，CView派生出CScrollView和CFormView等。
通过这种类层次结构，可以方便地创建和管理各种类型的窗口和控件。
三、消息和事件处理在MFC中，消息是用于实现窗口和控件之间通信的机制。
当用户操作窗口或控件时，会产生消息，应用程序可以通过消息处理函数来处理这些消息。
MFC提供了一些宏，如DECLARE_MESSAGE_MAP和BEGIN_MESSAGE_MAP，可以简化消息处理函数的定义和注册。
消息处理函数需要通过ON_MESSAGE或ON_COMMAND宏来注册，以告诉MFC在何时何地调用该函数。
事件是消息的一个特殊形式，一般是指用户操作控件时触发的消息。
深入浅出MFC学习笔记(第三章：MFC六大关键技术之仿真：命令传递)
软件英才网软件行业驰名招聘网站命令传递（Command routing）消息如果是仅仅从派生类流向父类，那就非常简单了。
然而MFC用来处理消息的C++类，并不是单线发展的。
document/view也具有处理消息的能力。
因此，消息应该有横向流动的机会。
MFC对消息循环的规定为：1：若是一般的windows消息（WM_xx)则一定是由派生类流向基类。
2：如果是WM_COMMAND消息，就非常复杂了。
要区分接受者的类型：1：接受者若为Frame窗口：处理次序为：View-> Frame窗口本身->CWinApp类。
2：接受者若为View ：处理次序为：View本身->Document;3:接受者若为Document：处理次序为：Document本身->Document template软件英才网软件行业驰名招聘网站因此，接下来我们的任务就是仿真以上的消息传递路线。
以下为需要添加的函数：全局函数AfxWndProc，它是整个消息循环的起始点，本来应该在CWinThread：：Run中被调用，每调用一次就推送一个消息。
模拟windows的disPatch函数。
软件英才网软件行业驰名招聘网站LRESULT AfxWndPro(HWND hWnd,UINT nMsg,WPARAMwParam,LPARAM lParam,CWnd *pWnd) {cout<<"AfxWndProc()"<<endl;return AfxCallWndProc (pWnd,hWnd,nMsg,wParam,lParam); }LRESULT AfxCallWndProc(CWnd*pWnd,HWND hWnd,UINT nMsg,WPARAM wParam,LPARAM lParam)软件英才网软件行业驰名招聘网站{cout<<"AfxCallWndProc"<<endl;LRESULT lResult=pWnd->windowProc(nMsg,wParam,lParam);return lResult;}全局函数AfxCallWndProc用于调用接受消息的类的消息处理函数。
MFC原理介绍
MFC原理介绍一：基础男瓜1、MFC封装了大部分的Windows API函数，由C格式的函数库升级为类库。
2、Windows程序开发由面向过程的开发模式晋升为面向对象的开发模式，从而使得Windows软件开发效率大大地提高了。
例如：要将两个字符串连接，在C语言中使用的是strcpy和strcat的函数，而CString类则使用“+”或“+=”符号操作即可。
对比MFC和Win32两个开发平台由此可见一斑。
3、MFC是面向对象开发，因此代码维护和修改的效率比Win32高很多。
比如说：MFC的程序代码一般是50个类，每个类有20个函数便于维护；而Win32程序的代码一共有1000个全局函数，函数没有分类使代码维护难度加大。
4、MFC开发平台还辅助了应用程序向导（MFC AppWizard）和类向导（ClassWizard）等工具，进一步的提高了Windows软件的开发效率。
二：MFC的六大关键技术MFC所有封装类一共200多个，但是MFC的内部技术不只是简单的封装。
MFC的内部总共有六大关键技术，架构起了整个MFC的开发平台。
MFC的六大关键技术包括：a)MFC程序的初始化过程;b)消息映射机制;c)运行时类型识别（RTTI）;d)动态创建;e)永久保存;f)消息传递。
{六大关键技术的目的是为了提高开发效率，开发者只要在局部做简单地修改，即可处理大部分窗口事物。
}三：封装类的原理CTime 类的主要成员 函数原型 函数说明CTime( );缺省构造函数，构造一个无效时间对象CTime( const CTime& timeSrc ); 拷贝构造函数，从另一个对象复制时间CTime( time_t time );构造函数，从C 语言时间句柄构造时间CTime( int nYear, int nMonth, int nDay, int nHour, int nMin, int nSec, int nDST = -1 ); 构造函数，通过年月日时分秒及毫秒构造时间 CTime( const SYSTEMTIME& sysTime, int nDST = -1 ); 从SYSTEMTIME 结构体对象构造时间 CTime( const FILETIME& fileTime, int nDST = -1 ); 从FILETIME 结构体对象构造时间 static CTime GetCurrentTime( ); 获取当前时间time_t GetTime( ) const; 从CTime 对象获取C 语言时间句柄 int GetYear( ) const; 获取年份 int GetMonth( ) const; 获取月份 int GetDay( ) const; 获取日期 int GetHour( ) const; 获取小时 int GetMinute( ) const; 获取分钟 int GetSecond( ) const; 获取秒 int GetDayOfWeek( ) const;获取星期运算符“==”、“!=”、“>”、“=”、“<>”、“>比较两个时间对象1、通过封装CTime 类我们可以认为，一个封装类往往有1个或一些核心的成员数据：a)CTime 中的time_t m_time;b)CSocket 类中的SOCKET m_hSocket; c)CRect 基类中的left,top,right,bottom; d)CWnd 中的HWND m_hWnd;几乎封装类所有的成员函数，都是围绕这个或这些核心的成员数据在工作的。
MFC的结构范文
MFC的结构范文MFC（Microsoft Foundation Class）是微软公司开发的一种在Windows平台上使用的C++类库。
MFC提供了一个面向对象的程序开发框架，使得开发者能够更容易地创建Windows应用程序。
1. 基类(CObject)：MFC的基类是CObject类，它提供了一些基本的功能，如内存管理、运行时类型信息以及对象的串行化等。
其他的MFC类都继承自CObject类。
2. 应用程序类(CWinApp)：应用程序类是MFC 应用程序的入口点，它负责处理程序的初始化和退出等操作。
在应用程序类中，开发者需要重写一些函数来实现自定义的初始化和退出操作。
3. 窗口类(CWnd)：窗口类是MFC中最重要的类之一，它封装了Windows API中的窗口和消息处理等功能。
开发者可以通过窗口类来创建、显示和管理窗口。
4. 对话框类(CDialog)：对话框类是MFC中常用的一种窗口类型，主要用于实现用户界面交互。
对话框类提供了一些常用的控件，如按钮、文本框、列表框等，方便开发者创建交互界面。
5.消息映射机制：MFC中的消息映射机制是其核心之一、通过消息映射机制，开发者可以将窗口中的消息与相应的处理函数关联起来。
当窗口接收到特定的消息时，相应的处理函数会被调用。
6.文档视图架构：MFC还提供了一种文档视图架构，用于实现文档/视图/框架三者之间的交互。
文档类管理文档的数据和操作，视图类负责显示文档的内容，框架类提供了窗口和菜单等框架功能。
除了上述的基本结构之外，MFC还提供了大量的类和函数，用于处理各种任务，如绘图、文件操作、网络编程等。
开发者可以根据自己的需求使用这些类和函数。
总的来说，MFC的结构是一个层次清晰、功能完善的框架，它使得开发者能够更加方便地开发Windows应用程序。
开发者只需要关注自己需要实现的功能，而不需要关心Windows API的细节。
MFC的类库和设计模式的使用使得代码更加模块化、易读性更强，进而提高了开发效率和代码质量。
mfc面试知识点总结
mfc面试知识点总结MFC（Microsoft Foundation Class）是微软公司开发的一套 C++ 库，用于简化 Windows 应用程序的开发。
MFC 提供了一系列的类和函数，用于处理 windows 窗口、消息、事件等，使得开发者能够更快速地完成 Windows 程序的开发。
在 MFC 的面试中，通常会涉及到一些基础知识和高级知识，下面就来总结一些常见的 MFC 面试知识点。
一、MFC 的基本概念1. MFC 是什么？MFC 是 Microsoft Foundation Class 的简称，是微软公司提供的用于简化 Windows 应用程序的开发的一套 C++ 类库。
2. MFC 的特点有哪些？MFC 的特点包括易学易用、功能强大、提供了丰富的类库和工具等。
3. MFC 和 Win32 API 有什么区别？MFC 是建立在 Win32 API 之上的，它封装了 Win32 API，提供了更加高层次的接口，使得开发 Windows 应用程序更加简单和方便。
4. MFC 和 ATL 有什么区别？MFC 是面向传统 Windows 应用程序的开发框架，而 ATL 是为开发高效的 COM 组件而设计的，两者目标不同。
5. MFC 和 .Net 的关系是什么？MFC 是基于 C++ 的框架，而 .Net 是 Microsoft 开发的基于 .Net Framework 的框架，两者属于不同的技术栈。
二、MFC 的基本类和对象1. CWinApp 类CWinApp 是 MFC 应用程序的主类，它代表了一个 MFC 应用程序的实例，通常包含了一个主窗口类对象和一些初始化及清理代码。
2. CFrameWnd 类CFrameWnd 是 MFC 中的主窗口类，它代表了应用程序的主窗口，通常包含了菜单、工具栏等 UI 元素。
3. CView 类CView 是MFC 中的视图类，它用于显示窗口中的用户界面，通常包含了子视图、控件等。
深入浅出MFC学习笔记(第三章MFC六大关键技术之仿真类
第三章：MFC六大关键技术之仿真：类型识别深入理解MFC的内部运行原理，是本次学习《深入浅出MFC》的主要目的。
要模仿的六大技术包括：1：MFC程序的初始化过程。
2：RTTI（Runtime type identification）运行时类型识别。
3：Dynamic creation 动态创建4：Persistence永久保存5：消息映射6：消息传递。
RTTI(运行时类型识别）IsKindOf能够侦测某个对象是否属于某种类。
即判断某一对象所属的类是否是父类或当前类；要达到动态类型识别的能力，必须在构建类继承体系时记录必要的信息，这被称为类型型录表。
MFC以链表的方式建立了此表。
类型型录表的每个元素为CRuntimeClass类型，其定义为：1class CRuntimeClass23{45public:67LPCSTR m_lpszClassName;//对象所属类名89 Int m_nObjectSize；//对象大小1011UINT m_wSchema;//模式号1213 CObject *(PASCAL*m_pfnCreateObject)();//构建函数抽象类为NULL1415 CRuntimeClass *pBaseClasss;//基类CRuntimeClass对象指针。
1617 Static CRuntimeClass *pFirstClass;//链表头指针。
1819 CRuntimeClass *m_pNextClass;//下一指针。
2021};MFC使用此类作为每个类的成员变量。
使用宏定义为每个类定义了自己的CRuntimeClass成员变量。
DECLAR_DYNAMIC和IMPLENMENT_DYNAMIC宏使用这两个宏将CRuntimeClass对象不知不觉放到类之中。
DECLARE_DYNMIC宏定义如下：22#define DELCARE_DYNMIC ( class_name ) \2324public:\2526static CRuntimeClass class##class_name \2728virtual CRuntimeClass *GetRuntimeClass()const;##用来告诉编译器把两个字符串连接起来。
MFC网络编程技巧
MFC网络编程技巧MFC（Microsoft Foundation Classes）是一套用于Windows操作系统上的C++编程框架，它提供了一系列的类和函数，简化了Windows程序的开发。
MFC网络编程则是在MFC框架下进行网络通信的技巧，下面将介绍一些MFC网络编程的重要技巧。
1. 理解TCP/IP和Socket编程：网络编程的核心是理解TCP/IP协议和Socket编程。
TCP/IP协议是Internet上最常用的通信协议，Socket 是对TCP/IP协议的封装，提供了一些类和函数来实现网络通信。
学习TCP/IP协议的基本原理和Socket编程的相关知识是进行MFC网络编程的基础。
2. 使用CAsyncSocket类：MFC框架提供了CAsyncSocket类来简化Socket编程。
CAsyncSocket类封装了Socket编程的各种方法，提供了一些异步操作的函数，比如异步连接、异步发送和异步接收等。
通过使用CAsyncSocket类，可以方便地实现网络通信功能。
3. 处理Socket消息：在MFC应用程序中，Socket的消息处理是通过重载CAsyncSocket类的多个虚函数来实现的。
比如，通过重载OnAccept、OnConnect、OnReceive和OnClose等函数，可以处理Socket 的连接、接收和关闭等事件。
在处理Socket消息时，需要注意及时释放资源，防止内存泄漏。
4. 使用CAsyncSocket的派生类：在实际的网络编程中，通常会创建一个继承自CAsyncSocket的派生类来处理具体的网络通信任务。
通过继承CAsyncSocket类，可以在派生类中实现一些特定的功能，比如客户端的连接、服务器端的接收等。
通过派生类来管理Socket对象，可以更好地组织代码和处理逻辑。
5. 异步发送和接收数据：MFC框架的CAsyncSocket类提供了异步发送和接收数据的函数。
MFC网络编程技巧
MFC网络编程技巧MFC（Microsoft Foundation Classes）是一种应用程序框架，用于开发Windows图形用户界面（GUI）应用程序。
网络编程指的是在MFC应用程序中实现与网络通信相关的功能，例如网络套接字的创建和管理、数据的传输、与服务器进行通信等。
在进行MFC网络编程时，有一些技巧可以帮助我们更好地实现所需的功能，并提高程序的性能和稳定性。
以下是一些关键技巧：1. 充分利用MFC提供的网络类：MFC提供了一些用于网络编程的类，例如CSocket、CAsyncSocket、CSocketFile等。
这些类封装了底层的套接字操作，简化了网络编程的实现。
我们可以充分利用这些类来加快开发速度和减少错误。
2. 使用非阻塞的套接字：默认情况下，使用MFC的CSocket类创建的套接字是阻塞的，也就是说，当套接字执行一些操作时，程序会一直等待直到该操作完成。
这可能导致程序的响应性变差。
为了避免这个问题，我们可以将套接字设置为非阻塞模式，这样套接字操作将不再阻塞程序的执行。
3. 使用消息机制进行异步处理：当我们需要在网络编程中执行一些耗时的操作时，例如等待服务器响应、等待数据传输等，使用异步处理可以避免阻塞用户界面，提高程序的响应性。
可以使用MFC的消息机制（例如PostMessage和SendMessage）来实现异步处理。
4. 错误处理和异常处理：在网络编程中，可能会出现各种错误，例如连接超时、网络中断等。
为了保证程序的健壮性，我们需要进行合适的错误处理和异常处理。
可以使用try-catch语句来捕捉和处理异常，确保程序能够正常处理错误情况。
5. 使用多线程进行并发处理：当需要同时处理多个连接或实现并发功能时，可以使用多线程来提高程序的并发能力。
可以使用MFC提供的CWinThread类来创建和管理线程，实现多线程编程。
6.优化性能：在进行网络编程时，性能是一个非常重要的因素。
可以通过一些优化措施来提高程序的性能，例如减少网络传输的数据量、使用缓冲区减少网络读写的次数、使用合适的数据结构等。
追根究底剖析MFC六大关键技术收藏
追根究底，剖析MFC六大关键技术(第一部分)收藏追根究底，剖析MFC六大关键技术题外话：我并不认为MFC减轻了程序员们的负担，MFC出现的目的虽然似乎是为了让程序员不用懂得太多就可以进行视窗编程，但本人在MFC 里徘徊了很久很久（因为那时没有书本详细介绍MFC的原理），毫无收获。
可能朋友们会说，怎么一定要了解MFC的具体呢，“黑箱”作业不行吗？这不是微软的初衷吗？不行！！！如果这样，我宁愿永远不选择MFC！在学电脑之前，本人学习的东西大都与艺术不无关系，小学时参加过全国书画比赛获银奖。
儿时的爱好就是在一张纸上随心所欲地画画！MFC“黑箱”就象一幅硕大的抽象画（抽象到你不能理解），它用铅笔勾画好线条，然后请你填颜色。
我们怎么能忍受“黑箱”作业？我们选择C++，就是因为它够自由，够艺术，我们可以在此放飞幻想。
所以，我们要攻克MFC。
伟大孙老师在剖析MFC的时候虽然尽心尽力，但可能由于篇幅所限，说得并不大清楚（我相信许多学员都有这方面的感受）。
在此，我突发奇想，想与大家一同分享一下著名的MFC六大关键技术。
从什么地方开始讲起好呢？我觉得回到最初摸索MFC的时候，从基本谈起最好。
因为我知道，一个走过来程序员，总是忘记了当初自己是怎么走过来的，忘记了一个学员最想知道的是什么。
一个小小的问题（一两句话就可以解释的），足学以令手无寸铁的学员头大半个月，所以，我努力回忆当初是怎么让自己豁然开朗的。
转入正题：MFC的六大关键技术包括：MFC程序的初始化过程。
运行时类型识别（RTTI）。
动态创建。
永久保存。
消息映射。
消息传递。
MFC程序的初始化过程1、设计一个简单完整MFC程序，产生一个窗口。
当然这不能让AppWizard自动为我们生成。
我们可以在Win32 Application工程下面那样写：#include <afxwin.h>class MyApp : public CWinApp{public:BOOL InitInstance() //②程序入点{CFrameWnd *Frame=new CFrameWnd();//构造框架m_pMainWnd=Frame; //将m_pMainWnd设定为Frame;Frame->Create(NULL,"最简单的窗口");//建立框架Frame->ShowWindow(SW_SHOW); //显示框架return true; //返回}};MyApp theApp; //①建立应用程序。
3.MFC原理介绍
3.MFC原理介绍包括C++封装原理和MFC六⼤关键技术，以及类向导和MFC应⽤程序向导的使⽤⽅法。
讲解MFC消息映射机制的原理、消息映射函数的建⽴，以及消息发送和接收的⽅法。
CTime类，C语⾔中time函数void CTmDlg::OnButton1(){CTime t = CTime::GetCurrentTime();int nYear = t.GetYear();int nMonth = t.GetMonth();int nDay = t.GetDay();int nHour = t.GetHour();int nMin = t.GetMinute();int nSec = t.GetSecond();int nWeek = t.GetDayOfWeek();//周三CString str;str.Format("当前时间是：%d年%02d⽉%02d⽇ %02d:%02d:%02d",nYear,nMonth,nDay,nHour,nMin,nSec);//AfxMessageBox(str);SetWindowText(str);//SetTimer}void CTmDlg::OnButton2(){time_t tt = time(NULL);tm * pTime = localtime(&tt);int nYear = pTime ->tm_year+1900;int nMonth = pTime ->tm_mon+1;int nDay = pTime ->tm_mday;int nHour = pTime ->tm_hour;int nMin = pTime ->tm_min;int nSec = pTime ->tm_sec;CString str;str.Format("当前时间是：%d年%02d⽉%02d⽇ %02d:%02d:%02d",nYear,nMonth,nDay,nHour,nMin,nSec);//AfxMessageBox(str);SetWindowText(str);//SetTimer}类// MyTime.h: interface for the CMyTime class.////////////////////////////////////////////////////////////////////////#if !defined(AFX_MYTIME_H__A7F50C7B_E6B7_4ED5_BB03_E00EB9935406__INCLUDED_)#define AFX_MYTIME_H__A7F50C7B_E6B7_4ED5_BB03_E00EB9935406__INCLUDED_#if _MSC_VER > 1000#pragma once#endif // _MSC_VER > 1000//⾯向对象（C++）特点：抽象，封装和派⽣，（多态）#include <time.h>class CMyTime{time_t m_time;public:int GetYear() const;static CMyTime GetCurrentTime();CMyTime();~CMyTime();};#endif // !defined(AFX_MYTIME_H__A7F50C7B_E6B7_4ED5_BB03_E00EB9935406__INCLUDED_)// MyTime.h: interface for the CMyTime class.////////////////////////////////////////////////////////////////////////#if !defined(AFX_MYTIME_H__A7F50C7B_E6B7_4ED5_BB03_E00EB9935406__INCLUDED_)#define AFX_MYTIME_H__A7F50C7B_E6B7_4ED5_BB03_E00EB9935406__INCLUDED_#if _MSC_VER > 1000#pragma once#endif// _MSC_VER > 1000//⾯向对象（C++）特点：抽象，封装和派⽣，（多态）#include <time.h>class CMyTime{time_t m_time;public:int GetYear() const;static CMyTime GetCurrentTime();CMyTime();~CMyTime();};#endif// !defined(AFX_MYTIME_H__A7F50C7B_E6B7_4ED5_BB03_E00EB9935406__INCLUDED_)#include "stdafx.h"#include <time.h>#include <stdio.h>#include "MyTime.h"int APIENTRY WinMain(HINSTANCE hInstance,HINSTANCE hPrevInstance,LPSTR lpCmdLine,int nCmdShow){CMyTime t = CMyTime::GetCurrentTime();int nYear = t.GetYear();//CTime time;/* time_t tt = time(NULL);tm * pTime = localtime(&tt);int nYear = pTime ->tm_year+1900;int nMonth = pTime ->tm_mon+1;int nDay = pTime ->tm_mday;int nHour = pTime ->tm_hour;int nMin = pTime ->tm_min;int nSec = pTime ->tm_sec;char s[200];sprintf(s,"当前时间是：%d年%02d⽉%02d⽇ %02d:%02d:%02d",nYear,nMonth,nDay,nHour,nMin,nSec);MessageBox(NULL,s,"提⽰",0);*/return0;}MFC所有封装类⼀共200多个，但是MFC的内部技术不只是简单的封装。
基本概念—MFC篇
基本概念——ＭＦＣ篇微生物燃料电池：（Microbial Fuel Cell，MFC）是一种利用微生物将有机物中的化学能直接转化成电能的装置。
其基本工作原理是：在阳极室厌氧环境下，有机物在微生物作用下分解并释放出电子和质子，电子依靠合适的电子传递介体在生物组分和阳极之间进行有效传递，并通过外电路传递到阴极形成电流，而质子通过质子交换膜传递到阴极，氧化剂(一般为氧气)在阴极得到电子被还原与质子结合成水。
燃料电池：燃料电池(FuelCell)是一种将存在于燃料与氧化剂中的化学能直接转化为电能的发电装置。
燃料和空气分别送进燃料电池，电就被奇妙地生产出来。
它从外表上看有正负极和电解质等，像一个蓄电池，但实质上它不能“储电”而是一个“发电厂”。
电池：电池（battery）指盛有电解质溶液和金属电极以产生电流的杯、槽或其他容器或复合容器的部分空间。
随着科技的进步，电池泛指能产生电能的小型装置。
如太阳能电池。
电池的性能参数主要有电动势、容量、比能量和电阻。
燃料：能通过化学或物理反应（包含反应）释放出能量的物质。
按其形成可以分为固体燃料、液体燃料和气体燃料，还有核燃料。
氧化还原介体：能加速初级电子供体的电子向最终电子受体传递的化合物。
微生物：个体微小，结构简单，通常要用光学显微镜和电子显微镜才能看清楚的生物，统称为微生物。
微生物包括细菌、病毒、霉菌、酵母菌等。
（但有些微生物是肉眼可以看见的，像属于真菌的蘑菇、灵芝等。
）包括细菌、病毒、真菌以及一些小型的原生动物、显微藻类等在内的一大类生物群体，它个体微小，却与人类生活关系密切。
涵盖了有益有害的众多种类，广泛涉及健康、食品、医药、工农业、环保等诸多领域。
细菌：广义的细菌即为原核生物是指一大类细胞核无核膜包裹，只存在称作拟核区（nuclear region)（或拟核）的裸露DNA的原始单细胞生物，包括真细菌（eubacteria）和古生菌（archaea）两大类群。
MFC原理结构说明
MFC原理结构说明MFC（Microsoft Foundation Class）是 Microsoft（微软）为Windows 系统提供的一套程序库，用于开发基于 Windows 操作系统的图形用户界面（GUI）应用程序。
本文将从原理和结构两个方面对 MFC 进行详细说明，以帮助读者更好地理解和应用 MFC 框架。
##一、MFC原理MFC 基于面向对象的思想，将应用程序开发过程中常用的功能封装成类，开发人员可以通过继承这些类并重写相应的函数来实现自定义的功能。
MFC 的核心是由一组 C++ 类组成的库，这些类封装了 Windows API 的复杂性，并提供了大量的应用程序开发工具和框架，简化了 Windows 应用程序的开发过程。
MFC 架构的核心是 CWinApp 类，它是整个应用程序的主类。
CWinApp 类集成了应用程序的生命周期管理、消息处理机制等功能，是 MFC 框架的入口点。
当应用程序启动时，会初始化 CWinApp 类的实例，然后调用它的 InitInstance 函数进行初始化操作，接着进入应用程序的消息循环过程。
消息循环过程中，CWinApp 类会接收并处理系统发送的各种消息，并根据消息的类型调用相应的函数进行处理。
在应用程序退出时，CWinApp 类会调用 ExitInstance 函数进行资源清理操作。
除了 CWinApp 类，MFC 还提供了一系列的窗口类（如 CFrameWnd、CDialog、CWnd等）用于创建和管理窗口。
这些类封装了窗口的创建、显示、响应用户输入等功能，开发人员只需通过继承这些类并重写相应的函数，就可以快速创建和管理窗口。
MFC 还提供了一些扩展类库，如 Doc/View 架构、多文件支持、打印和预览等功能。
Doc/View 架构是 MFC 应用程序中常用的一种架构，它将应用程序的逻辑数据（文档）和用户界面（视图）分离开来，开发人员可以将不同的文档类型和视图类型相互组合，实现复杂的应用程序。
- 1、下载文档前请自行甄别文档内容的完整性，平台不提供额外的编辑、内容补充、找答案等附加服务。
- 2、"仅部分预览"的文档,不可在线预览部分如存在完整性等问题,可反馈申请退款(可完整预览的文档不适用该条件!)。
- 3、如文档侵犯您的权益，请联系客服反馈,我们会尽快为您处理(人工客服工作时间：9:00-18:30)。
MFC六大关键技术(第四部分)——永久保存（串行化）先用一句话来说明永久保存的重要：弄懂它以后，你就越来越像个程序员了！如果我们的程序不需要永久保存，那几乎可以肯定是一个小玩儿。
那怕我们的记事本、画图等小程序，也需要保存才有真正的意义。
对于MFC的很多地方我不甚满意，总觉得它喜欢拿一组低能而神秘的宏来故弄玄虚，但对于它的连续存储（serialize）机制，却是我十分钟爱的地方。
在此，可让大家感受到面向对象的幸福。
MFC的连续存储（serialize）机制俗称串行化。
“在你的程序中尽管有着各种各样的数据，serialize机制会象流水一样按顺序存储到单一的文件中，而又能按顺序地取出，变成各种不同的对象数据。
”不知我在说上面这一句话的时候，大家有什么反应，可能很多朋友直觉是一件很简单的事情，只是说了一个“爽”字就没有下文了。
要实现象流水一样存储其实是一个很大的难题。
试想，在我们的程序里有各式各样的对象数据。
如画图程序中，里面设计了点类，矩形类，圆形类等等，它们的绘图方式及对数据的处理各不相同，用它们实现了成百上千的对象之后，如何存储起来？不想由可，一想头都大了：我们要在程序中设计函数store()，在我们单击“文件/保存”时能把各对象往里存储。
那么这个store()函数要神通广大，它能清楚地知道我们设计的是什么样的类，产生什么样的对象。
大家可能并不觉得这是一件很困难的事情，程序有能力知道我们的类的样子，对象也不过是一块初始化了存储区域罢了。
就把一大堆对象“转换”成磁盘文件就行了。
即使上面的存储能成立，但当我们单击“文件/打开”时，程序当然不能预测用户想打开哪个文件，并且当打开文件的时候，要根据你那一大堆垃圾数据new出数百个对象，还原为你原来存储时的样子，你又该怎么做呢？试想，要是我们有一个能容纳各种不同对象的容器，这样，用户用我们的应用程序打开一个磁盘文件时，就可以把文件的内容读进我们程序的容器中。
把磁盘文件读进内存，然后识别它“是什么对象”是一件很难的事情。
首先，保存过程不像电影的胶片，把景物直接映射进去，然后，看一下胶片就知道那是什么内容。
可能有朋友说它象录像磁带，拿着录像带我们看不出里面变化的磁场信号，但经过录像机就能把它还原出来。
其实不是这样的，比如保存一个矩形，程序并不是把矩形本身按点阵存储到磁盘中，因为我们绘制矩形的整个过程只不过是调用一个GDI函数罢了。
它保存只是坐标值、线宽和某些标记等。
程序面对“00 FF”这样的东西，当然不知道它是一个圆或是一个字符！拿刚才录像带的例子，我们之所以能最后放映出来，前提我们知道这对象是“录像带”，即确定了它是什么类对象。
如果我们事先只知道它“里面保存有东西，但不知道它是什么类型的东西”，这就导致我们无法把它读出来。
拿录像带到录音机去放，对录音机来说，那完全是垃圾数据。
即是说，要了解永久保存，要对动态创建有深刻的认识。
现在大家可以知道困难的根源了吧。
我们在写程序的时候，会不断创造新的类，构造新的对象。
这些对象，当然是旧的类对象（如MyDocument）从未见过的。
那么，我们如何才能使文档对象可以保存自己新对象呢，又能动态创建自己新的类对象呢？许多朋友在这个时候想起了CObject这个类，也想到了虚函数的概念。
于是以为自己“大致了解”串行化的概念。
他们设想：“我们设计的MyClass（我们想用于串行化的对象）全部从CObject类派生，CObject类对象当然是MyDocument能认识的。
”这样就实现了一个目的：本来MyDocument不能识别我们创建的MyClass对象，但它能识别CObject类对象。
由于MyClass从CObject类派生，我产的新类对象“是一个CObject”，所以MyDocument能把我们的新对象当作CObiect对象读出。
或者根据书本上所说的：打开或保存文件的时候，MyDocument会调用Serialize（），MyDocument的Serialize（）函会呼叫我们创建类的Serialize 函数[即是在MyDocument Serialize（）中调用：m_pObject->Serialize()，注意：在此m_pObject 是CObject类指针，它可以指向我们设计的类对象]。
最终结果是MyDocument的读出和保存变成了我们创建的类对象的读出和保存，这种认识是不明朗的。
有意思还有，在网上我遇到几位自以为懂了Serialize的朋友，居然不约而同的犯了一个很低级得让人不可思议的错误。
他们说：Serialize太简单了！Serialize（）是一个虚函数，虚函数的作用就是“优先派生类的操作”。
所以MyDocument不实现Serialize（）函数，留给我们自己的MyClass对象去调用Serialize（）……真是哭笑不得，我们创建的类MyClass并不是由MyDocument类派生，Serialize（）函数为虚在MyDocument和MyClass之间没有任何意义。
MyClass产生的MyObject对象仅仅是MyDocument的一个成员变量罢了。
话说回来，由于MyClass从CObject派生，所以CObject类型指针能指向MyClass对象，并且能够让MyClass对象执行某些函数（特指重载的CObject虚函数），但前提必须在MyClass 对象实例化了，即在内存中占领了一块存储区域之后。
不过，我们的问题恰恰就是在应用程序随便打开一个文件，面对的是它不认识的MyClass类，当然实例化不了对象。
幸好我们在上一节课中懂得了动态创建。
即想要从CObject派生的MyClass成为可以动态创建的对象只要用到DECLARE_DYNAMIC/IMPLEMENT_DYNAMIC宏就可以了（注意：最终可以Serialize的对象仅仅用到了DECLARE_SERIAL/IMPLEMENT_SERIAL宏，这是因为DECLARE_SERIAL/IMPLEMENT_SERIAL包含了DECLARE_DYNAMIC/IMPLEMENT_DYNAMIC宏）。
从解决上面的问题中，我们可以分步理解了：1、Serialize的目的：让MyDocument对象在执行打开/保存操作时，能读出（构造）和保存它不认的MyClass类对象。
2、MyDocument对象在执行打开/保存操作时会调用它本身的Serialize（）函数。
但不要指望它会自动保存和读出我们的MyClass类对象。
这个问题很容易解决，就直接在MyDocument:: Serialize（）{// 在此函数调用MyClass类的Serialize（）就行了！即MyObject. Serialize（）;}3、我们希望MyClass对象为可以动态创建的对象，所以要求在MyClass类中加上DECLARE_DYNAMIC/IMPLEMENT_DYNAMIC宏。
但目前的Serialize机制还很抽象。
我们仅仅知道了表面上的东西，实际又是如何的呢？下面作一个简单深刻的详解。
先看一下我们文档类的Serialize（）void CMyDoc::Serialize(CArchive& ar){if (ar.IsStoring()){// TODO: add storing code here}else{// TODO: add loading code here}}目前这个子数什么也没做（没有数据的读出和写入），CMyDoc类正等待着我们去改写这个函数。
现在假设CMyDoc有一个MFC可识别的成员变量m_MyVar,那么函数就可改写成如下形式：void CMyDoc::Serialize(CArchive& ar){if (ar.IsStoring()) //读写判断{ar<<m_MyVar; //写}else{ar>>m_MyVar; //读}}许多网友问：自己写的类（即MFC未包含的类）为什么不行？我们在CMyDoc里包含自写类的头文件MyClass.h，这样CMyDoc就认识MyDoc类对象了。
这是一般常识性的错误，MyDoc类认识MyClass类对象与否并没有用，关键是CArchive类，即对象ar不认识MyClass（当然你梦想重写CArchive类当别论）。
“>>”、“<<”都是CArchive重载的操作符。
上面ar>>m_MyVar说白即是在执行一个以ar和m_MyVar 为参数的函数，类似于function(ar,m_MyVar)罢了。
我们当然不能传递一个它不认识的参数类型，也因此不会执行function(ar,m_MyObject)了。
[注：这里我们可以用指针。
让MyClass从Cobject派生，一切又起了质的变化，假设我们定义了：MyClass *pMyClass = new MyClass;因为MyClass从CObject派生，根据虚函数原理，pMyClass也是一个CObject*，即pMyClass指针是CArchive类可认识的。
所以执行上述function(ar, pMyClass)，即ar << pMyClass是没有太多的问题（在保证了MyClass对象可以动态创建的前提下）。
]回过头来，如果想让MyClass类对象能Serialize，就得让MyClass从CObject派生，Serialize （）函数在CObject里为虚，MyClass从CObject派生之后就可以根据自己的要求去改写它，象上面改写CMyDoc::Serialize（）方法一样。
这样MyClass就得到了属于MyClass自己特有的Serialize（）函数。
现在，程序就可以这样写：……＃i nclude “MyClass.h”……void CMyDoc::Serialize(CArchive& ar){//在此调用MyClass重写过的Serialize()m_MyObject. Serialize(ar); // m_MyObject为MyClass实例}至此，串行化工作就算完成了，一即简单直观：从CObject派生自己的类，重写Serialize（）。
在此过程中，我刻意安排：在没有用到DECLARE_SERIAL/IMPLEMENT_SERIAL宏，也没有用到CArray等模板类的前提下就完成了串行化的工作。
我看过某些书，总是一开始就讲DECLARE_SERIAL/IMPLEMENT_SERIAL宏或马上用CArray模板，让读者觉得串行化就是这两个东西，导致许多朋友因此找不着北。
大家看到了，没有DECLARE_SERIAL/IMPLEMENT_SERIAL宏和CArray等数据结构模板也依然可以完成串行化工作。