孙鑫VC++讲座笔记

1,windows程序设计是种事件驱动方式的程序设计，主要基于消息的。当用户需要完成某种功能时，需要调用OS某种支持，然后OS将用户的需要包装成消息，并投入到消息队列中，最后应用程序从消息队列中取走消息并进行响应。
2，消息结构：
typedef struct tagMSG {   // msg
  HWND   hwnd;   //接收消息的窗口句柄。和哪个窗口相关联。
  UINT   message; //消息标识。消息本身是什么。
  WPARAM wParam;   //消息的附加信息。具体取决于消息本身。
  LPARAM lParam;
  DWORD time;   //消息投递时间。
  POINT pt;     //消息投递时，光标在屏幕上的位置。
} MSG;

3，消息队列：
每个应用程序OS都为它建立一个消息队列，消息队列是个先进先出的缓冲区，其中每个元素都是一个消息，OS将生成的每个消息按先后顺序放进消息队列中，应用程序总是取走当前消息队列中的第一条消息，应用程序取走消息后便知道用户的操作和程序的状态，然后对其处理即消息响应，消息响应通过编码实现。

4，使用VC编程除了良好的C基础外还需要掌握两方面：
一，消息本身。不同消息所代表的用户操作和应用程序的状态。
二，对于某个特定的消息来说，要让OS执行某个特定的功能去响应消息。

5，Window程序入口：
int WINAPI WinMain(
HINSTANCE hInstance, // 当前事例句柄。
HINSTANCE hPrevInstance, // 先前事例句柄。
LPSTR lpCmdLine,     // 命令行指针
int nCmdShow       // （窗口）显示的状态
);
说明：WinMain函数是Windows程序入口点函数，由OS调用，当OS启动应用程序的时候，winmain函数的参数由OS传递的。

6，创建一个完整的窗口需要经过下面四个操作步骤：
一，设计一个窗口类；如：WNDCLASS wndcls;
二，注册窗口类；   如：RegisterClass(&wndcls);
三，创建窗口；     如：CreateWindow(),CreateWindowEX();
四，显示及更新窗口。如：ShowWindow(),UpdateWindow();

说明：创建窗口的时候一定要基于已经注册的窗口类.

7，Windows提供的窗口类：
typedef struct _WNDCLASS {
  UINT   style;     //窗口的类型
  WNDPROC lpfnWndProc; //窗口过程函数指针（回调函数）
  int   cbClsExtra; //窗口类附加字节，为该类窗口所共享。通常0。
  int   cbWndExtra; //窗口附加字节。通常设为0。
  HANDLE hInstance; //当前应用程序事例句柄。
  HICON   hIcon;     //图标句柄 LoadIcon();
  HCURSOR hCursor;   //光标句柄 LoadCursor();
  HBRUSH hbrBackground; //画刷句柄 (HBRUSH)GetStockObject();
  LPCTSTR lpszMenuName; //菜单名字
  LPCTSTR lpszClassName; //类的名字
} WNDCLASS;

8,窗口类注册：
ATOM RegisterClass(
CONST WNDCLASS *lpWndClass   // address of structure with class
                    // data
);

9，创建窗口：
HWND CreateWindow(
LPCTSTR lpClassName, // pointer to registered class name
LPCTSTR lpWindowName, // pointer to window name
DWORD dwStyle,     // window style
int x,           // horizontal position of window
int y,           // vertical position of window
int nWidth,       // window width
int nHeight,       // window height
HWND hWndParent,     // handle to parent or owner window
HMENU hMenu,       // handle to menu or child-window identifier
HANDLE hInstance,   // handle to application instance
LPVOID lpParam     // pointer to window-creation data
);

10,显示和更新窗口窗口：
BOOL ShowWindow(
HWND hWnd,   // handle to window
int nCmdShow   // show state of window
);
BOOL UpdateWindow(
HWND hWnd   // handle of window
);

11,消息循环：
MSG msg;
while(GetMessage(&msg,...))   //从消息队列中取出一条消息
{
TranslateMessage(&msg); //进行消息（如键盘消息）转换
DispatchMessage(&msg); //分派消息到窗口的回调函数处理,（OS调用窗口回调函数进行处理）。
}

其中：
//**The GetMessage function retrieves a message from the calling thread's message queue and places it in the specified structure.
//**If the function retrieves a message other than WM_QUIT, the return value is nonzero.If the function retrieves the WM_QUIT message, the return value is zero. If there is an error, the return value is -1.

BOOL GetMessage(
LPMSG lpMsg,       // address of structure with message
HWND hWnd,       // handle of window
UINT wMsgFilterMin, // first message
UINT wMsgFilterMax   // last message
);


//The TranslateMessage function translates virtual-key messages into character messages. The character messages are posted to the calling thread's message queue, to be read the next time the thread calls the GetMessage or PeekMessage function.
BOOL TranslateMessage(
CONST MSG *lpMsg   // address of structure with message
);

//The DispatchMessage function dispatches a message to a window procedure.
LONG DispatchMessage(
CONST MSG *lpmsg   // pointer to structure with message
);


12，窗口过程函数（回调函数）原型：
The WindowProc function is an application-defined function that processes messages sent to a window. The WNDPROC type defines a pointer to this callback function. WindowProc is a placeholder（占位符） for the application-defined function name.

LRESULT CALLBACK WindowProc( //这里WindowProc是个代号名字。
HWND hwnd,     // handle to window
UINT uMsg,     // message identifier
WPARAM wParam, // first message parameter
LPARAM lParam   // second message parameter
);

说明：两种函数调用约定（__stdcall 和 __cdecl）：
#define CALLBACK   __stdcall
//__stdcall 标准调用预定，是PASCAL 调用约定，象DELPHI使用的就是标准调用约定
#define WINAPIV   __cdecl
// __cdecl 是C 语言形式的调用约定。


主要区别：函数参数传递顺序 和 对堆栈的清除上。
问题：除了那些可变参数的函数调用外，其余的一般都是__stdcall约定。但 C/C++编译默然的是__cdecl约定。所以如果在VC等环境中调用__stdcall约定的函数，必须要在函数声明的时加上 __stdcall 修饰符，以便对这个函数的调用是使用__stdcall约定（如使用DELPHI编写的DLL时候）。
（VC中可通过这途径修改：project|settings..|c/c++|...)


在窗口过程函数中通过一组switch语句来对消息进行处理：
如：
LRESULT CALLBACK WindowProc(
HWND hwnd,
UINT uMsg,
WPARAM wParam,
LPARAM lParam  
)
{
  switch(uMsg)
  {
case WM_PAINT:
...
break;
case ...
break;
case WM_CLOSE:
//DestroyWindow(hwnd);
  //销毁窗口，并发送WM_DESTROY消息。
break;
case WM_DESTROY:
//PostQuitMessage(0);
//发送WM_QUIT消息到消息队列中，请求终止。
      //GetMessage()取到WM_QUIT消息后，返回0，退出消息循           //   环，从而终止应用程序。
break;
default:
return DefWindowProc(hwnd,uMsg,wParam,lParam);
//用缺省的窗口过程处理我们不感兴趣的消息（其它消息）。
//这是必须的。
  }//switch
return 0;
}//WindowProc

