CBitmap m_bmZD,m_bmBack;

CBrush m_brZD,m_brBack;

和在初始化函数中 BOOL nameDlg::OnInitDialog(){填加

     VERIFY(m_bmZD.LoadBitmap(IDB_BG)); // IDB_BG 为位图ID       

     VERIFY(m_brZD.CreatePatternBrush(&m_bmZD));  

     VERIFY(m_bmBack.LoadBitmap(IDB_BG));

     VERIFY(m_brBack.CreatePatternBrush(&m_bmBack));  

3、填加利用向导映射AboutDlg的WM_CTLCOLOR消息，产生函数

HBRUSH nameDlg::OnCtlColor(CDC* pDC, CWnd* pWnd, UINT nCtlColor)

{

     HBRUSH hbr = CDialog::OnCtlColor(pDC, pWnd, nCtlColor);

     pDC->SetBkMode(TRANSPARENT);    

     if (nCtlColor==CTLCOLOR_EDIT)return hbr;

     else if(nCtlColor == CTLCOLOR_LISTBOX )

     return m_brBack;

     return m_brZD;    

     // TODO: 如果默认的不是所需画笔，则返回另一个画笔

     //return hbr;

} 

http://blog.ednchina.com/jimmy_qiu/49876/message.aspx

BOOL CXPButtonDemoDlg::OnEraseBkgnd(CDC* pDC)
{
BOOL retValue= CDialog::OnEraseBkgnd(pDC);
CRect rc;
GetClientRect(&rc);
pDC->FillSolidRect(&rc,RGB(0,0,255));
return retValue;
}

void CXPButton::PreSubclassWindow()
{
CButton::PreSubclassWindow();
ModifyStyle(0, BS_OWNERDRAW);
//设置按钮的有效区域
CRgn rgn;
CRect rc;
GetClientRect(&rc);
//有效区域为一个角半径为5的圆角矩形
rgn.CreateRoundRectRgn(rc.left,rc.top,rc.right,rc.bottom,5,5);
SetWindowRgn(rgn,TRUE);
rgn.DeleteObject();
}

BOOL CXPButton::OnEraseBkgnd(CDC* pDC)
{
//禁止绘制底色
return TRUE;
}

上一篇： 制作 MSN、QQ 的消息提示窗口
下一篇： 在单文档中添加系统菜单项

一、图像控制的对象结构

1 图像控制的数据成员

m_hImageList 连接图像对象的控制句柄

2 图像控制的建立方法

CimageList＆imageList建立图像控制对象结构

Create 初始化图像列表并绑定对象

图像控制的建立方法如下：

BOOL Create( int cx, int cy, UINT nFlags, int nInitial, int nGrow );

BOOL Create( UINT nBitmapID, int cx, int nGrow, COLORREF crMask );

BOOL Create( LPCTSTR lpszBitmapID, int cx, int nGrow, COLORREF crMask );

BOOL Create( CImageList& imagelist1, int nImage1, CImageList& imagelist2,int nImage2,int dx, int dy );

其中各项参数的含义为：cx定义图像的宽度，单位为象素；cy定义图象的高度，单位为象素；nFlags确定建立图像列表的类型，可以是以下值的组合： ILC_COLOR、ILC_COLOR4、ILC_COLOR8、ILC_COLOR16、ILC_COLOR24、ILC_COLOR32、 ILC_COLORDDB和ILC_MASK；nInitial用来确定图像列表包含的图像数量；nGrow用来确定图像列表可控制的图像数量。

NbitmapID 用来确定图像列表联系的位图标志值；crMask表示颜色屏蔽位；

LpszBitmapID 用来确定包含位图资源的标识串；

imagelist1 指向图像列表控制对象的一个指针；nImage1图像列表1中包含的图像数量；imagelist2指向图像列表控制对象的一个指针；nImage2图像列表2中包含的图像数量；dx表示以象素为单位的图像宽度；dy表示以象素为单位的图像高度。

同样，图像控制的建立也包括两个步骤，首先建立图像列表结构，然后建立图像列表控制。

3 图像控制的属性类

图像控制的属性类包括返回m_hImageList.控制句柄GetSafeHandle、取得图像列表中的图像数量GetImageCount、设置图像列表的背景颜色SetBkColor、取得图像列表的背景颜色SetBkColor和取得图像的有关信息SetBkColor。

4 图像控制的操作方法

图像控制的操作方法包括将一个图像列表绑定到一个对象上Attach、将对象上的图像列表解除绑定并返回句柄Detach、删除一个图像列表DeleteImageList、将一个图像增加到图像列表中Add和将一个图像从图像列表中删除Remove等。

二、图像控制的应用技巧

对于图像控制，同样不能单独使用，必须与列表控制、树控制和标签控制相互结合应用，下面分别介绍其具体应用技巧。

1 图像控制在列表控制中的应用技巧

1.1 设置图像控制CListCtrl::SetImageList的调用格式如下：

CImageList* SetImageList( CImageList* pImageList, int nImageList );

其返回值是指向前一个图像列表控制的一个指针，如果不存在前一个图像列表则为NULL；其中参数pImageList是指向图像列表的标识，nImageList是图像列表的类型，可以是如下值：

LVSIL_NORMAL 用大图标方式进行图像列表；

LVSIL_SMALL 用小图标方式进行图像列表；

LVSIL_STATE 以图像状态进行图像列表；

1.2 取得图像控制CListCtrl::GetImageList的调用格式如下：

CImageList* GetImageList( int nImageList ) const;

其返回值为指向图像列表控制的指针，其中nImageList用来确定取得返回值的图像列表的值，其取值与设置图像列表函数相同。

③图像控制在列表控制中的应用示例

CImageList Cil1,Cil2; //定义大小图标像列表

CVCLISTApp *pApp=(CVCLISTApp *)AfxGetApp();//取得列表控制程序

Cil1.Create(32,32,TRUE,2,2);//建立32位图像控制

Cil1.Add(pApp->LoadIcon(IDI_GJ));//增加选中状态图像

Cil1.Add(pApp->LoadIcon(IDI_XS));//增加非选中状态图像

Cil2.Create(16,16,TRUE,2,2); //建立16位图像控制

Cil2.Add(pApp->LoadIcon(IDI_GJ));//增加选中状态图像

Cil2.Add(pApp->LoadIcon(IDI_XS));//增加非选中状态图像

m_ListCtrl.SetImageList(&Cil1,LVSIL_NORMAL);//设置大图标控制

m_ListCtrl.SetImageList(&Cil2,LVSIL_SMALL);//设置小图标控制

2 图像控制在树控制中的应用技巧

2.1 设置图像控制CTreeCtrl::SetImageList的调用格式如下：

CImageList* SetImageList( CImageList * pImageList, int nImageListType );

其返回值为指向前前一个图像列表的指针，否则为NULL；参数pImageList为指向图像列表的标识，如果pImageList为NULL则所有的图像都将从树控制中被清除；nImageListType为图像列表设置的类型，可以是如下值之一：

TVSIL_NORMAL 设置正常图像列表，其中包括选中和非选中两种图标；

TVSIL_STATE 设置图像列表状态，指用户自定义状态；

2.2 取得图像控制CTreeCtrl::GetImageList的调用格式如下：

CImageList* GetImageList( UINT nImage );

如果调用成功则返回图像列表控制指针，否则为NULL；nImage为取得返回值的图像列表类型，其取值和取得图像列表控制完全相同。

2.3 图像控制在树控制中的应用示例

CImageList Cil1,Cil2;//定义大小图标像列表

CVCTREEApp *pApp=(CVCTREEApp *)AfxGetApp();//获取应用程序指针

Cil1.Create(16,16,ILC_COLOR,2,2);//建立图像控制

Cil1.Add(pApp->LoadIcon(IDI_PM));//增加选中状态图像

Cil1.Add(pApp->LoadIcon(IDI_CJ));//增加非选中状态图像

m_TreeCtrl.SetImageList(&Cil1,TVSIL_NORMAL);//设置图像控制列表

然后在树控制的结构定义中进行如下设置：

TCItem.item.iImage=0; //设置未选中图像索引号

TCItem.item.iSelectedImage=1;//设置选中时图像引号

3 图像控制在控制中的应用技巧

1.设置图像控制CTabCtrl::SetImageList的调用格式

CImageList * SetImageList( CImageList * pImageList );

其返回值为指向前一个图像列表的指针，如果不存在前一个图像列表则为NULL；pImageList为标识TAB控制的图像列表指针。

2 取得图像控制CTabCtrl::GetImageList的调用格式

HIMAGELIST GetImageList() const;

其返回值为指向TAB控制的图像列表指针，如果调用不成功则为NULL。
http://www.cnblogs.com/sherlockhua/archive/2008/02/11/1067013.html

　　 在此篇之前我们已经学会了在窗口显示图形，更准确的说是在窗口指定位置显示图形或文字，我们使用的坐标单位是象素，称之为设备坐标。看下面语句：

pDC->Rectangle(CRect(0,0,200,200));

　　 画一个高和宽均为200个象素的方块，因为采用的是默认的MM_TEXT映射模式，所以在设备环境不一样时，画的方块大小也不一样，在1024*768的显示器上看到的方块会比640*480的显示器上的小（在不同分辨率下的屏幕象素，在WINDOWS程序设计一书中有示例程序可以获得，或者可以用GetClientRect函数获得客户区的矩形大小。在这里就不说了，大家只要知道就行了），在输出到打印机时也会有类似的情况发生。如何做才能保证在不同设备上得到大小一致的方块或者图形、文字呢？就需要我们进行选择模式映射，来转换设备坐标和逻辑坐标。

Windows提供了以下几种映射模式：

MM_TEXT
MM_LOENGLISH
MM_HIENGLISH
MM_LOMETRIC
MM_HIMETRIC
MM_TWIPS
MM_ISOTROPIC
MM_ANISOTROPIC

下面分别讲讲这几种映射模式：

MM_TEXT：

　　 默认的映射模式，把设备坐标被映射到象素。x值向右方向递增；y值向下方向递增。坐标原点是屏幕左上角（0，0）。但我们可以通过调用CDC的SetViewprotOrg和SetWindowOrg函数来改变坐标原点的位置看下面两个例子：

//************************************************
// 例子6-1
void CMyView::OnDraw(CDC * pDC)
{
pDC->Rectangle(CRect(0,0,200,200));//全部采用默认画一个宽和高为200象素的方块
}

//**************************************************
// 例子6-2
void CMyView::OnDraw(CDC * pDC)
{
pDC->SetMapMode(MM_TEXT);//设定映射模式为MM_TEXT
pDC->SetWindowOrg(CPoint(100,100));//设定逻辑坐标原点为（100，100）
pDC->Rectangle(CRect(100,100,300,300));//画一个宽和高为200象素的方块
}

　　 这两个例子显示出来的图形是一样的，都是从屏幕左上角开始的宽和高为200象素的方块，可以看出例子2将逻辑坐标（100，100）映射到了设备坐标（0，0）处，这样做有什么用？滚动窗口使用的就是这种变换。

固定比例映射模式：

MM_LOENGLISH、MM_HIENGLISH、MM_LOMETRIC、MM_HIMETRIC、MM_TWIPS这一组是Windows提供的重要的固定比例映射模式。

它们都是x值向右方向递增，y值向下递减，并且无法改变。它们之间的区别在于比例因子见下：（我想书上P53页肯定是印错了，因为通过程序实验x值向右方向也是递增的）

MM_LOENGLISH 0.01英寸
MM_HIENGLISH 0.001英寸
MM_LOMETRIC 0.1mm
MM_HIMETRIC 0.01mm
MM_TWIPS 1/1440英寸 //应用于打印机，一个twip相当于1/20磅，一磅又相当于1/72英寸。

看例3

//**************************************************
// 例子6-3
void CMyView::OnDraw(CDC * pDC)
{
pDC->SetMapMode(MM_HIMETRIC);//设定映射模式为MM_HIMETRIC
pDC->Rectangle(CRect(0,0,4000,-4000));//画一个宽和高为4厘米的方块
}

　　 还有一种是可变比例映射模式，MM_ISOTROPIC、MM_ANISOTROPIC。用这种映射模式可以做到当窗口大小发生变化时图形的大小也会相应的发生改变，同样当翻转某个轴的伸展方向时图象也会以另外一个轴为轴心进行翻转，并且我们还可以定义任意的比例因子，怎么样很有用吧。
MM_ISOTROPIC、MM_ANISOTROPIC两种映射模式的区别在于MM_ISOTROPIC模式下无论比例因子如何变化纵横比是1：1而M_ANISOTROPIC模式则可以纵横比独立变化。

让我们看例子4

//**************************************************
// 例子6-4
void CMy002View::OnDraw(CDC* pDC)
{
CRect rectClient; //
GetClientRect(rectClient);//返回客户区矩形的大小
pDC->SetMapMode(MM_ANISOTROPIC);//设定映射模式为MM_ANISOTROPIC
pDC->SetWindowExt(1000,1000);
pDC->SetViewportExt (rectClient.right ,-rectClient.bottom );
//用SetWindowExt和SetViewportExt函数设定窗口为1000逻辑单位高和1000逻辑单位宽
pDC->SetViewportOrg(rectClient.right/2,rectClient.bottom/2 );//设定逻辑坐标原点为窗口中心
pDC->Ellipse(CRect(-500,-500,500,500));//画一个撑满窗口的椭圆。
// TODO: add draw code for native data here
}

怎么样，屏幕上有一个能跟随窗口大小改变而改变的椭圆。把 pDC->SetMapMode(MM_ANISOTROPIC)；这句改为pDC->SetMapMode(MM_ISOTROPIC)会怎样？大家可以试试。那还有一个问题就是上例的比例因子是多少呢？看下面公式（注意是以例子4为例的）

x比例因子=rectClient.right/1000 //视窗的宽除以窗口范围
y比例因子=-rectClient.bottom/1000 //视窗的高除以窗口范围

　　 从Windows的鼠标消息可以获得鼠标指针的当前坐标值（point.x和point.y）此坐标值是设备坐标。

很多MFC库函数尤其是CRect的成员函数只能工作在设备坐标下。
还有我们有时需要利用物理坐标，物理坐标的概念就是现实世界的实际尺寸。
设备坐标-逻辑坐标-物理坐标之间如何进行转换便成为我们要考虑的一个问题，物理坐标和逻辑坐标是完全要我们自己来做的，但WINDOWS提供了函数来帮助我们转换逻辑坐标和设备坐标。

CDC的LPtoDP函数可以将逻辑坐标转换成设备坐标
CDC的DPtoLP函数可以将设备坐标转换成逻辑坐标

下面列出我们应该在什么时候使用什么样的坐标系一定要记住：

◎CDC的所有成员函数都以逻辑坐标为参数
◎CWnd的所有成员函数都以设备坐标为参数
◎区域的定义采用设备坐标
◎所有的选中测试操作应考虑使用设备坐标。
◎需要长时间使用的值用逻辑坐标或物理坐标来保存。因设备坐标会因窗口的滚动变化而改变。
用书上的例子作为以前几篇的复习，如果你能够独立完成它说明前面的内容已经掌握。另外有些东西是新的，我会比较详细的做出说明，例如客户区、滚动窗口等。

下面我们来一步步完成例子6-5：

■第一步：用AppWizard创建MyApp6。除了Setp 1 选择单文档视图和Setp 6 选择基类为CScrollView外其余均为确省。

■第二步：在CMyApp6View类中增加m_rectEllipse和m_nColor两个私有数据成员。你可以手工在myapp6View.h添加，不过雷神建议这样做，在ClassView中选中CMyApp6View类，击右键选择Add Member Variable插入它们。

//**************************
// myapp6View.h
private:
int m_nColor; //存放椭圆颜色值
CRect m_rectEllipse; //存放椭圆外接矩形

//***************************************************

问题1： CRect是什么？
CRect是类，是从RECT结构派生的，和它类似的还有从POINT结构派生的CPoint、从SIZE派生的CSize。因此它们继承了结构中定义的公有整数数据成员，并且由于三个类的一些操作符被重载所以可以直接在三个类之间进行类的运算。
//重载operator +
CRect operator +( POINT point ) const;
CRect operator +( LPCRECT lpRect ) const;
CRect operator +( SIZE size ) const;
//重载operator -
CRect operator -( POINT point ) const;
CRect operator -( SIZE size ) const;
CRect operator -( LPCRECT lpRect ) const;
......
更多的请在MSDN中查看

■第三步：修改由AppWizard生成的OnIntitalUpdate函数

void CMyApp6View::OnInitialUpdate()
{
CScrollView::OnInitialUpdate();
CSize sizeTotal(20000,30000);
CSize sizePage(sizeTotal.cx /2,sizeTotal.cy /2);
CSize sizeLine(sizeTotal.cx /50,sizeTotal.cy/50);
SetScrollSizes(MM_HIMETRIC,sizeTotal,sizePage,sizeLine);//设置滚动视图的逻辑尺寸和映射模式
}

问题2： 关于void CMyApp6View::OnInitialUpdate()

函数OnInitialUpdate()是一个非常重要的虚函数，在视图窗口完全建立后框架用的第一个函数，框架在第一次调用OnDraw前会调用它。因此这个函数是设置滚动视图的逻辑尺寸和映射模式的最佳地点。

■第四步：编辑CMyApp6View构造函数和OnDraw函数

//*********************************************
// CMyApp6View构造函数
//
CMyApp6View::CMyApp6View():m_rectEllipse(0,0,4000,-4000)//椭圆矩形为4*4厘米。
{
m_nColor=GRAY_BRUSH;//设定刷子颜色
}

//************
本文来自: 站长(http://www.qqcf.com) 详细出处参考：http://study.qqcf.com/web/189/21186.htm

尽管如此，其中有关GDI绘图中的坐标映射部分还是有一个问题没有搞清楚，那就是http://xqscorpion.bokee.com/5172295.html。潘爱民翻译的那本VC内幕没有讲清楚；Jeff Prosise的这本书没有讲清楚；MSDN上的东西看的也是一头雾水；Charles Petzold的那本书还没有来得及看。因为这个问题，昨天晚上是带着遗憾的困惑入睡的。

总的来说，我对这两个函数的理解导致的结果是与实际程序运行的结果截然相反。依据MSDN上的解释，有一个很严重的问题没有阐述清楚，那就是：所谓的SetWindowOrg(x, y)函数，到底是表示set window origin to (x, y)还是set window origin as (x, y)；to和as在执行的时候，其操作的效果是截然相反的。

set window origin to (x, y)表示将坐标原点设置到(x, y)；即以(x, y)作为坐标原点，此时原点坐标不再为(0, 0)；
set window origin as (x, y)表示将原来的原点(0, 0)的坐标改为(x, y)；即将所有点的坐标增加(+x, +y)；

现在我的理解是：应该是 set window origin to (x, y)。这种理解基于以下几个前提：
1. 所有绘图语句中给出的坐标，全部是逻辑坐标，即在 window 中的坐标(相对于viewport所表示的设备坐标而言);
2. 所有用户能看到的点，其设备坐标一定是位于(0, 0)和(1024, 768)范围内；(假设显示器为输出设备，采用MM_TEXT映射方式，且屏幕分辨率为1024*768);
3. 所谓“(0,0)就原点，原点的坐标一定就是(0,0)”这种理解，是错误的；
4. Viewport中的坐标表示设备坐标；Window中的坐标表示逻辑坐标；
5. 当在逻辑坐标中指定新的原点后，在执行映射时，设备坐标的原点一定要与逻辑坐标的新原点重合；反过来也是一样，即两个坐标系的原点一定要重合。

下面举例说明：(MM_TEXT映射模式)

(1)
CRect rect(0, 0, 200, 200);
dc.rectangle(rect);
上面的语句在屏幕的最左上角绘制一个正方形;(因为此时逻辑坐标与设备坐标没有偏移)

(2)
dc.SetViewportOrg(100, 100);
CRect rect(0, 0, 200, 200);
dc.rectangle(rect);
将设备坐标的原点设置到(100, 100)；即设备坐标的原点不在(0, 0)处，而是在(100, 100)处；此时若执行映射的话，逻辑坐标的原点(0, 0)需要与设备坐标的原点(100, 100)重合(参考前提5)；那么此时绘制的矩形(0, 0, 200, 200)的坐标(为逻辑坐标，参考前提1)在设备坐标中就会映射为(100, 100, 300, 300)，最终我们在显示器上看到的会是一个向右下方偏移(100, 100)的一个边长为200的正方形(用户看到的点是在设备坐标中的，参考前提2)

(3)
dc.SetWindowOrg(100, 100);
CRect rect(0, 0, 200, 200);
dc.rectangle(rect);
将逻辑坐标的原点设置到(100, 100)；即逻辑坐标的原点不在(0, 0)处，而是在(100, 100)处；此时若执行映射的话，设备坐标的原点(0, 0)需要与逻辑坐标的原点(100, 100)重合(参考前提5)；那么此时绘制的矩形(0, 0, 200, 200)的坐标(为逻辑坐标，参考前提1)在设备坐标中就会映射为(-100, -100, 100, 100)，最终我们在显示器上看到的会是一个只有1/4个大小的矩形的一部分(事实上相当于向左上方偏移(100, 100)的一个边长为200的正方形。注意：用户看到的点是在设备坐标中的，参考前提2)

Windows应用程序通过为指定设备（屏幕，打印机等）创建一个设备描述表（Device Context, DC）在DC表示的逻辑意义的“画布”上进行图形的绘制。DC是一种包含设备信息的数据结构，它包含了物理设备所需的各种状态信息。Win32程序在绘制图形之前需要获取DC的句柄HDC，并在不继续使用时释放掉。

2．CDC及其派生类

CDC及其派生类的继承视图:
CObject
public |------CDC
public |------CClientDC
public |------CPaintDC
public |------CWindowDC
public |------CMetaFileDC
(注意: 除CMetaFileDC以外的三个派生类用于图形绘制.)
[以下几段是翻译MSDN中资料]
CDC类定义了一个设备描述表相关的类，其对象提供成员函数操作设备描述表进行工作，如显示器，打印机，以及显示器描述表相关的窗口客户区域。

通过CDC的成员函数可进行一切绘图操作。CDC提供成员函数进行设备描述表的基本操作，使用绘图工具， 选择类型安全的图形设备结构（GDI），以及色彩，调色板。除此之外还提供成员函数获取和设置绘图属性，映射，控制视口，窗体范围，转换坐标，区域操作，裁减，划线以及绘制简单图形（椭圆，多边形等）。成员函数也提供绘制文本，设置字体，打印机换码，滚动， 处理元文件。

通过CDC的成员函数可进行一切绘图操作。CDC提供成员函数进行设备描述表的基本操作，使用绘图工具， 选择类型安全的图形设备结构（GDI），以及色彩，调色板。除此之外还提供成员函数获取和设置绘图属性，映射，控制视口，窗体范围，转换坐标，区域操作，裁减，划线以及绘制简单图形（椭圆，多边形等）。成员函数也提供绘制文本，设置字体，打印机换码，滚动， 处理元文件。

其派生类:
PaintDC: 封装BeginPaint和EndPaint两个API的调用。
CClientDC: 处理显示器描述表的相关的窗体客户区域。
CWindowDC: 处理显示器描述表相关的整个窗体区域，包括了框架和控 件（子窗体）。
CMetaFileDC: 与元文件相关的设备描述表关联。

CDC提供两个函数，GetLayout和SetLayout用于反转设备描述表的布局。用于方便阿拉伯，希伯来的书写文化习惯的设计，以及非欧洲表中的字体布局。

CDC包含两个设备描述表，m_hDC和m_hAttribDC对应于相同的设备，CDC为m_hDC指定所有的输出GDI调用，大多数的GDI属性调用由m_hAttribDC控制。（如,GetTextColor是属性调用，而SetTextColor是一种输出调用。）

例子：框架使用这两个设备描述表，一个对象从物理设备中读取属性输出到元文件。打印机预览在框架中被执行时也是相同的形式。你也可以编写代码使用这两个设备描述表在你的应用程序中进行类似的操作。

3．使用方法

创建一个UseDC的MFC单文档程序，定制7个按钮用来选择使用的DC，每个按钮由一个成员变量标识控制[互斥]，分别是

bool m_bHDCDisplay ---- 使用整个屏幕的HDC；
bool m_bHDC ---- 使用当前视图的对应的DC；
bool m_bCDC ---- 使用CDC类[当前视图窗体]；
bool m_bCClientDC ---- 使用CClientDC类[视图客户区域DC]；
bool m_bCPaintDC ---- 使用CPaintDC[视图窗体]；
bool m_bCWindowDC ---- 使用CWindowDC[整个视图窗体]；
bool m_bCMetaFileDC ---- 使用CMetaFileDC

添加7个按钮的响应函数以控制这些bool变量.（这里比较简单我就不提供代码了）

视图类构造函数：

CUseDCView::CUseDCView()

{

this->m_bHDCDisplay = false;
this->m_bHDC = false;
this->m_bCDC = false;
this->m_bCClientDC = false;
this->m_bCPaintDC = false;
this->m_bCWindowDC = false;
this->m_bCMetaFileDC = false;
m_hMetaFile = NULL;

}

视图类OnDraw函数

void CUseDCView::OnDraw(CDC* pDC)

{

CUseDCDoc* pDoc = GetDocument();
ASSERT_VALID(pDoc);

//窗体在OnDraw中会自动传入关联当前视图窗体客户矩形区域的CPaintDC
//才能获取相应的设备描述表

HDC HDCDisplay = NULL; //屏幕DC的句柄 对应m_bHDCDisplay
HDC hDC = NULL; //普通DC的句柄 对应m_bHDC;
CDC * pCDC = NULL; //对应m_bCDC
CClientDC * pClientDC = NULL; //对应m_bCClientDC
CPaintDC * pPaintDC = NULL; //对应m_bCPaintDC
CWindowDC * pWindowDC = NULL; //对应m_bCWindowDC
CMetaFileDC * pMetaFileDC = NULL; //对应m_bMetaFileDC

HMETAFILE hMetaFile = NULL;
<!--[if !supportLineBreakNewLine]-->
<!--[endif]-->

RECT rect; //定义一个设备左上角的矩形区域
rect.left = 0;
rect.top = 0;
rect.right = 200;
rect.bottom = 30;

//注意: HDCDisplay和hDC的::Release()中第一个参数HWND
//与GetDC()的第一个参数必须对应。
if(m_bHDCDisplay)
{
HDCDisplay = ::GetDC(NULL); //获得整个显示器区域的DC
::DrawText(HDCDisplay, "HDC of Display", 14, &rect, DT_LEFT|DT_TOP);
::ReleaseDC(NULL, HDCDisplay);
HDCDisplay = NULL;
}
if(m_bHDC) //绘制在客户区域
{
hDC = ::GetDC(this->m_hWnd); //本窗体的DC
::DrawText(hDC, "HDC", 3, &rect, DT_LEFT|DT_TOP);
::ReleaseDC(this->m_hWnd, hDC);
hDC = NULL;
}
else if(m_bCDC){
//必须释放由程序框架传入的pDC才能获取当前客户区域设备描述表
pCDC = this->GetDC(); //当前窗体(视图)的设备描述表
pCDC->DrawText("Use class CDC", 13, &rect, DT_LEFT|DT_TOP);
this->ReleaseDC(pCDC);
pCDC = NULL;
}
else if(m_bCClientDC){
pClientDC = new CClientDC(this); //获取本窗体客户区域的DC
pClientDC->DrawText("Use class CClientDC", &rect, DT_LEFT|DT_TOP);
delete pClientDC;
pClientDC = NULL;
}
else if(m_bCPaintDC) { //测试当前传入的CDC是不是CPaintDC
pPaintDC = (CPaintDC*)pDC;
pPaintDC->DrawText("Use class CPaintDC", &rect, DT_LEFT|DT_TOP);
}
else if(m_bCWindowDC){
pWindowDC = new CWindowDC(this); //获取本窗体框架和客户区域的DC
//注意：绘制字符串的矩形区域空白部分覆盖了视图子窗体的边缘．
pWindowDC->DrawText("Use class CWindowDC", &rect, DT_LEFT|DT_TOP);
delete pWindowDC;
pWindowDC = NULL;
}
else if(m_bCMetaFileDC){
//传入pDC->m_hDC使用pDC绘制,图形在视图窗体左上角
pMetaFileDC = new CMetaFileDC();
pMetaFileDC->m_hDC = pDC->m_hDC;
pMetaFileDC->DrawText("Use class CMetaFileDC", &rect, DT_LEFT|DT_TOP);
pMetaFileDC->Draw3dRect(200, 0, 300, 30, (COLORREF)0xffff00, (COLORREF)0x0000ff);
m_hMetaFile = pMetaFileDC->Close();
delete pMetaFileDC;
pDC->PlayMetaFile(m_hMetaFile);
}

}

MFC程序中使用CPaintDC在视图窗口中绘制图象时要注意，应该在OnPaint()编写关于CPaintDC相关的代码，而不是在OnDraw()中.但是请注意，如果使用OnPaint()函数响应WM_PAINT事件，OnDraw函数将会被屏蔽；

可以使用以下代码测试：

在CUseDCView.h，CUseDCView的类定义中语句DECLARE_MESSAGE_MAP()之前加上afx_msg void OnPaint()，在CUseDCView.cpp中BEGIN_MESSAGE_MAP (CUseDCView, CView)和END_MESSAGE_MAP()之间加上ON_WM_PAINT()。

void CUseDCView::OnPaint()

{
CPaintDC dc(this);
RECT rect;
rect.left = 0;
rect.top = 0;
rect.right = 200;
rect.bottom = 30;
dc.Draw3dRect(&rect, (COLORREF)0xff0000, (COLORREF)0x0000ff);
}

使用CMetaFileDC

有兴趣可以在以下语句中可以尝试以下几种情况：

else if(m_bCMetaFileDC){

...
...

}

情况1：（与上面的OnDraw函数中相同）
//传入pDC->m_hDC使用pDC绘制,图形在视图窗体左上角
pMetaFileDC = new CMetaFileDC();
pMetaFileDC->m_hDC = pDC->m_hDC;
pMetaFileDC->DrawText("Use class CMetaFileDC", &rect, DT_LEFT|DT_TOP);
pMetaFileDC->Draw3dRect(200, 0, 300, 30, (COLORREF)0xffff00, (COLORREF)0x0000ff);
m_hMetaFile = pMetaFileDC->Close();
delete pMetaFileDC;
pDC->PlayMetaFile(m_hMetaFile);

情况2：

//传入pDC->m_hDC使用屏幕DC绘制,图形在视图窗体左上角
HDC hdc;
pMetaFileDC = new CMetaFileDC();
hdc = ::GetDC(NULL);
pMetaFileDC->m_hDC = pDC->m_hDC;
pMetaFileDC->DrawText("Use class CMetaFileDC", &rect, DT_LEFT|DT_TOP);
pMetaFileDC->Draw3dRect(200, 0, 300, 30, (COLORREF)0xffff00, (COLORREF)0x0000ff);
m_hMetaFile = pMetaFileDC->Close();
delete pMetaFileDC;
::PlayMetaFile(hdc, m_hMetaFile);
::ReleaseDC(NULL, hdc);

情况3：

//传入屏幕DC,使用屏幕DC绘制,图像在屏幕左上角
HDC hdc;
pMetaFileDC = new CMetaFileDC();
hdc = ::GetDC(NULL);
pMetaFileDC->m_hDC = hdc;
pMetaFileDC->DrawText("Use class CMetaFileDC", &rect, DT_LEFT|DT_TOP);
pMetaFileDC->Draw3dRect(200, 0, 300, 30, (COLORREF)0xffff00, (COLORREF)0x0000ff);
m_hMetaFile = pMetaFileDC->Close();
delete pMetaFileDC;
::PlayMetaFile(hdc, m_hMetaFile);
::ReleaseDC(NULL, hdc);

情况4：

//传入屏幕DC,使用pDC绘制, 图像在屏幕左上角
HDC hdc;
pMetaFileDC = new CMetaFileDC();
hdc = ::GetDC(NULL);
pMetaFileDC->m_hDC = hdc;
pMetaFileDC->DrawText("Use class CMetaFileDC", &rect, DT_LEFT|DT_TOP);
pMetaFileDC->Draw3dRect(200, 0, 300, 30, (COLORREF)0xffff00, (COLORREF)0x0000ff);
m_hMetaFile = pMetaFileDC->Close();
delete pMetaFileDC;
pDC->PlayMetaFile(m_hMetaFile);
::ReleaseDC(NULL, hdc);

情况5：

//传入屏幕DC,使用pDC绘制,但是绘制前释放屏幕DC,
//没有出错,而且图像绘制在屏幕左上角
HDC hdc;
pMetaFileDC = new CMetaFileDC();
hdc = ::GetDC(NULL);
pMetaFileDC->m_hDC = hdc;
pMetaFileDC->DrawText("Use class CMetaFileDC", &rect, DT_LEFT|DT_TOP);
pMetaFileDC->Draw3dRect(200, 0, 300, 30, (COLORREF)0xffff00, (COLORREF)0x0000ff);
m_hMetaFile = pMetaFileDC->Close();
delete pMetaFileDC;
::ReleaseDC(NULL, hdc);
pDC->PlayMetaFile(m_hMetaFile);

情况6：

//传入屏幕pDC->hDC,使用CMetaFileDC绘制，图像在视图窗体左上角
HDC hdc;
pMetaFileDC = new CMetaFileDC();
hdc = pDC->m_hDC;
pMetaFileDC->m_hDC = hdc;
pMetaFileDC->DrawText("Use class CMetaFileDC", &rect, DT_LEFT|DT_TOP);
pMetaFileDC->Draw3dRect(200, 0, 300, 30, (COLORREF)0xffff00, (COLORREF)0x0000ff);
m_hMetaFile = pMetaFileDC->Close();
pMetaFileDC->PlayMetaFile(m_hMetaFile);
delete pMetaFileDC;
::ReleaseDC(NULL, hdc);

情况7：

//传入屏幕DC,使用CMetaFileDC绘制，图像在屏幕左上角
HDC hdc;
pMetaFileDC = new CMetaFileDC();
hdc = ::GetDC(NULL);
pMetaFileDC->m_hDC = hdc;
pMetaFileDC->DrawText("Use class CMetaFileDC", &rect, DT_LEFT|DT_TOP);
pMetaFileDC->Draw3dRect(200, 0, 300, 30, (COLORREF)0xffff00, (COLORREF)0x0000ff);
m_hMetaFile = pMetaFileDC->Close();
pMetaFileDC->PlayMetaFile(m_hMetaFile);
delete pMetaFileDC;
::ReleaseDC(NULL, hdc);

情况8：

//传入屏幕DC,使用CMetaFileDC绘制，绘图前释放hdc
//仍然没有出错,图像在屏幕左上角
HDC hdc;
pMetaFileDC = new CMetaFileDC();
hdc = ::GetDC(NULL);
pMetaFileDC->m_hDC = hdc;
pMetaFileDC->DrawText("Use class CMetaFileDC", &rect, DT_LEFT|DT_TOP);
pMetaFileDC->Draw3dRect(200, 0, 300, 30, (COLORREF)0xffff00, (COLORREF)0x0000ff);
m_hMetaFile = pMetaFileDC->Close();
::ReleaseDC(NULL, hdc);
pMetaFileDC->PlayMetaFile(m_hMetaFile);
delete pMetaFileDC;

由上面代码可见绘图的位置与传入CMetaFileDC::m_hDC的值有关。

使用CMetaFileDC需要注意：

使用CMetaFileDC对象调用一系列你想重复的CDC的GDI命令，只能使用CDC类中GDI输出命令。CDC的PlayMetaFile可以使用图元文件句柄来执行图元文件中的命令，图元文件也能使用CopyMetaFile使其存储在磁盘上。当不再需要图元文件时，调用DeleteMetaFile从内存中删除它。

第一种：用insert函数插入pair数据，下面举例说明(以下代码虽然是随手写的，应该可以在VC和GCC下编译通过，大家可以运行下看什么效果，在VC下请加入这条语句，屏蔽4786警告  ＃pragma warning (disable:4786) )

#include <map>
#include <string>
#include <iostream>
using namespace std;
int main()
{
 map<int,string> mapStudent;
 mapStudent.insert(pair<int,string>(1,"student_one"));
 mapStudent.insert(pair<int,string>(2,"student_two"));
 mapStudent.insert(pair<int,string>(3,"student_three"));
 map<int,string>::iterator iter;
 for(iter=mapStudent.begin();iter!=mapStudent.end();iter++)
  cout<<iter->first<<' '<<iter->second<<endl;
}

第二种：用insert函数插入value_type数据，下面举例说明

#include <map>
#include <string>
#include <iostream>
using namespace std;
int main()
{
 map<int,string> mapStudent;
 mapStudent.insert(map<int,string>::value_type(1,"student_one"));
 mapStudent.insert(map<int,string>::value_type(2,"student_two"));
 mapStudent.insert(map<int,string>::value_type(3,"student_three"));
 map<int,string>::iterator iter;
 for(iter=mapStudent.begin();iter!=mapStudent.end();iter++)
  cout<<iter->first<<' '<<iter->second<<endl;
}

第三种：用数组方式插入数据，下面举例说明

#include <map>
#include <string>
#include <iostream>
using namespace std;
int main()
{
 map<int,string> mapStudent;
 mapStudent[1]="student_one";
 mapStudent[2]="student_two";
 mapStudent[3]="student_three";
 map<int,string>::iterator iter;
 for(iter=mapStudent.begin();iter!=mapStudent.end();iter++)
  cout<<iter->first<<' '<<iter->second<<endl;
}

以上三种用法，虽然都可以实现数据的插入，但是它们是有区别的，当然了第一种和第二种在效果上是完成一样的，用insert函数插入数据，在数据的插入上涉及到集合的唯一性这个概念，即当map中有这个关键字时，insert操作是插入数据不了的，但是用数组方式就不同了，它可以覆盖以前该关键字对应的值，用程序说明

mapStudent.insert(map<int,string>::value_type(1,"student_one"));
mapStudent.insert(map<int,string>::value_type(1,"student_two"));

上面这两条语句执行后，map中1这个关键字对应的值是“student_one”，第二条语句并没有生效，那么这就涉及到我们怎么知道insert语句是否插入成功的问题了，可以用pair来获得是否插入成功，程序如下

pair<map<int,string>::iterator,bool> Insert_Pair;
Insert_Pair=mapStudent.insert(map<int,string>::value_type(1,"student_one"));

我们通过pair的第二个变量来知道是否插入成功，它的第一个变量返回的是一个map的迭代器，如果插入成功的话Insert_Pair.second应该是true的，否则为false。

下面给出完成代码，演示插入成功与否问题

#include <map>
#include <string>
#include <iostream>
using namespace std;
int main()
{
 map<int,string> mapStudent;
 pair<map<int,string>::iterator,bool> Insert_Pair;
 Insert_Pair＝mapStudent.insert(pair<int,string>(1,"student_one"));
 if(Insert_Pair.second==true)
  cout<<"Insert Successfully!"<<endl;
 else
  cout<<"Insert Failure."<<endl;
 Insert_Pair＝mapStudent.insert(pair<int,string>(1,"student_two"));
 if(Insert_Pair.second==true)
  cout<<"Insert Successfully!"<<endl;
 else
  cout<<"Insert Failure."<<endl;
 map<int,string>::iterator iter;
 for(iter=mapStudent.begin();iter!=mapStudent.end();iter++)
  cout<<iter->first<<' '<<iter->second<<endl;
}

大家可以用如下程序，看下用数组插入在数据覆盖上的效果

#include <map>
#include <string>
#include <iostream>
using namespace std;
int main()
{
 map<int,string> mapStudent;
 mapStudent[1]="student_one";
 mapStudent[1]="student_two";
 mapStudent[2]="student_three";
 map<int,string>::iterator  iter;
 for(iter=mapStudent.begin();iter!=mapStudent.end();iter++)
  cout<<iter->first<<' '<<iter->second<<endl;
}

3.map的大小

在往map里面插入了数据，我们怎么知道当前已经插入了多少数据呢，可以用size函数，用法如下：

int nSize=mapStudent.size();

4.数据的遍历

这里也提供三种方法，对map进行遍历

第一种：应用前向迭代器，上面举例程序中到处都是了，略过不表

第二种：应用反相迭代器，下面举例说明，要体会效果，请自个动手运行程序

#include <map>
#include <string>
#include <iostream>
using namespace std;
int main()
{
 map<int,string> mapStudent;
 mapStudent.insert(pair<int,string>(1,"student_one"));
 mapStudent.insert(pair<int,string>(2,"student_two"));
 mapStudent.insert(pair<int,string>(3,"student_three"));
 map<int,string>::reverse_iterator iter;
 for(iter=mapStudent.rbegin();iter!=mapStudent.rend();iter++)
  cout<<iter->first<<' '<<iter->second<<endl;
}

第三种：用数组方式，程序说明如下

#include <map>
#include <string>
#include <iostream>
using namespace std;
int main()
{
 map<int, string> mapStudent;
 mapStudent.insert(pair<int,string>(1,"student_one"));
 mapStudent.insert(pair<int,string>(2,"student_two"));
 mapStudent.insert(pair<int,string>(3,"student_three"));
 int nSize=mapStudent.size();
 for(int nIndex=1;nIndex<=nSize;nIndex++)
  cout<<mapStudent[nIndex]<<endl;
}

5.数据的查找（包括判定这个关键字是否在map中出现）

在这里我们将体会，map在数据插入时保证有序的好处。
要判定一个数据（关键字）是否在map中出现的方法比较多，这里标题虽然是数据的查找，在这里将穿插着大量的map基本用法。

这里给出三种数据查找方法

第一种：用count函数来判定关键字是否出现，其缺点是无法定位数据出现位置,由于map的特性，一对一的映射关系，就决定了count函数的返回值只有两个，要么是0，要么是1，出现的情况，当然是返回1了

第二种：用find函数来定位数据出现位置，它返回的一个迭代器，当数据出现时，它返回数据所在位置的迭代器，如果map中没有要查找的数据，它返回的迭代器等于end函数返回的迭代器，程序说明

#include <map>
#include <string>
#include <iostream>
using namespace std;
int main()
{
 map<int,string> mapStudent;
 mapStudent.insert(pair<int,string>(1,"student_one"));
 mapStudent.insert(pair<int,string>(2,"student_two"));
 mapStudent.insert(pair<int,string>(3,"student_three"));
 map<int,string>::iterator iter;
 iter=mapStudent.find(1);
 if(iter!=mapStudent.end())
  cout<<"Find,the value is "<<iter->second<<endl;
 else
  cout<<"Do not Find."<<endl;
}

第三种：这个方法用来判定数据是否出现，是显得笨了点，但是，我打算在这里讲解

Lower_bound函数用法，这个函数用来返回要查找关键字的下界(是一个迭代器)
Upper_bound函数用法，这个函数用来返回要查找关键字的上界(是一个迭代器)
例如：map中已经插入了1，2，3，4的话，如果lower_bound(2)的话，返回的2，而upper-bound（2）的话，返回的就是3
Equal_range函数返回一个pair，pair里面第一个变量是Lower_bound返回的迭代器，pair里面第二个迭代器是Upper_bound返回的迭代器，如果这两个迭代器相等的话，则说明map中不出现这个关键字，程序说明

#include <map>
#include <string>
#include <iostream>
using namespace std;
int main()
{
 map<int,string> mapStudent;
 mapStudent[1]="student_one";
 mapStudent[3]="student_three";
 mapStudent[5]="student_five";
 map<int,string>::iterator iter;
 iter=mapStudent.lower_bound(2);
 cout<<iter->second<<endl;//返回的是下界3的迭代器
 iter=mapStudent.lower_bound(3);
 cout<<iter->second<<endl;//返回的是下界3的迭代器
 iter=mapStudent.upper_bound(2);
 cout<<iter->second<<endl;//返回的是上界3的迭代器
 iter=mapStudent.upper_bound(3);
 cout<<iter->second<<endl;//返回的是上界5的迭代器
 pair<map<int,string>::iterator,map<int,string>::iterator> mapPair;
 mapPair=mapStudent.equal_range(2);
 if(mapPair.first==mapPair.second)
  cout<<"Do not Find."<<endl;
 else
  cout<<"Find."<<endl;
 mapPair=mapStudent.equal_range(3);
 if(mapPair.first==mapPair.second)
  cout<<"Do not Find."<<endl;
 else
  cout<<"Find."<<endl;
}

6.数据的清空与判空

清空map中的数据可以用clear()函数，判定map中是否有数据可以用empty()函数，它返回true则说明是空map。

7.数据的删除

这里要用到erase函数，它有三个重载了的函数，下面在例子中详细说明它们的用法

#include <map>
#include <string>
#include <iostream>
using namespace std;
int main()
{
 map<int,string> mapStudent;
 mapStudent.insert(pair<int,string>(1,"student_one"));
 mapStudent.insert(pair<int,string>(2,"student_two"));
 mapStudent.insert(pair<int,string>(3,"student_three"));
 //如果你要演示输出效果，请选择以下的一种，你看到的效果会比较好
 //如果要删除1,用迭代器删除
 map<int,string>::iterator iter;
 iter=mapStudent.find(1);
 mapStudent.erase(iter);
8.其他一些函数用法

 //如果要删除1，用关键字删除
 int n=mapStudent.erase(1);//如果删除了会返回1，否则返回0

 //用迭代器，成片的删除
 //一下代码把整个map清空
 mapStudent.earse(mapStudent.begin(),mapStudent.end());

 //成片删除要注意的是，也是STL的特性，删除区间是一个前闭后开的集合
 //自个加上遍历代码，打印输出吧
}

这里有swap,key_comp,value_comp,get_allocator等函数，感觉到这些函数在编程用的不是很多，略过不表，有兴趣的话可以自个研究。

9.排序

这里要讲的是一点比较高深的用法了,排序问题，STL中默认是采用小于号来排序的，以上代码在排序上是不存在任何问题的，因为上面的关键字是int型，它本身支持小于号运算，在一些特殊情况，比如关键字是一个结构体，涉及到排序就会出现问题，因为它没有小于号操作，insert等函数在编译的时候过不去，下面给出两个方法解决这个问题

第一种：小于号重载，程序举例

#include <map>
#include <string>
using namespace std;
typedef struct tagStudentInfo
{
 int nID;
 string strName;
}StudentInfo,*PStudentInfo;//学生信息
int main()
{
 int nSize;
 //用学生信息映射分数
 map<StudentInfo,int>mapStudent;
 map<StudentInfo,int>::iterator iter;
 StudentInfo studentInfo;
 studentInfo.nID=1;
 studentInfo.strName="student_one";
 mapStudent.insert(pair<StudentInfo,int>(studentInfo,90));
 studentInfo.nID=2;
 studentInfo.strName="student_two";
 mapStudent.insert(pair<StudentInfo,int>(studentInfo,80));
 for(iter=mapStudent.begin();iter!=mapStudent.end();iter++)
  cout<<iter->first.nID<<endl<<iter->first.strName<<endl<<iter->second<<endl;
}

以上程序是无法编译通过的，只要重载小于号，就OK了，如下：

typedef struct tagStudentInfo
{
 int nID;
 string strName;
 bool operator<(tagStudentInfo const& _A) const
 {
  //这个函数指定排序策略，按nID排序，如果nID相等的话，按strName排序
  if(nID<_A.nID)
   return true;
  if(nID==_A.nID)
   return strName.compare(_A.strName)<0;
  return false;
 }
}StudentInfo,*PStudentInfo;  //学生信息

第二种：仿函数的应用，这个时候结构体中没有直接的小于号重载，程序说明

#include <map>
#include <string>
using namespace std;
typedef struct tagStudentInfo
{
 Int nID;
 String strName;
}StudentInfo,*PStudentInfo;  //学生信息
class sort
{
Public:
 bool operator()(StudentInfo const &_A,StudentInfo const &_B) const
 {
  if(_A.nID<_B.nID)
   return true;
  if(_A.nID==_B.nID)
   return _A.strName.compare(_B.strName)<0;
  return false;
 }
};
int main()
{
 //用学生信息映射分数
 map<StudentInfo,int,sort>mapStudent;
 StudentInfo studentInfo;
 studentInfo.nID = 1;
 studentInfo.strName ="student_one";
 mapStudent.insert(pair<StudentInfo,int>(studentInfo,90));
 studentInfo.nID=2;
 studentInfo.strName="student_two";
 mapStudent.insert(pair<StudentInfo,int>(studentInfo,80));
}

10.   另外

由于STL是一个统一的整体，map的很多用法都和STL中其它的东西结合在一起，比如在排序上，这里默认用的是小于号，即less<>，如果要从大到小排序呢，这里涉及到的东西很多，在此无法一一加以说明。

还要说明的是，map中由于它内部有序，由红黑树保证，因此很多函数执行的时间复杂度都是log2N的，如果用map函数可以实现的功能，而STL  Algorithm也可以完成该功能，建议用map自带函数，效率高一些。

下面说下，map在空间上的特性，否则，估计你用起来会有时候表现的比较郁闷，由于map的每个数据对应红黑树上的一个节点，这个节点在不保存你的数据时，是占用16个字节的，一个父节点指针，左右孩子指针，还有一个枚举值（标示红黑的，相当于平衡二叉树中的平衡因子），我想大家应该知道，这些地方很费内存了吧，不说了……

（本文为转载，作者佚名，留作存档，以便自己查找）

　　框架窗口为应用程序的用户界面提供结构框架，它是应用程序的主窗口，负责管理其包容的窗口，一个应用程序的最顶层的框架窗口是应用程序启动时创建的第一个窗口。
　　MFC提供三种类型的框架窗口：单文档窗口，多文档窗口（MDI），对话框。在AppWizard的第一个对话框中，就提供了选项，让用户选择应用程序是基于单文档、多文档还是对话框的。MFC单文档窗口一次只能打开一个文档框架窗口，而MDI应用程序运行时，在应用程序的一个实例中打开多个文档框架窗口，这些窗口称作子窗口（Child Window）。这些文档可以是同一类型的，也可以是不同类型的。如Visual Studio就可以打开资源文件窗口和源程序窗口等不同类型的窗口。此时，激活不同类型的MDI子窗口，菜单也将相应变化。
　　MFC提供了三个类CFrameWnd、CMDIFrameWnd、CMDIChildWnd和CDialog 分别用于支持单文档窗口、多文档窗口和对话框。

CFrameWnd
　　用于SDI框架窗口，形成单个文档及其视的边框。框架窗口既是应用程序的主框架窗口，也是当前文档对应的视图的边框。

CMDIFrameWnd
　　用于MDI应用程序的主框架窗口。主框架窗口是所有MDI文档窗口的容器，并与它们共享菜单条。MDI框架窗口是出现在桌面中的顶层窗口。

CMDIChildWnd
　　用于在MDI主框架窗口中显示打开的各个文档。每个文档及其视都有一个MDI子框架窗口，子框架窗口包含在MDI主框架窗口中。子框架窗口看起来类似一般的框架边框窗口，但它是包含在主框架窗口中，而不是位于桌面的，并且为主窗口所裁剪。而且MDI子窗口没有自己的菜单，它与主MDI框架窗口共享菜单。

CDialog
　　对话框是一种特殊类型的窗口，它的边框一般不可以调整，而且内部包含一些控件窗口。有关对话框作为主窗口的技术可以参见下一章。

　　要生成一个单文档窗口，主窗口就必须从CFrameWnd派生；要生成一个多文档窗口，主窗口就必须从CMDIFrameWnd派生，而且其中的子窗口必须从CMDIChildWnd派生出来；而基于对话框的窗口程序就要从CDialog派生出主窗口类。

子窗口
　　子窗口就是具有WS_CHILD风格的窗口，且一定有一个父窗口。所有的控件都是子窗口。子窗口可以没有边框。子窗口被完全限制在父窗口内部。

父窗口
　　父窗口就是拥有子窗口的窗口。弹出式窗口
　　具有WS_POPUP风格，它可以没有父窗口。这种窗口几乎什么都没有，可看作一个矩形区域。3.5.2窗口的创建

窗口的创建分为两步：第一步是用new创建一个C++的窗口对象，但是此时只是初始化窗口的数据成员，并没有真正创建窗口（这一点与一般的对象有所不同）。

//第一步：创建一个C++对象，其中CMainFrame是从CFrameWnd派生的对象。

CMainFrame* pMyFrame=new CMainFrame();//用new操作符创建窗口对象

或

CMainFrame MyFrame;//定义一个窗口对象，自动调用其构造函数

第二步是创建窗口。CFrameWnd的Create成员函数把窗口给做出来，并将其HWND保存在C++对象的公共数据成员m_hWnd中。

//第二步：创建窗口

pMyFrame->Create(NULL,“My Frame Window”);

或

MyFrame.Create(NULL,“My Frame Window”);

Create函数的原形如下：

BOOL Create( LPCTSTR lpszClassName, LPCTSTR lpszWindowName, DWORD dwStyle = WS_OVERLAPPEDWINDOW, const RECT& rect = rectDefault, CWnd* pParentWnd = NULL, LPCTSTR lpszMenuName = NULL, DWORD dwExStyle = 0, CCreateContext* pContext = NULL );

　　Create函数第一个参数为窗口注册类名，它指定了窗口的图标和类风格。这里我们使用NULL做为其值，表明使用缺省属性。第二个参数为窗口标题。其余几个参数指定了窗口的风格、大小、父窗口、菜单名等。

　　这个函数看起来比较复杂，对于CFrameWnd派生出来的窗口，我们可以使用LoadFrame从资源文件中创建窗口，它只需要一个参数。

pMyFrame->LoadFrame(IDR_FRAME)；

LoadFrame使用该参数从资源中获取许多默认值，包括主边框窗口的标题、图标、菜单、加速键等。但是，在使用LoadFrame时，必须确保标题字符串、图标、菜单、加速键等资源使用同一个ID标识符（在本例中，我们使用IDR_FRAME）。

提示：在Hello程序的InitInstance中我们看不到创建窗口的过程。实际上，在

pDocTemplate = new CSingleDocTemplate(

IDR_MAINFRAME,

RUNTIME_CLASS(CHelloDoc),

RUNTIME_CLASS(CMainFrame), // main SDI frame window

RUNTIME_CLASS(CHelloView));

　　AddDocTemplate(pDocTemplate); 程序片段中，我们看到，CSingleDocTemplate构造函数的第二个参数就是IDR_MAINFRAME。在构造函数内部，已经通过调用m_pMainWnd->LoadFrame(IDR_MAINFRAME)，完成了应用程序主窗口的创建过程。
　　在InitInstance中，创建完窗口后，窗口调用ShowWindow成员函数来显示窗口。ShowWindow带一个参数，指示窗口以何种方式显示（最大化、最小化或一般）。缺省方式为SW_SHOW，但实际上我们经常希望应用程序启动时窗口最大化，此时可以将该参数该为SW_SHOWMAXMIZED，即调用

m_pMainWnd->ShowWindow(SW_SHOWMAXIMIZED)；

　　在MainFrm.cpp中，我们还看到CMainFrame类有一个OnCreate方法。OnCreate成员函数定义如清单3.3。当调用Create或CreateEx时，操作系统会向窗口发送一条WM_CREATE消息。这一函数就是用来响应WM_CREATE消息的。

清单3.3 OnCreate成员函数定义

int CMainFrame::OnCreate(LPCREATESTRUCT lpCreateStruct)

{

if (CFrameWnd::OnCreate(lpCreateStruct) == -1)

return -1;

if (!m_wndToolBar.Create(this) ||

!m_wndToolBar.LoadToolBar(IDR_MAINFRAME))

{

TRACE0("Failed to create toolbar\n");

return -1; // fail to create

}

if (!m_wndStatusBar.Create(this) ||

!m_wndStatusBar.SetIndicators(indicators,

sizeof(indicators)/sizeof(UINT)))

{

TRACE0("Failed to create status bar\n");

return -1; // fail to create

}

// TODO: Remove this if you don't want tool tips or a resizeable toolbar

m_wndToolBar.SetBarStyle(m_wndToolBar.GetBarStyle() |

CBRS_TOOLTIPS | CBRS_FLYBY | CBRS_SIZE_DYNAMIC);

// TODO: Delete these three lines if you don't want the toolbar to

// be dockable

m_wndToolBar.EnableDocking(CBRS_ALIGN_ANY);

EnableDocking(CBRS_ALIGN_ANY);

DockControlBar(&m_wndToolBar);

return 0;

}

　　在OnCreate函数中，首先调用CFrameWnd的缺省处理方法OnCreate完成窗口创建工作。后面是应用程序主窗口的特定工作，在上面程序中，创建了工具条和状态栏（有关工具条和状态栏编程参见下一章有关内容）。可以在此处加入一些初始化工作，如从INI文件中载入设置，显示Splash Window(启动画面)等。

3.5.3 注册窗口

　　在传统的Windows C程序中，送给一个窗口的所有消息是在它的窗口函数中处理的。把一个窗口同它的窗口函数联系起来的过程称为注册窗口类。注册窗口包括对窗口指定一个窗口函数（给出窗口函数的指针）以及设定窗口的光标、背景刷子等内容。一个注册窗口类可以被多个窗口共享。注册窗口通过调用API函数RegisterClass来完成。
　　在MFC下，框架提供了缺省的自动窗口注册过程。框架仍然使用传统的注册类，而且提供了几个标准的注册类，它们在标准的应用程序初始化函数中注册。调用AfxRegisterWndClass全局函数就可以注册附加的窗口类，然后把已经注册的类传给CWnd的Create成员函数。用户可以定制自己的注册过程，以提供一些附加的特性。比如设置窗口的图标、背景、光标等。下面是注册窗口的例子。

BOOL CMainFrame::PreCreateWindow(CREATESTRUCT& cs)

{

// TODO: Modify the Window class or styles here by modifying

// the CREATESTRUCT cs

UINT ClassStyle=CS_VREDRAW|CS_HREDRAW;

cs.style=cs.style&(~FWS_ADDTOTITLE);

cs.lpszClass = AfxRegisterWndClass(ClassStyle,

AfxGetApp()->LoadStandardCursor(IDC_ARROW),

(HBRUSH)(COLOR_WINDOW+1),//for brush

AfxGetApp()->LoadIcon(IDR_MAINFRAME));

return TRUE;

}

　　注册窗口在CFrameWnd的PreCreateWnd方法中完成。从成员函数名字PreCreateWindow中就可以看出来，注册窗口的工作必须在调用Create函数创建窗口之前完成。其中cs.style=cs.style&(~FWS_ADDTOTITLE)指定窗口标题风格，关闭自动添加文档标题的功能。AfxRegisterWndClass指定窗口使用箭头光标、背景刷子使用比窗口颜色标号大一的颜色、图标使用IDR_MAINFRAME标识符指定的图标（当然也可以使用其它图标）。用上面的程序段替换Hello程序MainFrm.cpp中的PreCreateWindow成员函数定义，并重新编译和运行程序。此时，窗口标题变成了Hello，原来令人讨厌的“Untitled-”没有了，因为窗口风格中关闭自动添加当前文件名的风格。

3.5.4 关闭和销毁窗口

　　框架窗口不仅维护窗口的创建，还管理着窗口的关闭和销毁过程。关闭窗口时，操作系统依次向被关闭的窗口发送WM_CLOSE和WM_DESTROY消息。WM_CLOSE消息的缺省处理函数OnClose将调用DestroyWindow，来销毁窗口；最后，框架调用窗口的析构函数作清理工作并删除C++窗口对象。
　　不要使用C++的delete操作符来销毁框架窗口，而应当采用CWnd的DestroyWindow成员函数来销毁。DestroyWindow首先删除子窗口，再删除窗口本身。若窗口以变量方式产生（即在堆栈上分配内存），该窗口对象会被自动清除。若对象是用new操作符创建的（也就是在堆上分配内存的），则需要用户自己处理。有关DestroyWindow问题在第五章对话框技术中还要作进一步解释。

OnClose()常用功能：保存窗口的一些状态、工具条状态，提示保存未保存的数据等等。

void CMainFrame::OnClose()

{

SaveBarState( "MyDockState" );//保存工具条状态

CFrameWnd::OnClose();

}3.5.5 窗口激活

　　活动窗口必定是一个没有父窗口的顶层窗口，包括框架窗口和对话框。当顶层窗口被激活时，Windows向窗口发送WM_ACTIVATE消息，对此消息的缺省处理是将活动窗口设为有输入焦点。
　　输入焦点用于表示哪个窗口有资格接收键盘输入消息。带有输入焦点的窗口或是一个活动窗口，或者是该活动窗口的子窗口。当一个顶层窗口获得输入焦点时，Windows向该窗口发送WM_SETFOCUS消息，此窗口可将输入焦点重定位到它的子窗口上。子窗口不会自动获得输入焦点。失去输入焦点的窗口会收到WM_KILLFOCUS消息。当子窗口拥有输入焦点时，父窗口就不会处理键盘输入了。

MFC支持两种类型的拆分窗口：静态的和动态的。

静态拆分窗口的行列数在拆分窗口被创建时就设置好了，用户不能更改。但是用户可以缩放各行各列。一个静态拆分窗口最多可以包含16行16列。

要找一个使用了静态拆分窗口的应用程序，只要看一下windows管理器即可。

动态拆分窗口最多可以有两行两列，但它们可以相互拆分和合并。Vc就使用了动态拆分窗口使得可以同时编辑源程序文件的两个以上不同的部分。

选择静态或动态拆分的一个准则是是否希望用户能够交互地修改拆分窗口的行列配置。另一个决定因素是计划在拆分窗口中使用的视图种类。

在静态拆分窗口中很容易使用两个以上不同种类的视图，因为您可以在每个窗格中指定所用的视图类型。但是在动态拆分窗口中，MFC管理着视图，

除非从 CsplitterWnd派生一个新类并修改拆分窗口的默认操作性能，否则拆分窗口中的所有视图使用的都是相同的视图类。

静态拆分窗口是用CsplitterWnd::CreateStatic而不是CsplitterWnd::Create创建，并且由于MFC不会自动创建静态拆分窗口中显示的视图，

所以您要亲自在CreateStatic返回之后创建视图。CsplitterWnd为此提供了名为 CreateView的函数。

你应按如下步骤创建一个CSplitterWnd对象：

       1. 在父框架中嵌入一个CSplitterWnd成员变量。

　　2. 重载父框架的CFrameWnd::OnCreateClient成员函数。

　　3. 从重载的OnCreateClient函数中调用类CSplitterWnd的Create或CreateStatic成员函数，并调用CreateView来创建视图。

使用静态拆分窗口的一个优点是由于您自己给窗格添加视图，所以可以控制放入视图的种类。

关键函数

   BOOL CreateStatic( CWnd* pParentWnd, int nRows, int nCols, DWORD dwStyle =
　　WS_CHILD | WS_VISIBLE, UINT nID = AFX_IDW_PANE_FIRST );
　　函数有5个参数，意义如下:
　　● pParentWnd:切分窗口的父窗口指针
　　● nRows:水平方向分隔窗口的数目
　　● nCols:垂直方向分隔窗口的数目
　　● dwStyle:切分窗口的风格
　　● nID:子窗口的ID值，默认为系统定义的AFX_IDW_PANE_FIRST
　　返回值:如果创建成功，返回非零值(TRUE)，否则返回0(FALSE)。
　　m_wndSplitter.CreateStatic(this, 2,1); // 切分为2行1列
　　

　　virtual BOOL CreateView( int row, int col, CRuntimeClass* pViewClass,

 SIZE sizeInit, CCreateContext* pContext );
　　函数有5个参数，意义如下:
　　● row:窗格的行标，从0开始
　　● col:窗格的列标，从0开始
　　● pViewClass:视图的执行期类CRuntimeClass指针，可以用宏RUNTIME_CLASS获得
　　● sizeInit:一个SIZE(或者CSize)类型的数据，指定窗格的初始大小
　　● pContext:一般是由父窗口传递过来，包含窗口的创建信息
　　返回值:如果创建成功，返回非零值(TRUE)，否则返回0(FALSE)。

   m_wndSplitter.CreateView(0,0,RUNTIME_CLASS(CTest),CSize(190,100),pContext)

实现的关键代码

BOOL CMainFrame::OnCreateClient(LPCREATESTRUCT lpcs, CCreateContext* pContext)
{
// TODO: Add your specialized code here and/or call the base class
if(!m_wndSplitter.CreateStatic(this,1,2))
{
return FALSE;
}
CRect rect;
GetClientRect(&rect);
if(!m_wndSplitter.CreateView(0,0,RUNTIME_CLASS(CTest),

                 CSize(rect.Width()/4,rect.Height()),pContext)||
!m_wndSplitter.CreateView(0,1,RUNTIME_CLASS(CSplitterSDIView), 

                    CSize(rect.Width()/4*3,rect.Height()),pContext))
{
return FALSE;
}
return TRUE;
}

重载该函数之前需要做的步骤：

1. 在CMainFrame类中添加protected成员CSplitterWnd m_wndSplitter;

2. 建立对话框资源（IDD_FORMVIEW），并以CFormView类为基类建立相应的视类；

3. 重载OnCreateClient函数（如上述代码）。

4. 如果需要更多的划分，则再添加其他的CSplitterWnd成员变量，但在m_wndSplitter2.CreateStatic（）

   函数里的第一个参数则采用需要划分的那个子视图，如m_wndSplitter2.CreateStatic(&m_wndSplitter1,

   1, 2, WS_CHILD|WS_VISIBLE, m_wndSplitter1.IdFromRowCol(0,0)) )，当然也需要自己创建需要的所

   有视图。

多视类之间的交互

在MFC程序中，各个视类之间进行数据交互是通过Doc类来完成的，由CDocument类来处理文档，

而由CView类来显示。即将数据存储到CDocument类中，而用到数据的时候再从该类中读取。

处理按钮事件：

void CTest::OnShowInt()
{
// TODO: Add your control notification handler code here
CSplitterSDIDoc* pDoc =(CSplitterSDIDoc*) GetDocument();
UpdateData(TRUE);
pDoc->x=m_int;
pDoc->UpdateAllViews(NULL);
}

在CSplitterSDIView中显示：

void CSplitterSDIView::OnDraw(CDC* pDC)
{
CSplitterSDIDoc* pDoc = GetDocument();
ASSERT_VALID(pDoc);
// TODO: add draw code for native data here
CString str;
str.Format("%d", pDoc->x);
pDC->TextOut(0,0,str);
}

CSplitterWnd类的其他成员信息

有关该类的其他成员函数，可以参考MSDN。

其他信息

void CXXSplitterWnd::OnLButtonDown(UINT nFlags,CPoint point) 

{         CWnd::OnLButtonDown(nFlags,point);} 

void CSplitterWndEx::OnDrawSplitter(CDC *pDC, ESplitType nType, const CRect &rectArg){ 

                 if(pDC==NULL)

                   {

                   RedrawWindow(rectArg,NULL,RDW_INVALIDATE|RDW_NOCHILDREN);

                  return;

                  } 

                  ASSERT_VALID(pDC); 

                 CRect rc=rectArg; 

                 switch(nType)

                   { 

                  case splitBorder: 

                 //重画分割窗口边界,使之为红色 

                          pDC->Draw3dRect(rc,RGB(255,0,0),RGB(255,0,0));  

                        rc.InflateRect(-CX_BORDER,-CY_BORDER); 

                          pDC->Draw3dRect(rc,RGB(255,0,0),RGB(255,0,0)); 

                                    return;

                   case splitBox:  

                        pDC->Draw3dRect(rc,RGB(0,0,0),RGB(0,0,0));

                          rc.InflateRect(-CX_BORDER,-CY_BORDER); 

                          pDC->Draw3dRect(rc,RGB(0,0,0),RGB(0,0,0)); 

                         rc.InflateRect(-CX_BORDER,-CY_BORDER);

                          pDC->FillSolidRect(rc,RGB(0,0,0)); 

                          pDC->Draw3dRect(rc,RGB(0,0,0),RGB(0,0,0));

                          return; 

                  case splitBar:  

                 //重画分割条，使之为绿色  

                         pDC->FillSolidRect(rc,RGB(255,255,255));

                          rc.InflateRect(-5,-5); 

                          pDC->Draw3dRect(rc,RGB(255,0,0),RGB(255,0,0)); 

                                    return;  

                 default:

                           ASSERT(FALSE);

                   } 

                  pDC->FillSolidRect(rc,RGB(0,0,255));

}

 void CSplitterWndEx::OnInvertTracker(CRect &rect) 

{                   ASSERT_VALID(this); 

                 ASSERT(!rect.IsRectEmpty()); 

                  ASSERT((GetStyle()&WS_CLIPCHILDREN)==0);

                  CRect rc=rect;  

                 rc.InflateRect(2,2);

                  CDC* pDC=GetDC(); 

                  CBrush* pBrush=CDC::GetHalftoneBrush(); 

                 HBRUSH hOldBrush=NULL; 

                 if(pBrush!=NULL) hOldBrush=(HBRUSH)SelectObject(pDC->m_hDC,pBrush->m_hObject);

                  pDC->PatBlt(rc.left,rc.top,rc.Width(),rc.Height(),BLACKNESS);  

                           if(hOldBrush!=NULL)

                   SelectObject(pDC->m_hDC,hOldBrush);

                  ReleaseDC(pDC); 

} 

 GetClientRect(rect);  

 
2)CRect   rect;  

  GetClientRect(&rect);  

  ....  

  为什么这两段代码的效果一样？？