13，DestroyWindow()函数和PostQuitMessage()函数原型：
//**The DestroyWindow function destroys the specified window. The function sends WM_DESTROY and WM_NCDESTROY messages。

BOOL DestroyWindow(
HWND hWnd   // handle to window to destroy
);

//**The PostQuitMessage function indicates to the system that a thread has made a request to terminate (quit). It is typically used in response to a WM_DESTROY message.
//**The PostQuitMessage function posts a WM_QUIT message to the thread's message queue and returns immediately; the function simply indicates（预示，通知） to the system that the thread is requesting to quit at some time in the future.

When the thread retrieves the WM_QUIT message from its message queue, it should exit its message loop and return control to the system.

VOID PostQuitMessage(
int nExitCode   // exit code
);

14，关于DC句柄获取：
a)使用BeginPaint(),EndPaint()对。注意只能在响应WM_PAINT消息时使用。
b)使用GetDc(),ReleaseDC()对。注意他们不能在响应WM_PAINT中使用。

孙鑫VC++讲座笔记-(2)C++
1, c语言中，结构体struct中不能包括函数的，而在C++中struct中可以包括函数。
2，C++中结构体和类可以通用，区别主要表现在访问控制方面：struct中默认是public，而 class中默认的是private。
3，构造函数最重要的作用是创建对象的本身，C++中每个类可以拥有多个构造函数，但必须至少有一个构造函数，当一个类中没有显式提供任何构造函数，C++编辑器自动提供一个默认的不带参数的构造函数，这个默认的构造函数只负责构造对象，不做任何初始化工作。但在一个类中只要自己定义一个构造函数，不管带参不带参，编辑器不再提供默认的不带参的构造函数了。构造函数没有返回值。
4,析构函数当一个对象生命周期结束时候被调用来回收对象占用的内存空间。一个类只需有一个析构函数。析构函数没有返回值也不的带参数。
5，析构函数的作用与构造函数相反，对象超出起作用范围对应的内存空间被系统收回，或被程序用delete删除的时候，对象的析构函数被调用。
6，函数的重载条件：函数的参数类型、个数不同，才能构成函数的重载。重载是发生在同一个类中。
7，类是抽象的，不占用具体物理内存，只有对象是实例化的，是占用具体物理内存的。
8，this指针是隐含指针，指向对象本身（this指针不是指向类的），代表了对象的地址。所有的对象调用的成员函数都是同一代码段，但每个对象都有自己的数据成员。当对象通过调用它的成员函数来访问它的数据成员的时候，成员函数除了接收实参外，还接收了对象的地址，这个地址被一个隐藏的形参this所获取，通过这个this指针可以访问对象的数据成员和成员函数。
9，对象中public属性的成员在外部和子类中都可以被访问；protected属性的成员在外部不能被访问，在子类中是可以访问的；private属性在子类中和外部都不能被访问。
10，类的继承访问特性：（public,protected,private)
a）基类中private属性成员，子类无论采用那种继承方式都不能访问。
b）采用public继承，基类中的public,protected属性的成员访问特性在子类中仍然保持一致。
c）采用protected继承，基类中的public,protected属性成员访问特性在子类中变为protected.
d）采用provate继承，基类中的public,protected属性成员访问特性在子类中变为provate.
11，子类和基类的构造函数或析构函数调用顺序：
当调用子类的构造函数时候先调用基类的构造函数（如果没有指明，则调用基类却省那个不带参数的构造函数；如果要指明则在子类构造函数名后加":基类名(参数)"）。析构函数则相反，先调用子类析构函数，后调用基类的析构函数。
12，函数的覆盖：
函数的覆盖是发生在发生父类和子类之间的。（函数的重载是发生在同一个类中）
当子类中重写了父类的某些成员函数后，子类中的成员函数覆盖了父类的对应同名成员函数。
13，用父类指针访问子类对象成员时候，只能访问子类从父类继承来的那部分。（这时候外部不可以访问父类中保护和私有的部分，子类中不可访问父类私有部分。）
14，多态性：在基类的的成员函数前加virturl变成虚函数，当用子类对象调用该功能的成员函数时候，子类有的就调用子类的，子类没有的就调用基类的。
当C++编译器在编译的时候，发现被调用的成员函数在基类中定义的是虚函数，这个时候C++就会采用迟绑定技术（late binding)，在运行的时候，依据对象的类型来确定调用的哪个函数，子类有调用子类的，子类没有的就调用基类的。
如果基类中的成员函数不是虚函数，则这时候的绑定是早期绑定，在编译的时候就已经确定该调用哪个函数。
15，纯虚函数：在类中定义时 eg: virtual void f1()=0;
纯虚函数没有函数体，含有纯虚函数的类叫做抽象类，抽象类不能实例化对象。当子类从抽象类的基类中派生出来时候，如果没有实现基类中的纯虚函数，则子类也是个抽象类，也不能实例化对象。
纯虚函数被标名为不具体实现的虚成员函数，纯虚函数可以让类只具有操作的名称而不具有具体的操作的内容，让派生类在继承的时候再给出具体的定义。如果派生类没有给出基类的纯虚函数的具体定义的时候，派生类也为一个抽象类，也不能实例化对象。
16，引用：变量的别名。引用需要在定义的时候用一变量或对象初始化自己。引用一旦在定义的时候初始化，就维系在一个特定的变量或对象上。
引用不占用物理内存（与定义引用的目标共用同一内存）。指针变量需要占用物理内存，用来存储地址。
1, c语言中，结构体struct中不能包括函数的，而在C++中struct中可以包括函数。
2，C++中结构体和类可以通用，区别主要表现在访问控制方面：struct中默认是public，而 class中默认的是private。
3，构造函数最重要的作用是创建对象的本身，C++中每个类可以拥有多个构造函数，但必须至少有一个构造函数，当一个类中没有显式提供任何构造函数，C++编辑器自动提供一个默认的不带参数的构造函数，这个默认的构造函数只负责构造对象，不做任何初始化工作。但在一个类中只要自己定义一个构造函数，不管带参不带参，编辑器不再提供默认的不带参的构造函数了。构造函数没有返回值。
4,析构函数当一个对象生命周期结束时候被调用来回收对象占用的内存空间。一个类只需有一个析构函数。析构函数没有返回值也不的带参数。
5，析构函数的作用与构造函数相反，对象超出起作用范围对应的内存空间被系统收回，或被程序用delete删除的时候，对象的析构函数被调用。
6，函数的重载条件：函数的参数类型、个数不同，才能构成函数的重载。重载是发生在同一个类中。
7，类是抽象的，不占用具体物理内存，只有对象是实例化的，是占用具体物理内存的。
8，this指针是隐含指针，指向对象本身（this指针不是指向类的），代表了对象的地址。所有的对象调用的成员函数都是同一代码段，但每个对象都有自己的数据成员。当对象通过调用它的成员函数来访问它的数据成员的时候，成员函数除了接收实参外，还接收了对象的地址，这个地址被一个隐藏的形参this所获取，通过这个this指针可以访问对象的数据成员和成员函数。
9，对象中public属性的成员在外部和子类中都可以被访问；protected属性的成员在外部不能被访问，在子类中是可以访问的；private属性在子类中和外部都不能被访问。
10，类的继承访问特性：（public,protected,private)
a）基类中private属性成员，子类无论采用那种继承方式都不能访问。
b）采用public继承，基类中的public,protected属性的成员访问特性在子类中仍然保持一致。
c）采用protected继承，基类中的public,protected属性成员访问特性在子类中变为protected.
d）采用provate继承，基类中的public,protected属性成员访问特性在子类中变为provate.
11，子类和基类的构造函数或析构函数调用顺序：
当调用子类的构造函数时候先调用基类的构造函数（如果没有指明，则调用基类却省那个不带参数的构造函数；如果要指明则在子类构造函数名后加":基类名(参数)"）。析构函数则相反，先调用子类析构函数，后调用基类的析构函数。
12，函数的覆盖：
函数的覆盖是发生在发生父类和子类之间的。（函数的重载是发生在同一个类中）
当子类中重写了父类的某些成员函数后，子类中的成员函数覆盖了父类的对应同名成员函数。
13，用父类指针访问子类对象成员时候，只能访问子类从父类继承来的那部分。（这时候外部不可以访问父类中保护和私有的部分，子类中不可访问父类私有部分。）
14，多态性：在基类的的成员函数前加virturl变成虚函数，当用子类对象调用该功能的成员函数时候，子类有的就调用子类的，子类没有的就调用基类的。
当C++编译器在编译的时候，发现被调用的成员函数在基类中定义的是虚函数，这个时候C++就会采用迟绑定技术（late binding)，在运行的时候，依据对象的类型来确定调用的哪个函数，子类有调用子类的，子类没有的就调用基类的。
如果基类中的成员函数不是虚函数，则这时候的绑定是早期绑定，在编译的时候就已经确定该调用哪个函数。
15，纯虚函数：在类中定义时 eg: virtual void f1()=0;
纯虚函数没有函数体，含有纯虚函数的类叫做抽象类，抽象类不能实例化对象。当子类从抽象类的基类中派生出来时候，如果没有实现基类中的纯虚函数，则子类也是个抽象类，也不能实例化对象。
纯虚函数被标名为不具体实现的虚成员函数，纯虚函数可以让类只具有操作的名称而不具有具体的操作的内容，让派生类在继承的时候再给出具体的定义。如果派生类没有给出基类的纯虚函数的具体定义的时候，派生类也为一个抽象类，也不能实例化对象。
16，引用：变量的别名。引用需要在定义的时候用一变量或对象初始化自己。引用一旦在定义的时候初始化，就维系在一个特定的变量或对象上。
引用不占用物理内存（与定义引用的目标共用同一内存）。指针变量需要占用物理内存，用来存储地址。
孙鑫VC++讲座笔记-(3)MFC程序框架的剖析
孙鑫VC++讲座笔记-(3)MFC程序框架的剖析