1.因为 CRect 重载了到 LPRECT 的操作：   

CRect::operator   LPRECT(   ); GetClientRect(rect); 隐含的调用了该操作。

摘自 : http://topic.csdn.net/t/20020816/13/946020.html

2.首先要知道 GetClientRect 函数的原型，如下：   

  void   GetClientRect(   LPRECT   lpRect   )   const;  

  说明这个函数的参数是 LPRECT, 而并非 CRect 或是 CRect* ，那为什么你所说的两种情况都正确呢！   

http://msnpiki.msnfanatic.com/index.php/Main_Page-->

s New Roman;">  1 ）、对于 GetClientRect(rc) ，这里的参数是 CRect ，因为 CRect 类里有个 LPRECT 运算符重载（ operator   LPRECT() ），所以当传一个 CRect 变量给这个函数的时候，这个变量会自动转换成 LPRECT.  

  2) 、对于 GetClientRect(&rc) 那就更好理解了，因为还有一点， CRect 是从 RECT 继承的，所以你传一个 CRect* 给这个函数的时候，它会自动转换成其基类形式（ RECT ）的地址 , 所以也是对的！

文章出处：飞诺网(www.firnow.com):http://dev.firnow.com/course/3_program/c++/cppjs/20100630/288201.html

 GetClientRect(&rect);         //指定窗口的用户区域矩形，得到RECT（即以所在窗口左上角为原点，

                                           仅仅是个大小，返回值的左上角永远为0，0）

 ClientToScreen(&rect);      // 把用户区坐标系下的RECT坐标转换为屏幕坐标系下的RECT坐标
 

ClipCursor(&rect);               //将鼠标锁定在用户区域

GetClientRect()返回一CRect类型，它包含了指定窗口的用户区域矩形。它保存的是参数的地址&rect，该地址指向CRect的位置。CRect类型是在MFC中定义的。用它处理矩形是非常方便的。

如果做完图，想把鼠标移出用户区域，通过ClipCursor(NULL);即可实现。

本文来自CSDN博客，转载请标明出处：http://blog.csdn.net/mydriverc/archive/2007/09/03/1770552.aspx

找了一会后，发现有两个选项可以貌似可以帮助我Revert to this revision 和 Revert changes from this revision
但我不清楚这两个的区别，故google了一把,得到以下信息

譬如有个文件，有十个版本，假定版本号是1，2，3，4，5，6，7，8，9，10。

Revert to this revision： 如果是在版本6这里点击“Revert to this revision”，表示7～10的修改全部作废，历史倒退到了版本6那个年代。

Revert changes from this revision：如果是在版本6这里点击“Revert changes from this revision”，表示版本6这个历史事件被抹杀了，只剩下除版本6外的9个历史事件了。

如果是同时选择了6，7，8三个历史时期并点击“Revert changes from this revision”，表示抹杀6~8这仨历史时期。

同理，如果同时选择7～10，然后点击“Revert changes from this revision”，则效果跟在版本6这里点击“Revert to this revision”是一样的。