1,寻找WinMain人口：
在安装目录下找到MFC文件夹下的SRC文件夹，SRC下是MFC源代码。
路径：MFC|SRC|APPMODUL.CPP：
_tWinMain(HINSTANCE hInstance, HINSTANCE hPrevInstance,
LPTSTR lpCmdLine, int nCmdShow)
{
// call shared/exported WinMain
return AfxWinMain(hInstance, hPrevInstance, lpCmdLine, nCmdShow);
}
注意：（#define _tWinMain   WinMain）

2，对于全局对象或全局变量来说，在程序运行即WINMAIN函数加载的时候，已经为全局对象或全局变量分配了内存和赋初值。
所以：CTEApp theApp;->CTEApp ::CTEApp(){}->_tWinMain(){}
说明：每一个MFC程序，有且只有一个从WinApp类派生的类（应用程序类），也只有一个从应用程序类所事例化的对象，表示应用程序本身。在WIN32程序当中，表示应用程序是通过WINMAIN入口函数来表示的（通过一个应用程序的一个事例号这一个标识来表示的）。在基于MFC应用程序中，是通过产生一个应用程序对象，用它来唯一的表示了应用程序。

3，通过构造应用程序对象过程中调用基类CWinApp的构造函数，在CWinApp的构造函数中对程序包括运行时一些初始化工作完成了。
CWinApp构造函数：MFC|SRC|APPCORE.CPP
CWinApp::CWinApp(LPCTSTR lpszAppName){...}//带参数，而CTEApp构造函数没有显式向父类传参，难道CWinApp()有默认参数？见下：
（在CWinApp类定义中， CWinApp(LPCTSTR lpszAppName = NULL); ）
注意：CWinApp()函数中：
pThreadState->m_pCurrentWinThread = this;
pModuleState->m_pCurrentWinApp = this
（this指向的是派生类CTEApp对象，即theApp）
调试：CWinApp::CWinApp();->CTEApp theApp;（->CTEApp ::CTEApp()）->CWinApp::CWinApp()->CTEApp ::CTEApp()->_tWinMain(){}

4,_tWinMain函数中通过调用AfxWinMain()函数来完成它要完成的功能。（Afx*前缀代表这是应用程序框架函数，是一些全局函数，应用程序框架是一套辅助生成应用程序的框架模型，把一些类做一些有机的集成，我们可根据这些类函数来设计自己的应用程序）。
AfxWinMain()函数路径：MFC|SRC|WINMAIN.CPP：
在AfxWinMain()函数中：
CWinApp* pApp = AfxGetApp();
说明：pApp存储的是指向WinApp派生类对象（theApp）的指针。
//_AFXWIN_INLINE CWinApp* AFXAPI AfxGetApp()
// { return afxCurrentWinApp; }

调用pThread->InitInstance()
说明：pThread也指向theApp,由于基类中virtual BOOL InitApplication()定义为虚函数，所以调用pThread->InitInstance()时候，调用的是派生类CTEApp的InitInstance()函数。

nReturnCode = pThread->Run();
说明：pThread->Run()完成了消息循环。