UNICODE：它是用两个字节表示一个字符的方法。比如字符'A'在ASCII下面是一个字符，可'A'在UNICODE下面是两个字符,高字符用0填充，而且汉字'程'在ASCII下面是两个字节，而在UNICODE下仍旧是两个字节

。UNICODE的用处就是定长表示世界文字，据统计，用两个字节可以编码现存的所有文字而没有二义。

MBCS，它是多字节字符集，它是不定长表示世界文字的编码。MBCS表示英文字母时就和ASCII一样（这也是我们容易把MBCS和ASCII搞混的原因），但表示其他文字时就需要用多字节。 

WINDOWS下面的程序设计可以支持MBCS和UNICODE两种编码的字符串，具体用那种就看你定义了MBCS宏还是UNICODE宏。MBCS宏对应的字符串指针是char*也就是LPSTR，UNICODE对应的指针是unsigned   short*也就是LPWSTR，为了写程序方便微软定义了类型LPTSTR，在MBCS下他就是char*,   在UNICODE下它是unsigned   char*,这样你就可以重定义一个宏进行不同字符集的转换了。

LPTSTR、LPCSTR、LPCTSTR、LPSTR的意义：

LPSTR：32bit指针 指向一个字符串，每个字符占1字节

LPCSTR:32-bit指针 指向一个常字符串，每个字符占1字节

LPCTSTR:32-bit指针 指向一个常字符串,每字符可能占1字节或2字节，取决于Unicode是否定义

LPTSTR:32-bit指针 每字符可能占1字节或2字节，取决于Unicode是否定义

Windows使用两种字符集ANSI和UNICODE，前者就是通常使用的单字节方式，但这种方式处理象中文这样的双字节字符不方便，容易出现半个汉字的情况。而后者是双字节方式，方便处理双字节字符。

WindowsNT的所有与字符有关的函数都提供两种方式的版本，而Windows9x只支持ANSI方式。_T一般同字常数相关，如_T("Hello"。如果你编译一个程序为ANSI方式，_T实际不起任何作用。而如果编译一个程序为UNICODE方式，则编译器会把"Hello"字符串以UNICODE方式保存。_T和_L的区别在于，_L不管你是以什么方式编译，一律UNICODE方式保存.

Windows核心编程的第一章。

L是表示字符串资源为Unicode的。

比如

wchar_t Str[] = L"Hello World!";

这个就是双子节存储字符了。

_T是一个适配的宏～

当

#ifdef _UNICODE的时候

_T就是L

没有#ifdef _UNICODE的时候

_T就是ANSI的。

比如

LPTSTR lpStr = new TCHAR[32];

TCHAR* szBuf = _T("Hello");

以上两句使得无论是在UNICODE编译条件下都是正确编译的。

而且MS推荐你使用相匹配的字符串函数。

比如处理LPTSTR或者LPCTSTR 的时候，不要用strlen ,而是要用_tcslen

否则在UNICODE的编译条件下，strlen不能处理 wchar_t*的字符串。

T是非常有意思的一个符号（TCHAR、LPCTSTR、LPTSTR、_T()、_TEXT()...），它表示使用一种中间类型，既不明确表示使用 MBCS，也不明确表示使用 UNICODE。那到底使用哪种字符集?编译的时候才决定

在vc++中有着各种字符串的表示法，如您所说。        

首先char*   是指向ANSI字符数组的指针，其中每个字符占据8位（有效数据是除掉最高位的其他7位），这里保持了与传统的C,C++的兼容。      

 LP的含义是长指针(long   pointer)。

LPSTR是一个指向以‘"0’结尾的ANSI字符数组的指针，与char*可以互换使用，在win32中较多地使用LPSTR。而LPCSTR中增加的‘C’的含义是“CONSTANT”（常量），表明这种数据类型的实例不能被使用它的API函数改变，除此之外，它与LPSTR是等同的。    

    为了满足程序代码国际化的需要，业界推出了Unicode标准，它提供了一种简单和一致的表达字符串的方法，所有字符中的字节都是16位的值，其数量也可以满足差不多世界上所有书面语言字符的编码需求，开发程序时使用Unicode（类型为wchar_t)是一种被鼓励的做法。    

    LPWSTR与LPCWSTR由此产生，它们的含义类似于LPSTR与LPCSTR，只是字符数据是16位的wchar_t而不是char。       

 然后为了实现两种编码的通用，提出了TCHAR的定义：   