5,注册窗口类：AfxEndDeferRegisterClass();
AfxEndDeferRegisterClass()函数所在文件：MFC|SRC|APPCORE.CPP
BOOL AFXAPI AfxEndDeferRegisterClass(LONG fToRegister){...}
说明：设计窗口类：在MFC中事先设计好了几种缺省的窗口类，根据不同的应用程序的选择，调用AfxEndDeferRegisterClass()函数注册所选择的窗口类。
调试：CWinApp::CWinApp();->CTEApp theApp;（->CTEApp ::CTEApp()）->CWinApp::CWinApp()->CTEApp ::CTEApp()->_tWinMain(){}//进入程序
->AfxWinMain();->pApp->InitApplication()；->pThread->InitInstance()//父类InitInstance虚函数;->CTEApp::InitInstance()//子类实现函数;->AfxEndDeferRegisterClass(LONG fToRegister)//注册所选择的窗口类（出于文档管理，注册提前，正常的应在PreCreateWindow中进行注册）//之后进入创建窗口阶段（以下再不做调试）

6，PreCreateWindow()：//主要是注册窗口类
BOOL CMainFrame::PreCreateWindow(CREATESTRUCT& cs)
{
if( !CFrameWnd::PreCreateWindow(cs) )
return FALSE;
return TRUE;
}
说明：
CFrameWnd::PreCreateWindow()函数所在文件：MFC|SRC|WINFRM.CPP
BOOL CFrameWnd::PreCreateWindow(CREATESTRUCT& cs)
{
if (cs.lpszClass == NULL)
{
VERIFY(AfxDeferRegisterClass(AFX_WNDFRAMEORVIEW_REG));
  //判断AFX_WNDFRAMEORVIEW_REG型号窗口类是否注册，如果没有注册则注册
cs.lpszClass = _afxWndFrameOrView; // COLOR_WINDOW background
  //把注册后的窗口类名赋给cs.lpszClass
}

if ((cs.style & FWS_ADDTOTITLE) && afxData.bWin4)
cs.style |= FWS_PREFIXTITLE;

if (afxData.bWin4)
cs.dwExStyle |= WS_EX_CLIENTEDGE;

return TRUE;
}

其中：
virtual BOOL PreCreateWindow(CREATESTRUCT& cs);//PreCreateWindow()是个虚函数,如果子类有则调用子类的。
#define VERIFY(f)       ASSERT(f)
#define AfxDeferRegisterClass(fClass) AfxEndDeferRegisterClass(fClass)
define AFX_WNDFRAMEORVIEW_REG       0x00008
const TCHAR _afxWndFrameOrView[] = AFX_WNDFRAMEORVIEW;//WINCORE.CPP文件中，定义为全局数组。
//#define AFX_WNDFRAMEORVIEW AFX_WNDCLASS("FrameOrView")

7，创建窗口：
Create()函数路径：MFC|SRC|WINFRM.CPP:
CFrameWnd::Create(...){
...
CreateEx(...);//从父类继承来的，调用CWnd::CreateEx().
...
}

CWnd::CreateEx()函数路径：MFC|SRC|WINCORE.CPP
BOOL CWnd::CreateEx(...){
...
if (!PreCreateWindow(cs))//虚函数，如果子类有调用子类的。
{
PostNcDestroy();
return FALSE;
}
...
HWND hWnd = ::CreateWindowEx(cs.dwExStyle, cs.lpszClass,
cs.lpszName, cs.style, cs.x, cs.y, cs.cx, cs.cy,
cs.hwndParent, cs.hMenu, cs.hInstance, cs.lpCreateParams);

...
}
说明：CreateWindowEx()函数与CREATESTRUCT结构体参数的对应关系，使我们在创建窗口之前通过可PreCreateWindow(cs)修改cs结构体成员来修改所要的窗口外观。PreCreateWindow(cs))//是虚函数，如果子类有调用子类的。
HWND CreateWindowEx(
DWORD dwExStyle,    
LPCTSTR lpClassName,
LPCTSTR lpWindowName,
DWORD dwStyle,    
int x,          
int y,          
int nWidth,      
int nHeight,      
HWND hWndParent,    
HMENU hMenu,      
HINSTANCE hInstance,
LPVOID lpParam    
);
typedef struct tagCREATESTRUCT { // cs
  LPVOID   lpCreateParams;
  HINSTANCE hInstance;
  HMENU   hMenu;
  HWND     hwndParent;
  int     cy;
  int     cx;
  int     y;
  int     x;
  LONG     style;
  LPCTSTR   lpszName;
  LPCTSTR   lpszClass;
  DWORD   dwExStyle;
} CREATESTRUCT;

8，显示和更新窗口：
CTEApp类，TEApp.cpp中
m_pMainWnd->ShowWindow(SW_SHOW);//显示窗口，m_pMainWnd指向框架窗口
m_pMainWnd->UpdateWindow();//更新窗口
说明：
class CTEApp : public CWinApp{...}
class CWinApp : public CWinThread{...}
class CWinThread : public CCmdTarget
{
...
public:
CWnd* m_pMainWnd;
...
...
}

9，消息循环：
int AFXAPI AfxWinMain()
{ ...
// Perform specific initializations
if (!pThread->InitInstance()){...}
//完成窗口初始化工作，完成窗口的注册，完成窗口的创建，显示和更新。
nReturnCode = pThread->Run();
//继承基类Run()方法，调用CWinThread::Run()来完成消息循环
...
}

CWinThread::Run()方法路径：MFC|SRC|THRDCORE.CPP
int CWinThread::Run()
{ ...
// phase2: pump messages while available
do//消息循环
{
  // pump message, but quit on WM_QUIT
  if (!PumpMessage())//取消息并处理
  return ExitInstance();
  ...
} while (::PeekMessage(&m_msgCur, NULL, NULL, NULL, PM_NOREMOVE));
...
}
说明：
BOOL PeekMessage(,,,,)函数说明
The PeekMessage function checks a thread message queue for a message and places the message (if any) in the specified structure.
If a message is available, the return value is nonzero.
If no messages are available, the return value is zero.

/
BOOL CWinThread::PumpMessage()
{
...
if (!::GetMessage(&m_msgCur, NULL, NULL, NULL))//取消息
{...}
...
// process this message
if (m_msgCur.message != WM_KICKIDLE && !PreTranslateMessage(&m_msgCur))
{
::TranslateMessage(&m_msgCur);//进行消息（如键盘消息）转换
::DispatchMessage(&m_msgCur);//分派消息到窗口的回调函数处理（实际上分派的消息经过消息映射，交由消息响应函数进行处理。）
}
return TRUE;
}

9，文档与视结构：
可以认为View类窗口是CMainFram类窗口的子窗口。
DOCument类是文档类。
DOC-VIEW结构将数据本身与它的显示分离开。
文档类：数据的存储，加载
视类：数据的显示，修改

10，文档类，视类，框架类的有机结合：
在CTEApp类CTEApp::InitInstance()函数中通过文档模板将文档类，视类，框架类的有机组织一起。
...
CSingleDocTemplate* pDocTemplate;
pDocTemplate = new CSingleDocTemplate(
IDR_MAINFRAME,
RUNTIME_CLASS(CTEDoc),
RUNTIME_CLASS(CMainFrame),     // main SDI frame window
RUNTIME_CLASS(CTEView));
AddDocTemplate(pDocTemplate);//增加到模板
孙鑫VC++讲座笔记-(4)MFC消息映射机制的剖析
一，消息映射机制

1，消息响应函数：（例：在CDrawView类响应鼠标左键按下消息）
1）在头文件(DrawView.h)中声明消息响应函数原型。
//{{AFX_MSG(CDrawView)   //注释宏
afx_msg void OnLButtonDown(UINT nFlags, CPoint point);
//}}AFX_MSG   //注释宏
说明：
在注释宏之间的声明在VC中灰色显示。afx_msg宏表示声明的是一个消息响应函数。
2）在源文件（DrawView.cpp)中进行消息映射。
BEGIN_MESSAGE_MAP(CDrawView, CView)
//{{AFX_MSG_MAP(CDrawView)
ON_WM_LBUTTONDOWN()
//}}AFX_MSG_MAP
// Standard printing commands
ON_COMMAND(ID_FILE_PRINT, CView::OnFilePrint)
ON_COMMAND(ID_FILE_PRINT_DIRECT, CView::OnFilePrint)
ON_COMMAND(ID_FILE_PRINT_PREVIEW, CView::OnFilePrintPreview)
END_MESSAGE_MAP()
说明：
在宏BEGIN_MESSAGE_MAP()与END_MESSAGE_MAP()之间进行消息映射。
宏ON_WM_LBUTTONDOWN()把消息WM_LBUTTONDOWN与它的响应函数OnLButtonDown（）相关联。这样一旦有消息的产生，就会自动调用相关联的消息响应函数去处理。
宏ON_WM_LBUTTONDOWN()定义如下：
#define ON_WM_LBUTTONDOWN() /
{ WM_LBUTTONDOWN, 0, 0, 0, AfxSig_vwp, /
(AFX_PMSG)(AFX_PMSGW)(void (AFX_MSG_CALL CWnd::*)(UINT, CPoint))&OnLButtonDown },
3）源文件中进行消息响应函数处理。（DrawView.cpp中自动生成OnLButtonDown函数轮廓，如下）
void CDrawView::OnLButtonDown(UINT nFlags, CPoint point)
{
// TODO: Add your message handler code here and/or call default
CView::OnLButtonDown(nFlags, point);
}
说明：
可见当增加一个消息响应处理，在以上三处进行了修改。可在消息响应函数里添加消息处理代码完成对消息的响应、处理。

2，消息响应的方式：
1）在基类中针对每种消息做一个虚函数，当子类对消息响应时候，只要在子类中重写这个虚函数即可。缺点：MFC类派生层次很多，如果在基类对每个消息进行虚函数处理，那么从基类派生的每个子类都将背负一个庞大的虚表，这样浪费内存，故MFC没有采取这中方式而采取消息映射方式。
2）消息映射方式：MFC在后台维护了一个句柄和C++对象指针对照表，当收到一个消息后，通过消息结构里资源句柄（查对照表）就可找到与它对应的一个C++对象指针，然后把这个指针传给基类，基类利用这个指针调用WindowProc()函数对消息进行处理，WindowProc()函数中调用OnWndMsg()函数，真正的消息路由及处理是由OnWndMsg()函数完成的。由于WindowProc()和OnWndMsg()都是虚函数，而且是用派生类对象指针调用的，由多态性知最总终调用子类的。在OnWndMsg()函数处理的时候，根据消息种类去查找消息映射，判断所发的消息有没有响应函数，具体方式是到相关的头文件和源文件中寻找消息响应函数声明（从注释宏//{{AFX_MSG(CDrawView)...//}}AFX_MSG之间寻找），消息映射（从宏BEGIN_MESSAGE_MAP(...)....END_MESSAGE_MAP()之间寻找），最终找到对应的消息处理函数。当然，如果子类中没有对消息进行处理，则消息交由基类处理。
说明：
virtual LRESULT WindowProc(UINT message, WPARAM wParam, LPARAM lParam);
virtual BOOL OnWndMsg(UINT message, WPARAM wParam, LPARAM lParam, LRESULT* pResult);


二，有关绘图

1，使用SDK获取DC句柄：
HDC hdc;
hdc=::GetDc(m_hWnd);//获取DC句柄
MoveToEx(hdc,m_ptOrigin.x,m_ptOrigin.y,NULL);
LineTo(hdc,point.x,point.y);
::ReleaseDC(m_hWnd,hdc);//释放DC

2，利用CDC类指针和CWin类成员函数获取DC。
CDC *pDC=GetDC();
pDC->MoveTo(m_ptOrigin);
pDC->LineTo(point);
ReleaseDC(pDC);

3，利用CClientDC对象。（CClientDC类从CDC类派生来的）
CClientDC dc(this);
dc.MoveTo(m_ptOrigin);
dc.LineTo(point);
说明：
The CClientDC class is derived from CDC and takes care of calling the Windows functions GetDC at construction time and ReleaseDC at destruction time. This means that the device context associated with a CClientDC object is the client area of a window.

4，利用CWindowDC对象。（CWindowDC类从CDC类派生来的）
CWindowDC dc(this);//
dc.MoveTo(m_ptOrigin);
dc.LineTo(point);
说明：
The CWindowDC class is derived from CDC. It calls the Windows functionsGetWindowDC at construction time andReleaseDC at destruction time. This means that a CWindowDC object accesses the entire screen area of a CWnd (both client and nonclient areas).

5，GetParent()得到父窗口指针；GetDesktopWindow()得到屏幕窗口指针。

6，利用画笔改变线条颜色和类型：
CPen pen(PS_DOT,1,RGB(0,255,0));//构造画笔对象
CClientDC dc(this);CPen *pOldPen=dc.SelectObject(&pen);//将画笔选入DC
dc.MoveTo(m_ptOrigin);
dc.LineTo(point);
dc.SelectObject(pOldPen);//恢复先前的画笔

7，使用画刷（通常利用画刷去填充矩形区域）：
使用单色画刷
CBrush brush(RGB(255,0,0));//构造画刷对象
CClientDC dc(this);
dc.FillRect(CRect(m_ptOrigin,point),&brush);//用指定的画刷去填充矩形区域

使用位图画刷
CBitmap bitmap;//构造位图对象（使用前需要初试化）
bitmap.LoadBitmap(IDB_BITMAP1);//初试化位图对象
CBrush brush(&bitmap);//构造位图画刷
CClientDC dc(this);
dc.FillRect(CRect(m_ptOrigin,point),&brush);//用指定的位图画刷去填充矩形区域