如果定义_UNICODE，声明如下：     typedef   wchar_t   TCHAR;    

如果没有定义_UNICODE，则声明如下：     typedef   char   TCHAR;     

LPTSTR和LPCTSTR中的含义就是每个字符是这样的TCHAR。       

CString类中的字符就是被声明为TCHAR类型的，它提供了一个封装好的类供用户方便地使用。

如果您还需要进一步的信息，请参看http://msdn.microsoft.com/library/default.asp?url=/library/en-us/vclib/html/_crt_data_type_mappings.asp等其他有关信息。

LPTSTR、LPCSTR、LPCTSTR、LPSTR之间的转换：

如何理解LPCTSTR类型？

2007-11-10 21:43

L表示long指针

这是为了兼容Windows 3.1等16位操作系统遗留下来的，在win32中以及其他的32为操作系统中， long指针和near指针及far修饰符都是为了兼容的作用。没有实际意义。

P表示这是一个指针

C表示是一个常量

T表示在Win32环境中，有一个_T宏

这个宏用来表示你的字符是否使用UNICODE, 如果你的程序定义了UNICODE或者其他相关的宏，那么这个字符或者字符串将被作为UNICODE字符串，否则就是标准的ANSI字符串。

STR表示这个变量是一个字符串

所以LPCTSTR就表示一个指向常固定地址的可以根据一些宏定义改变语义的字符串。