使用透明画刷
CBrush *pBrush=CBrush::FromHandle((HBRUSH)GetStockObject(NULL_BRUSH));//获取透明画刷对象指针
CClientDC dc(this);
CBrush *pOldBrush=dc.SelectObject(pBrush);//将透明画刷选入DC
dc.Rectangle(CRect(m_ptOrigin,point));
dc.SelectObject(pOldBrush);//释放透明画刷
说明：
The GetStockObject function retrieves a handle to one of the predefined stock pens, brushes, fonts, or palettes.
HGDIOBJ GetStockObject(
int fnObject   // type of stock object
);

Returns a pointer to a CBrush object when given a handle to a Windows HBRUSH object.
static CBrush* PASCAL FromHandle( HBRUSH hBrush );//FromHandle是一个静态方法，故可用CBrush::FromHandle()形式调用。
注意点：
1）静态方法不属于某一个具体对象，而属于类本身，在类加载的时候就已经为类静态方法分配了代码去，故可用CBrush::FromHandle()形式调用。
2）静态方法中，不能引用非静态的数据成员和方法。
3）静态数据成员需要在类外单独做初始化，形式如： 变量类型 类名::变量名=初始值;

8，CDC::SetROP2方法：
int SetROP2( int nDrawMode );
Sets the current drawing mode.
孙鑫VC++讲座笔记-(5)文本编程
1,创建插入符：
void CreateSolidCaret( int nWidth, int nHeight );//创建插入符
void CreateCaret( CBitmap* pBitmap );//创建位图插入符
void ShowCaret( );//显示插入符
void HideCaret( );//隐藏插入符
static void PASCAL SetCaretPos( POINT point );//移动插入符号
说明：
1）创建插入符要在窗口创建完成之后，CreateSolidCaret函数创建的插入符被初始化为隐藏，所以需要调用ShowCaret()将其显示。
2）使用CreateCaret函数创建位图插入符的时候，不能使用局部的位图对象关联位图资源。（与资源相关联的C++对象，当它析构的时候会同时把与它相关联的资源销毁。）

2，获取当前字体信息的度量：CDC::GetTextMetrics
BOOL GetTextMetrics( LPTEXTMETRIC lpMetrics ) const;
说明：
typedef struct tagTEXTMETRIC { /* tm */
  int tmHeight;//字体高度。Specifies the height (ascent + descent) of characters.
  int tmAscent;//基线以上的字体高度
  int tmDescent;//基线以下的字体高度
  int tmInternalLeading;
  int tmExternalLeading;
  int tmAveCharWidth;//字符平均宽度
  int tmMaxCharWidth;
  int tmWeight;
  BYTE tmItalic;
  BYTE tmUnderlined;
  BYTE tmStruckOut;
  BYTE tmFirstChar;
  BYTE tmLastChar;
  BYTE tmDefaultChar;
  BYTE tmBreakChar;
  BYTE tmPitchAndFamily;
  BYTE tmCharSet;
  int tmOverhang;
  int tmDigitizedAspectX;
  int tmDigitizedAspectY;
} TEXTMETRIC;

3，OnDraw函数:
virtual void OnDraw( CDC* pDC )
当窗口（从无到有或尺寸大小改变等）要求重绘的时候，会发送WM_PAIN消息，调用OnDraw函数进行重绘。

4,获取字符串的高度和宽度（区别字符串的长度）：
CDC::GetTextExtent
CSize GetTextExtent( LPCTSTR lpszString, int nCount ) const;
CSize GetTextExtent( const CString& str ) const;
说明：
The CSize class is similar to the Windows SIZE structure。
typedef struct tagSIZE {
  int cx;//the x-extent
  int cy;//the y-extent
} SIZE;


5，路径层：
BOOL BeginPath( );
//在这作图定义路径层剪切区域
BOOL EndPath( );
BOOL SelectClipPath( int nMode );//调用这个函数来使当前路径层剪切区域与新剪切区域进行互操作。  
//在这覆盖作图（包含前定义的路径层区域）定义新的剪切区域

说明：
1）SelectClipPath Selects the current path as a clipping region for the device context, combining the new region with any existing clipping region by using the specified mode. The device context identified must contain a closed path.

nMode：RGN_AND，RGN_COPY，RGN_DIFF，RGN_OR，RGN_XOR
RGN_AND   The new clipping region includes the intersection (overlapping areas) of the current clipping region and the current path.
RGN_COPY   The new clipping region is the current path.
RGN_DIFF   The new clipping region includes the areas of the current clipping region, and those of the current path are excluded.
RGN_OR   The new clipping region includes the union (combined areas) of the current clipping region and the current path.
RGN_XOR   The new clipping region includes the union of the current clipping region and the current path, but without the overlapping areas.
2）应用：当作图的时候，如果想要在整幅图形其中的某个部分和其它部分有所区别，我们可以把这部分图形放到路径层当中，然后指定调用指定互操作模式调用SelectClipPath( int nMode )函数来使路径层和覆盖在其上新绘图剪切区域进行互操作，达到特殊效果。

6，关于文本字符串一些函数：
COLORREF GetBkColor( ) const;//得到背景颜色
virtual COLORREF SetBkColor( COLORREF crColor );//设置背景颜色
BOOL SetTextBkColor( COLORREF cr );//设置文本背景颜色
virtual COLORREF SetTextColor( COLORREF crColor );//设置文本颜色
virtual BOOL TextOut( int x, int y, LPCTSTR lpszString, int nCount );//输出文本
BOOL TextOut( int x, int y, const CString& str );
CString Left( int nCount ) const;//得到字符串左边nCount个字符
int GetLength( ) const;//得到字符串长度

7,字体CFont::CFont
CFont( );//构造函数
//Constructs a CFont object. The resulting object must be initialized with CreateFont, CreateFontIndirect, CreatePointFont, or CreatePointFontIndirect before it can be used.
选用字体事例代码组：
CClientDC dc(this);
CFont font;//构造字体对象
font.CreatePointFont(300,"华文行楷",NULL);//初始化字体对象，与字体资源相关联
CFont *pOldFont=dc.SelectObject(&font);//将新字体选入DC
...
dc.SelectObject(pOldFont);//恢复原字体
说明：
1）构造字体对象时候，必须初始化。（初始化是将字体对象与字体资源相关联）。
2）初始化对象时候，选用的字体也可以是系统字体，但不一定都有效，据测试选用。

8，在MFC中CEditView 和 cRichEditView类已经完成了初步的文字处理。可以让应用程序的View类以CEditView 和 cRichEditView类为基类。

9，平滑变色
CDC::TextOut()是一个字母一个字母的输出，达不到平滑效果。
CDC::DrawText()：将文字的输出局限于一个矩形区域，超出矩形区域的文字都被截断。利用这一特点，可每隔些时间增加矩形大小，从而可实现人眼中的平滑效果。
CWnd::SetTimer()：设置定时器。按设定的时间定时发送WM_TIMER消息。

说明：
UINT SetTimer( UINT nIDEvent, UINT nElapse, void (CALLBACK EXPORT* lpfnTimer)(HWND, UINT, UINT, DWORD) );
//nIDEvent定时器标示，nElapse消息发送间隔时间，void (CALLBACK EXPORT* lpfnTimer)(HWND, UINT, UINT, DWORD)设置回调函数，如果设置则由设置的回调函数处理WM_TIMER消息，如果没有设置回调函数设为NULL，这发送的WM_TIMER消息压入消息队列，交由相关联的窗口处理（添加WM_TIMER消息处理函数OnTimer()）。

afx_msg void OnTimer( UINT nIDEvent );
//响应WM_TIMER消息，nIDEvent为消息对应定时器标示（可以设置不同的定时器发送WM_TIMER消息）



问题：
1，在CCareView类中添加WM_CREATE消息响应函数OnCreate(),WM_CREATE消息是在什么时候被检查到而被响应的呢？
（猜测：添加WM_CREATE消息后，消息被压入消息队列，然后经过消息循环进行分发到具体窗口，从而进行响应）

2,现有一文本文件内容已经读入串STR中，要求在视图客户区按原先文本文件中的格式输出。
问题是，利用CDC的TextOut()来在CView类派生类窗口中输出串时，忽略了串中的TAB、回车换行等格式，无论串有多长均在一行上输出。
这其中是CDC类成员函数TextOut()忽略串中格式的，还是CView类派生类窗口设置从中做怪呢？怎么解决？

孙鑫VC++讲座笔记-(6)菜单编程
1,弹出菜单（Pop-up)是不能用来作命令响应的。

2，MFC中菜单项消息如果利用ClassWizard来对菜单项消息分别在上述四个类中进行响应，则菜单消息传递顺序：View类--Doc类--CMainFrame类--App类。菜单消息一旦在其中一个类中响应则不再在其它类中查找响应函数。
具体：
当点击一个菜单项的时候，最先接受到菜单项消息的是CMainFrame框架类，CMainFrame框架类将会把菜单项消息交给它的子窗口View类，由View类首先进行处理；如果View类检测到没对该菜单项消息做响应，则View类把菜单项消息交由文档类Doc类进行处理；如果Doc类检测到Doc类中也没对该菜单项消息做响应，则Doc类又把该菜单项消息交还给View类，由View类再交还给CMainFrame类处理。如果CMainFrame类查看到CMainFrame类中也没对该消息做响应，则最终交给App类进行处理。

3，消息的分类：标准消息，命令消息，通告消息。
[标准消息]：除WM_COMMAND之外，所有以WM_开头的消息。
[命令消息]：来自菜单、加速键或工具栏按钮的消息。这类消息都以WM_COMMAND呈现。
在MFC中，通过菜单项的标识（ID）来区分不同的命令消息；在SDK中，通过消息的wParam参数识别。
[通告消息]：由控件产生的消息，例如，按钮的单击，列表框的选择等均产生此类消息，为的是向其父窗口（通常是对话框）通知事件的发生。这类消息也是以WM_COMMAND形式呈现。
说明：
1）从CWnd派生的类，都可以接收到[标准消息]。
2）从CCmdTarget派生的类，都可以接收到[命令消息]和[通告消息]。

4，一个菜单拦可以有若干个子菜单，一个子菜单又可以有若干个菜单项等。对菜单栏的子菜单由左至右建立从0开始的索引。对特定子菜单的菜单项由上至下建立了从0开始的索引。访问子菜单和菜单项均可以通过其索引或标识（如果有标识的话）进行。
相关重要函数：
CMenu* GetMenu( ) ;//CWnd::GetMenu得到窗口菜单栏对象指针。
CMenu* GetSubMenu( ) ;//CMenu::GetSubMenu获得指向弹出菜单对象指针
UINT CheckMenuItem( );//CMenu::CheckMenuItem Adds check marks to or removes check marks from menu items in the pop-up menu.
BOOL SetDefaultItem();//CMenu::SetDefaultItem Sets the default menu item for the specified menu.
BOOL SetMenuItemBitmaps( );//CMenu::SetMenuItemBitmaps 设置位图标题菜单。
UINT EnableMenuItem();//CMenu::EnableMenuItem使菜单项有效，无效，或变灰。
BOOL SetMenu( CMenu* pMenu );//CWnd::SetMenu在当前窗口上设置新菜单或移除菜单。
HMENU Detach( );//CMenu::Detach Detaches a Windows menu from a CMenu object and returns the handle.
说明：
1）在计算子菜单菜单项的索引的时候，分隔栏符也算索引的。
2）int GetSystemMetrics()获取系统信息度量。可以用它来获取菜单标题的尺寸从而设置位图标题菜单中位图的大小。
3）在MFC中MFC为我们提供了一套命令更新机制，所有菜单项的更新都是由这套机制来完成的。所以要想利用CMenu::EnableMenuItem来自己控制菜单使用或不使用变灰等，必须要在CMainFrame的构造函数中将变量m_bAutoMenuEnable设置为FALSE。
4）Create a CMenu object on the stack frame as a local, then call CMenu’s member functions to manipulate the new menu as needed. Next, call CWnd::SetMenu to set the menu to a window, followed immediately by a call to the CMenu object’s Detach member function. The CWnd::SetMenu member function sets the window’s menu to the new menu, causes the window to be redrawn to reflect the menu change, and also passes ownership of the menu to the window. The call to Detach detaches the HMENU from the CMenu object, so that when the local CMenu variable passes out of scope, the CMenu object destructor does not attempt to destroy a menu it no longer owns. The menu itself is automatically destroyed when the window is destroyed.
5）You can use the LoadMenuIndirect member function to create a menu from a template in memory, but a menu created from a resource by a call to LoadMenu is more easily maintained, and the menu resource itself can be created and modified by the menu editor.
6）EXAMPLE：
CMenu menu;//定义为局部对象
menu.LoadMenu(IDR_MAINFRAME);
SetMenu(&menu);
menu.Detach();// 这里menu对象作为一个局部对象。使用Detach()从menu对象中分离窗口菜单句柄，从而当menu对象析构的时候窗口菜单资源不随之销毁。