同样， LPCSTR就只能是一个ANSI字符串，在程序中我们大部分时间要使用带T的类型定义。

LPCTSTR == const TCHAR *

CString 和 LPCTSTR 可以说通用。 原因在于CString定义的自动类型转换，没什么奇特的，最简单的C++操作符重载而已。

常量字符串ansi和unicode的区分是由宏_T来决定的。但是用_T("abcd")时， 字符串"abcd"就会根据编译时的是否定一_UNICODE来决定是char* 还是 w_char*。 同样，TCHAR 也是相同目的字符宏。 看看定义就明白了。简单起见，下面只介绍 ansi 的情况，unicode 可以类推。

ansi情况下，LPCTSTR 就是 const char*, 是常量字符串（不能修改的）。

而LPTSTR 就是 char*, 即普通字符串（非常量，可修改的）。

这两种都是基本类型， 而CString 是 C++类， 兼容这两种基本类型是最起码的任务了。

由于const char* 最简单（常量，不涉及内存变更，操作迅速）， CString 直接定义了一个类型转换函数

operator LPCTSTR() {......}， 直接返回他所维护的字符串。

当你需要一个const char* 而传入了CString时， C++编译器自动调用 CString重载的操作符 LPCTSTR()来进行隐式的类型转换。

当需要CString , 而传入了 const char* 时（其实 char* 也可以），C++编译器则自动调用CString的构造函数来构造临时的 CString对象。

因此CString 和 LPCTSTR 基本可以通用。

但是 LPTSTR又不同了，他是 char*， 意味着你随时可能修改里面的数据，这就需要内存管理了(如字符串变长，原来的存贮空间就不够了，则需要重新调整分配内存)。

所以 不能随便的将 const char* 强制转换成 char* 使用。

楼主举的例子

LPSTR lpstr = (LPSTR)(LPCTSTR)string;

就是这种不安全的使用方法。

这个地方使用的是强制类型转换，你都强制转换了，C++编译器当然不会拒绝你，但同时他也认为你确实知道自己要做的是什么。因此是不会给出警告的。

强制的任意类型转换是C(++)的一项强大之处，但也是一大弊端。这一问题在 vc6 以后的版本(仅针对vc而言)中得到逐步的改进(你需要更明确的类型转换声明)。

其实在很多地方都可以看到类似

LPSTR lpstr = (LPSTR)(LPCTSTR)string;

地用法，这种情况一般是函数的约束定义不够完善的原因， 比如一个函数接受一个字符串参数的输入，里面对该字符串又没有任何的修改，那么该参数就应该定义成 const char*， 但是很多初学者弄不清const地用法，或者是懒， 总之就是随意写成了 char* 。 这样子传入CString时就需要强制的转换一下。

这种做法是不安全的，也是不被建议的用法，你必须完全明白、确认该字符串没有被修改。

CString 转换到 LPTSTR (char*), 预定的做法是调用CString的GetBuffer函数，使用完毕之后一般都要再调用ReleaseBuffer函数来确认修改 (某些情况下也有不调用ReleaseBuffer的，同样你需要非常明确为什么这么做时才能这样子处理，一般应用环境可以不考虑这种情况)。

同时需要注意的是， 在GetBuffer 和 ReleaseBuffer之间，CString分配了内存交由你来处理，因此不能再调用其他的CString函数。

CString 转LPCTSTR:

CString cStr;

const char *lpctStr=(LPCTSTR)cStr;

LPCTSTR转CString:

LPCTSTR lpctStr;

CString cStr=lpctStr;

一.函数原型
   strcpy
   extern char *strcpy(char *dest,char *src);
   #include <string.h>
   功能：把src所指由NULL结束的字符串复制到dest所指的数组中
   说明:src和dest所指内存区域不可以重叠且dest必须有足够的空间来容纳src的字符串。
   返回指向dest的指针

memcpy
extern void *memcpy(void *dest,void *src,unsigned int count);
#include <string.h>
   功能：由src所指内存区域复制count个字符串到dest所指内存区域.
   说明：src和dest所指内存区域不能重叠，函数返回指向dest的指针.
  
   memset
   extern void *memset(void *buffer,int c,int count);
   #include <string.h>
   功能：把buffer所指内存区域的前count个字节设置成字符c
   说明：返回指向buffer的指针.

二.区别
    memset 用来对一段内存空间全部设置为某个字符，一般用于在对定义的字符串初始化为' '或者'"0';
    例: char a[100];
          memset(a,'"0',sizeof(a));
   
   memcpy 是用来做内存拷贝，可以用来拷贝任何数据类型的对象，可以指定拷贝的数据长度；
   例:
           char a[100],b[50];
           memcpy(b,a,sizeof(b));   //注意：如果使用sizeof(a),会造成内存溢出
   mem是一段内存，他的长度，必须自己记住.memcpy是见着什么拷贝什么。
   
    strcpy 就只能拷贝字符串，它遇到'"0'就结束拷贝；
      例：char a[100],b[50];
              strcpy(a,b);
              如用strcpy(b,a)要注意a中的字符串长度(第一个'"0'之前) 是否超过50,如果超过，则会造成b的
内存溢出.它是不会拷贝'"0'的，所以一般还有加一个语句:
              *a='"0';
  
三.使用技巧
      memset 可以方便的清空一个数据结构的变量或数组.
      如:
        struct sample_struct
       {
              char csName[16];
              int iSeq;
              int iType;
       };
       对于变量
       struct sample_struct stTest;
       一般情况下，初始化stTest的方法:
        stTest.csName[0]='"0';
        stTest.iSeq=0;
        stTest.iType=0;
    而用memset:
       memset(&stTest,0,sizeof(struct sample_struct));
    如果是数组:
    struct sample_struct TEST[100];
    memset(TEST,0,sizeof(struct sample_struct)*100);

strcpy是拷贝字符串，以"0为标志结束（即一旦遇到数据值为0的内存地址拷贝过程即停止）
strcpy的原型为
char *strcpy(char *dest, const char *src)
而memcpy是给定来源和目标后，拷贝指定大小n的内存数据，而不管拷贝的内容是什么（不仅限于字符）
memcpy的原型为
void *memcpy(void *dest, const void *src, size_t n);

 void *memset(void *s,  int c, size_t n); 

memset:作用是在一段内存块中填充某个给定的值，它对较大的结构体或数组进行清零操作的一种最快方法。

常见的三种错误

　　一.将信息写入.INI文件中.

　　1.所用的WINAPI函数原型为:

BOOL WritePrivateProfileString(
LPCTSTR lpAppName,
LPCTSTR lpKeyName,
LPCTSTR lpString,
LPCTSTR lpFileName
);

　　其中各参数的意义:

　　　LPCTSTR lpAppName 是INI文件中的一个字段名.

　　　LPCTSTR lpKeyName 是lpAppName下的一个键名,通俗讲就是变量名.

　　　LPCTSTR lpString 是键值,也就是变量的值,不过必须为LPCTSTR型或CString型的.

　　　LPCTSTR lpFileName 是完整的INI文件名.

　　2.具体使用方法:设现有一名学生,需把他的姓名和年龄写入 c:\stud\student.ini 文件中.

CString strName,strTemp;
int nAge;
strName="张三";
nAge=12;
::WritePrivateProfileString("StudentInfo","Name",strName,"c:\\stud\\student.ini");

　　此时c:\stud\student.ini文件中的内容如下:

　　　[StudentInfo]
　　　Name=张三

　　3.要将学生的年龄保存下来,只需将整型的值变为字符型即可:

strTemp.format("%d",nAge);
::WritePrivateProfileString("StudentInfo","Age",strTemp,"c:\\stud\\student.ini");

二.将信息从INI文件中读入程序中的变量.

　　1.所用的WINAPI函数原型为:

DWORD GetPrivateProfileString(
LPCTSTR lpAppName,
LPCTSTR lpKeyName,
LPCTSTR lpDefault,
LPTSTR lpReturnedString,
DWORD nSize,
LPCTSTR lpFileName
);

　　其中各参数的意义:

　　　前二个参数与 WritePrivateProfileString中的意义一样.

　　　lpDefault : 如果INI文件中没有前两个参数指定的字段名或键名,则将此值赋给变量.

　　　lpReturnedString : 接收INI文件中的值的CString对象,即目的缓存器.

　　　nSize : 目的缓存器的大小.

　　　lpFileName : 是完整的INI文件名.

　　2.具体使用方法:现要将上一步中写入的学生的信息读入程序中.

CString strStudName;
int nStudAge;
GetPrivateProfileString("StudentInfo","Name","默认姓名",strStudName.GetBuffer(MAX_PATH),MAX_PATH,"c:\\stud\\student.ini");

　　执行后 strStudName 的值为:"张三",若前两个参数有误,其值为:"默认姓名".

　　3.读入整型值要用另一个WINAPI函数:

UINT GetPrivateProfileInt(
LPCTSTR lpAppName,
LPCTSTR lpKeyName,
INT nDefault,
LPCTSTR lpFileName
);

　　这里的参数意义与上相同.使用方法如下:

nStudAge=GetPrivateProfileInt("StudentInfo","Age",10,"c:\\stud\\student.ini");

三.循环写入多个值,设现有一程序,要将最近使用的几个文件名保存下来,具体程序如下:

　　1.写入:

CString strTemp,strTempA;
int i;
int nCount=6;
文件://共有6个文件名需要保存
for(i=0;i {strTemp.format("%d",i);
strTempA=文件名;
文件://文件名可以从数组,列表框等处取得.
::WritePrivateProfileString("UseFileName","FileName"+strTemp,strTempA,
"c:\\usefile\\usefile.ini");
}
strTemp.format("%d",nCount);
::WritePrivateProfileString("FileCount","Count",strTemp,"c:\\usefile\\usefile.ini");
文件://将文件总数写入,以便读出.

　　2.读出:

nCount=::GetPrivateProfileInt("FileCount","Count",0,"c:\\usefile\\usefile.ini");
for(i=0;i {strTemp.format("%d",i);
strTemp="FileName"+strTemp;
::GetPrivateProfileString("CurrentIni",strTemp,"default.fil", strTempA.GetBuffer(MAX_PATH),MAX_PATH,"c:\\usefile\\usefile.ini");

文件://使用strTempA中的内容.

}

　　补充四点:

　　　1.INI文件的路径必须完整,文件名前面的各级目录必须存在,否则写入不成功,该函数返回 FALSE 值.

　　　2.文件名的路径中必须为 \\ ,因为在VC++中, \\ 才表示一个 \ .

　　　3.也可将INI文件放在程序所在目录,此时 lpFileName 参数为: ".\\student.ini".

　　　4.从网页中粘贴源代码时,最好先粘贴至记事本中,再往VC中粘贴,否则易造成编译错误,开始时我也十分不解,好好的代码怎么就不对呢?后来才找到这个方法.还有一些代码中使用了全角字符如:＜，＼等,也会
造成编译错误.

原文：http://tech.ddvip.com/2008-11/122662858992494.html
ClassWizard为CTreeCtrl（树控件）添加的NM_DBLCLK（双击）消息的响应函数中带有一个NMHDR * 型指针形参：

OnDblClkTree(NMHDR* pNMHDR, LRESULT* pResult)

　　这个陌生的指针类型常使初用树控件的编程者陷入迷茫之中。实际上我们完全不理会它，也可以实现树控件的双击响应，即在OnDblClkTree( )函数中调用树控件的成员函数CTreeCtrl::GetSelectedItem( )以获取树控件的子项句柄HTREEITEM，得到此句柄后，我们便可用下列成员函数获取子项各种有用信息：

　　CTreeCtrl::GetItemData( )、

　　CTreeCtrl::GetItemHeight( )、

　　CTreeCtrl::GetItemImage( )、

　　CTreeCtrl::GetItemRect( )、

　　CTreeCtrl::GetItemState( )、

　　CTreeCtrl::GetItemText( )。

通过update(TRUE)取得控件上的值到m_strID，处理修改后通过update(FALSE)传回控件，界面显示
通过m_editID.GetWindText(str),取得值，处理后，通过m_editID.SetWindText(str)传回控件界面显示

update(TRUE)=m_editID.GetWindText(str)?
update(FALSE)=m_editID.SetWindText(str)?

用VC++6.0编程的时候，文本编辑控件Edit Box是一个经常用到的控件。如果你是用它输入一些简单的文字、数字等信息，直接拿来用就可以了，但如果你用它制作大文本的编辑软件，就会觉得不好控制，许多功能无法实现，即便用CEditView，也只会生成一个类似于记事本的东西，再想加入些自己编写的功能也很困难。下面我以CEdit为基类定义了一个CEditBox类，加入了许多文本编辑时经常要用到的接口函数，用它来控制Edit Box控件就很容易制作出具有较强文本编辑功能的编辑软件了。

在这个扩展类中主要增加了以下功能：

①增加控件的容量，使它能容纳大文本；
②可设置编辑控件文字颜色、背景色和字体；
③对控件内的文本和选择文本的访问；
④直接装入文件到控件和保存控件内容到文件；
⑤自定义的右键菜单；
⑥多重ReDo/UnDo功能。

这些功能基本上都是独立的，实际使用时可根据需要选用所需功能。

准备工作：用ClassWizard在工程中加入一个新类，基类选为CEdit，类名设置为CEditBox。

一、设置控件的容量：

EditBox控件默认情况下只能装入64K的文本，如果超出，多出部分会被自动截掉。利用CEdit类的SetLimitText()函数可重新设置控件容量。

函数原型为：

void SetLimitText(UINT nMax);

参数为nMax为控件可接收的文本最大字节数。

设置方法：用ClassWizard在CEditBox类中添加消息函数PreSubclassWindow()，把设置文本容量的语句放在里面即可。

因为nMax为无符号整型，-1是把它设置为可以取到的最大值。你也可以根据需要设置控件的容量。

注意：在不同操作系统下，控件可设置的最大容量也不同。如果是Windows98，这个值就是64K，无法再增大了，而在Windows2000和WindowsXP下这个值要大得多，才可以起到增加控件容量的目的。

二、设置编辑控件的前景色、背景色和字体：

在CEditBox的头文件中加入以下变量定义：

在CEditBox的构造函数中设置它们的初值：

在CEditBox的析构函数中回收创建的字体资源：

这里只设置了前景色和背景色的默认值，如果想设置默认字体，可在上面的PreSubclassWindow()函数中进行设置：

这里使用了比较简单的CreatePointFont()函数创建字体，它只需给出字体尺寸和字体名。如果想创建更复杂的字体，可以改用CreateFont()函数。本例中设置控件的初始字体为尺寸为100（0.1点）的“宋体”字。

如果你想用EditBox本身的默认字体作为初始字体，就不要在PreSubclassWindow()函数中加入这些语句。

用ClassWizard添加消息反射函数CtlColor()来修改控件的文本颜色和背景色。

注意：在ClassWizard下可看到有两个很相似的消息，一个是“=WM_CTLCOLOR”消息，另一个是“WM_CTLCOLOR”消息，这里必须用“=WM_CTLCOLOR”消息添加函数。如果误用了“WM_CTLCOLOR”消息将得不到想要的效果。

PreSubclassWindow()和CtlColor()函数都是消息函数，为了设置控件颜色和字体，还需定义接口函数在使用时调用：

至此，用CEditBox类可以定义出可设置颜色和字体的Edit Box控件了。使用时，先在对话框中加入一个Edit Box控件，用ClassWizard为定义一个控制变量m_Edit，类型设定为CEditBox。然后用m_Edit.SetForeColor(color)、m_Edit.SetBkColor()和m_Edit.SetTextFont(FontHight,FontName)为控件设置颜色和字体，这样就可以作出一个美观的文本框了。

说明：Edit Box控件只能放入纯文本，不支持对文本格式的设置，也就不能对局部的文字颜色和字体进行设置，所以，以上设置都是针对整个控件的。

三、访问编辑控件的内容：

Edit Box控件已经提供了几种访问控件内容的方法：

①定义一个与控件关联的变量，类型可设置为CString或其它类型，用UpdateData()函数来更新控件或变量。

②用GetWindowText()获取控件内文本，用SetWindowText()设置控件文本。

③用SetSel()设置控件内的选择区，用GetSel()获取控件中选择文本的位置，用ReplaceSel()替换选择的文本。

但只用这几种方法还是不太方便，所以在CEditBox类中又增加了几个访问接口函数。

1、读取控件文本ReadText()

参数str是字符串的引用，用于接收读取的控件内容，返回值是控件中文本字节数。

2、用字符串设置控件内容SetText()

参数str是准备设置控件的内容，要求是字符串。

3、读取当前选择的文本ReadSelText()

参数str是字符串的引用，用于接收读出的文本，返回值是读出的文本字节数。

如果当前控件中有内容被选择，则读出选择文本，并返回长度；如果没有选择的文本，读出的是空串，返回为0。

4、设置选择区SetSelText()

参数nStartChar为选择区起点（从0算起），nSelLen为选择区长度。

功能是把控件的指定区域设置为选择的状态。

5、当前是否有选择isSelect()

如果当前控件中有选择的文本，返回非0值，否则返回0。

以上是为了使控件访问更方便而增加的接口函数。再配合CEdit本身提供的访问函数，很多操作都可轻易实现了。

CEdit控件提供访问函数主要有：

int GetWindowText(LPCTSTR lpszStringBuf,int nMaxCount);
获取控件文本，与ReadText()功能相同。

void SetWindowText(LPCTSTR lpszString);
设置控件文本。

void GetSel(int& nStartChar,int& nEndChar);
获取选择区的位置

void SetSel(int nStartChar,int nEndChar,BOOL bNoScroll=FALSE);
设置选择区，参数为起点和终点，用SetSel(0,-1)可设置为全选

void ReplaceSel(LPCTSTR lpszNewText,BOOL bCanUndo=FALSE);
用字符串替换选择的文本

四、与文件的接口：

这部分接口函数供“打开文件”和“保存文件”等操作调用。把它们定义在CEditBox类中，增强了控件的封装性，也可以简化应用中“打开”和“保存”的操作。

1、文件内容装入Edit控件

参数PathName为文件路径名，调用该函数可以把指定文件装入编辑控件。如果文件不存在，直接返回。

2、保存编辑控件内容到文件

参数PathName为文件路径名，调用该函数可以把控件内容写入指定文件。如果建立文件失败，直接返回。

3、新建文件

供“新建”文件菜单消息调用，功能是清空控件。

4、是否有文件打开

如果控件中已经有打开的文件，返回非0，否则返回0。

5、获取打开的文件名

如果控件中已经有打开的文件，返回文件路径名，否则返回空串。

这5个函数中的m_PathName是在CEditBox中定义的字符串变量，并初始化为空串。

五、自定义右键菜单：

文本编辑框已经提供了一个默认右键菜单，如果你想重新定义一个来代替它，可以按下面的方法制作。

在VC++的Project菜单下选择Add To Project下的Components and Controls，在弹出的对话框中打开Visual C++ Components，找到Pop-up Menu，单击Insert按钮，选择加入的类为CEditBox，确定。关闭对话框。

这时，你在CEditBox类中会看到已经加入了下面的代码：

再到资源的Menu下，你可以找到一个ID号为CG_IDR_POPUP_EDIT_BOX的新菜单，编辑它就可得到你想要的右键菜单了。这和其它菜单的做法没有区别，我就不再详细介绍了。

1.string类成员函数c_str()的原型:

                  const char *c_str()const;//返回一个以null终止的c字符串

2.c_str()函数返回一个指向正规c字符串的指针,内容和string类的本身对象是一样的,通过string类的c_str()函数能够把string对象转换成c中的字符串的样式;

3.操作c_str()函数的返回值时,只能使用c字符串的操作函数,如:strcpy()等函数.因为,string对象可能在使用后被析构函数释放掉,那么你所指向的内容就具有不确定性.

eg:

char  * name[20];

string  ptr = "tongnono";

strcpy(name,ptr.c_str());//c_str()返回的是一个临时的指针变量,不能对其操作.