5，命令更新机制：
菜单项状态的维护是依赖于CN_UPDATE_COMMAND_UI消息，谁捕获CN_UPDATE_COMMAND_UI消息，MFC就在其中创建一个CCmdUI对象。
在后台操作系统发出WM_INITMENUPOPUP消息，然后由MFC的基类如CFrameWnd接管并创建一个CCmdUI对象和第一个菜单项相关联，调用对象成员函数DoUpdate()（注：这个函数在MSDN中没有找到说明）发出CN_UPDATE_COMMAND_UI消息，这条消息带有指向CCmdUI对象的指针。此后同一个CCmdUI对象又设置为与第二个菜单项相关联，这样顺序进行，直到完成所有菜单项。
更新命令UI处理程序仅应用于弹出式菜单项上的项目，不能应用于永久显示的顶级菜单项目。
说明：
1）可以手工或用ClassWizard来给菜单项添加UPDATE_COMMAND_UI消息响应，利用响应函数中传进来的CCmdUI对象指针可完成设置菜单项可使用，不可使用，变灰，设置标记菜单等操作。

6，如果要想让工具栏上的某个图标与菜单项的某个菜单相关联，只需要将图标的ID设置为该菜单项的ID。
工具栏图标的索引记数顺序是：从做至右从0开始，分隔符也算索引号。

7,利用向项目中添加VC的POPMENU控件：Project->Add to Project->Components and Controls..
系统增加的内容：A，一个菜单资源；B，在派生View类中增加了OnContextMenu()函数
说明：
1）CWnd::OnContextMenu Called by the framework when the user has clicked the right mouse button (right clicked) in the window. You can process this message by displaying a context menu using the TrackPopupMenu.
2）BOOL TrackPopupMenu( UINT nFlags, int x, int y, CWnd* pWnd, LPCRECT lpRect = NULL );
//CMenu::TrackPopupMenu Displays a floating pop-up menu at the specified location and tracks the selection of items on the pop-up menu. A floating pop-up menu can appear anywhere on the screen.

8，利用调用TrackPopupMenu函数，手工添加弹出菜单：
1）用资源管理器添加一个菜单资源
2）在鼠标右键消息响应函数中，加载菜单资源，并获得要显示的子菜单指针，并用该指针调用TrackPopupMenu函数便完成任务（但要注意：鼠标响应函数传进来的坐标是客户区坐标，而TrackPopupMenu函数中使用的是屏幕坐标，在调用TrackPopupMenu前要调用ClientToScreen客户区坐标到屏幕坐标的转换）
事例代码：
CMenu menu;
menu.LoadMenu(IDR_MENU1);
CMenu *pPopup=menu.GetSubMenu(0);
ClientToScreen(&point);
pPopup->TrackPopupMenu(TPM_LEFTALIGN | TPM_RIGHTBUTTON, point.x, point.y,this);
说明：
CWnd::ClientToScreen(..);//将一个坐标点或一个矩形区域坐标转换成屏幕坐标。
CMenu::TrackPopupMenu(..);//在指定位置以指定的方式显示弹出菜单。
CWnd::ScreenToClient(..);
//Converts the screen coordinates of a given point or rectangle on the display to client coordinates.

9,当弹出菜单属于框架窗口的时候（可在TrackPopupMenu函数参数中设置），弹出菜单上的消息，在路由的时候，仍然遵循View-DOC-MainFrame-APP的响应顺序。

10，动态菜单编程：
所有的资源对象都有一个数据成员保存了资源的句柄。
CMenu::AppendMenu //Appends a new item to the end of a menu.
CMenu::CreatePopupMenu //Creates an empty pop-up menu and attaches it to a CMenu object.
CMenu::InsertMenu
//Inserts a new menu item at the position specified by nPosition and moves other items down the menu.
CMenu::GetSubMenu //Retrieves a pointer to a pop-up menu.
CWnd::GetMenu //Retrieves a pointer to the menu for this window.
CMenu::DeleteMenu //Deletes an item from the menu.

11，手动给动态菜单项添加响应函数：
在Resource.h中可以添加资源的ID
在头文件中写消息函数原型
在代码文件中添加消息映射和添加消息响应函数
说明：
可以先创建一个临时的菜单项，设置它的ID和动态菜单项的一致，然后对它用向导进行消息响应，然后删除临时菜单。
再在代码文件中把消息映射放到宏外（注意一定要放到宏外面，因为CLASSWIZARD发现菜单删除了，同时要把其宏对里的消息映射也删除掉的）

12，CWnd::DrawMenuBar
//Redraws the menu bar. If a menu bar is changed after Windows has created the window, call this function to draw the changed menu bar

CWnd::GetParent //get a pointer to a child window’s parent window (if any).
CWnd::Invalidate //注意其参数的作用

13，集合类：
CStringArray，CStringArray，CDWordArray，CPtrArray，CStringArray，CUIntArray，CWordArray
其中成员函数：
CArray::GetAt
CArray::Add

14,命令消息是到OnCommand函数的时候完成路由的。
由于CWnd::OnCommand 是个虚函数，可以在框架类中重写OnCommand函数，从而可以截获菜单消息使它不再往下（VIEW类）路由。
例：
BOOL CMainFrame::OnCommand(WPARAM wParam, LPARAM lParam)
{
// TODO: Add your specialized code here and/or call the base class
int MenuCmdId=LOWORD(wParam);//取命令ID
CMenu2View *pView=(CMenu2View*)GetActiveView();//获取当前VIEW类指针
if(MenuCmdId>=IDM_PHONE1 && MenuCmdId<IDM_PHONE1+pView->m_strArray.GetSize())//消息范围判断
{
CClientDC dc(pView);
dc.TextOut(0,0,pView->m_strArray.GetAt(MenuCmdId-IDM_PHONE1));
return TRUE;
  //函数返回，避免调用CFrameWnd::OnCommand函数，在CFrameWnd::OnCommand中截获的消息会交由VIEW类处理
}
return CFrameWnd::OnCommand(wParam, lParam);
//调用基类OnCommand函数，在CFrameWnd::OnCommand中截获的消息会交由VIEW类处理
}

MSDN说明：
virtual BOOL OnCommand( WPARAM wParam, LPARAM lParam );
//The framework calls this member function when the user selects an item from a menu, when a child control sends a notification message, or when an accelerator keystroke is translated.
OnCommand processes the message map for control notification and ON_COMMAND entries, and calls the appropriate member function.
Override this member function in your derived class to handle the WM_COMMAND message. An override will not process the message map unless the base class OnCommand is called.

15，LOWORD与HIWORD宏
WORD LOWORD(
DWORD dwValue // value from which low-order word is retrieved
);
WORD HIWORD(
DWORD dwValue // value from which high-order word is retrieved
);

//The LOWORD macro retrieves the low-order word from the given 32-bit value.
//The HIWORD macro retrieves the high-order word from the given 32-bit value.


16，CFrameWnd::GetActiveView
CView* GetActiveView( ) const;//获取当前视窗口指针（单文档框架中）

17，源文件是单独参与编译的