以下未经说明，listctrl默认view 风格为report

相关类及处理函数

MFC：CListCtrl类

SDK：以 “ListView_”开头的一些宏。如 ListView_InsertColumn

1. CListCtrl 风格

      LVS_ICON: 为每个item显示大图标
      LVS_SMALLICON: 为每个item显示小图标
      LVS_LIST: 显示一列带有小图标的item
      LVS_REPORT: 显示item详细资料

      直观的理解：windows资源管理器，“查看”标签下的“大图标，小图标，列表，详细资料”

2. 设置listctrl 风格及扩展风格

      LONG lStyle;
      lStyle = GetWindowLong(m_list.m_hWnd, GWL_STYLE);//获取当前窗口style
      lStyle &= ~LVS_TYPEMASK; //清除显示方式位
      lStyle |= LVS_REPORT; //设置style
      SetWindowLong(m_list.m_hWnd, GWL_STYLE, lStyle);//设置style
 
      DWORD dwStyle = m_list.GetExtendedStyle();
      dwStyle |= LVS_EX_FULLROWSELECT;//选中某行使整行高亮（只适用与report风格的listctrl）
      dwStyle |= LVS_EX_GRIDLINES;//网格线（只适用与report风格的listctrl）
      dwStyle |= LVS_EX_CHECKBOXES;//item前生成checkbox控件
      m_list.SetExtendedStyle(dwStyle); //设置扩展风格
 
      注：listview的style请查阅msdn
      http://msdn.microsoft.com/library/default.asp?url=/library/en-us/wceshellui5/html/wce50lrflistviewstyles.asp

3. 插入数据

      m_list.InsertColumn( 0, "ID", LVCFMT_LEFT, 40 );//插入列
      m_list.InsertColumn( 1, "NAME", LVCFMT_LEFT, 50 );
      int nRow = m_list.InsertItem(0, “11”);//插入行
      m_list.SetItemText(nRow, 1, “jacky”);//设置数据

4. 一直选中item

5. 选中和取消选中一行

    int nIndex = 0;
    //选中
    m_list.SetItemState(nIndex, LVIS_SELECTED|LVIS_FOCUSED, LVIS_SELECTED|LVIS_FOCUSED);
    //取消选中
    m_list.SetItemState(nIndex, 0, LVIS_SELECTED|LVIS_FOCUSED);
 

6. 得到listctrl中所有行的checkbox的状态

      m_list.SetExtendedStyle(LVS_EX_CHECKBOXES);
      CString str;
      for(int i=0; i<m_list.GetItemCount(); i++)
      {
           if( m_list.GetItemState(i, LVIS_SELECTED) == LVIS_SELECTED || m_list.GetCheck(i))
           {
                str.Format(_T("第%d行的checkbox为选中状态"), i);
                AfxMessageBox(str);
           }
      }

7. 得到listctrl中所有选中行的序号

      方法一：
      CString str;
      for(int i=0; i<m_list.GetItemCount(); i++)
      {
           if( m_list.GetItemState(i, LVIS_SELECTED) == LVIS_SELECTED )
           {
                str.Format(_T("选中了第%d行"), i);
                AfxMessageBox(str);
           }
      }

      方法二：
      POSITION pos = m_list.GetFirstSelectedItemPosition();
      if (pos == NULL)
           TRACE0("No items were selected!\n");
      else
      {
           while (pos)
           {
                int nItem = m_list.GetNextSelectedItem(pos);
                TRACE1("Item %d was selected!\n", nItem);
                // you could do your own processing on nItem here
           }
      }

8. 得到item的信息

      TCHAR szBuf[1024];
      LVITEM lvi;
      lvi.iItem = nItemIndex;
      lvi.iSubItem = 0;
      lvi.mask = LVIF_TEXT;
      lvi.pszText = szBuf;
      lvi.cchTextMax = 1024;
      m_list.GetItem(&lvi);

      关于得到设置item的状态，还可以参考msdn文章
      Q173242: Use Masks to Set/Get Item States in CListCtrl
               http://support.microsoft.com/kb/173242/en-us

9. 得到listctrl的所有列的header字符串内容

      LVCOLUMN lvcol;
      char  str[256];
      int   nColNum;
      CString  strColumnName[4];//假如有4列

      nColNum = 0;
      lvcol.mask = LVCF_TEXT;
      lvcol.pszText = str;
      lvcol.cchTextMax = 256;
      while(m_list.GetColumn(nColNum, &lvcol))
      {
           strColumnName[nColNum] = lvcol.pszText;
           nColNum++;
      }

10. 使listctrl中一项可见，即滚动滚动条

11. 得到listctrl列数

12. 删除所有列

      方法一：
         while ( m_list.DeleteColumn (0))
       因为你删除了第一列后，后面的列会依次向上移动。

      方法二：
      int nColumns = 4;
      for (int i=nColumns-1; i>=0; i--)
          m_list.DeleteColumn (i);

13. 得到单击的listctrl的行列号

      添加listctrl控件的NM_CLICK消息相应函数
      void CTest6Dlg::OnClickList1(NMHDR* pNMHDR, LRESULT* pResult)
      {
           // 方法一：
           /*
           DWORD dwPos = GetMessagePos();
           CPoint point( LOWORD(dwPos), HIWORD(dwPos) );
  
           m_list.ScreenToClient(&point);
  
           LVHITTESTINFO lvinfo;
           lvinfo.pt = point;
           lvinfo.flags = LVHT_ABOVE;
    
           int nItem = m_list.SubItemHitTest(&lvinfo);
           if(nItem != -1)
           {
                CString strtemp;
                strtemp.Format("单击的是第%d行第%d列", lvinfo.iItem, lvinfo.iSubItem);
                AfxMessageBox(strtemp);
           }
          */
  
          // 方法二:
          /*
           NM_LISTVIEW* pNMListView = (NM_LISTVIEW*)pNMHDR;
           if(pNMListView->iItem != -1)
           {
                CString strtemp;
                strtemp.Format("单击的是第%d行第%d列",
                                pNMListView->iItem, pNMListView->iSubItem);
                AfxMessageBox(strtemp);
           }
          */
           *pResult = 0;
      }

14. 判断是否点击在listctrl的checkbox上

      添加listctrl控件的NM_CLICK消息相应函数
      void CTest6Dlg::OnClickList1(NMHDR* pNMHDR, LRESULT* pResult)
      {
           DWORD dwPos = GetMessagePos();
           CPoint point( LOWORD(dwPos), HIWORD(dwPos) );
  
           m_list.ScreenToClient(&point);
  
           LVHITTESTINFO lvinfo;
           lvinfo.pt = point;
           lvinfo.flags = LVHT_ABOVE;
    
           UINT nFlag;
           int nItem = m_list.HitTest(point, &nFlag);
           //判断是否点在checkbox上
           if(nFlag == LVHT_ONITEMSTATEICON)
           {
                AfxMessageBox("点在listctrl的checkbox上");
           }
           *pResult = 0;
      }

15. 右键点击listctrl的item弹出菜单

      添加listctrl控件的NM_RCLICK消息相应函数
      void CTest6Dlg::OnRclickList1(NMHDR* pNMHDR, LRESULT* pResult)
      {
           NM_LISTVIEW* pNMListView = (NM_LISTVIEW*)pNMHDR;
           if(pNMListView->iItem != -1)
           {
                DWORD dwPos = GetMessagePos();
                CPoint point( LOWORD(dwPos), HIWORD(dwPos) );
   
                CMenu menu;
                VERIFY( menu.LoadMenu( IDR_MENU1 ) );
                CMenu* popup = menu.GetSubMenu(0);
                ASSERT( popup != NULL );
                popup->TrackPopupMenu(TPM_LEFTALIGN | TPM_RIGHTBUTTON, point.x, point.y, this );
           }
           *pResult = 0;
  }

16. item切换焦点时(包括用键盘和鼠标切换item时)，状态的一些变化顺序

      添加listctrl控件的LVN_ITEMCHANGED消息相应函数
      void CTest6Dlg::OnItemchangedList1(NMHDR* pNMHDR, LRESULT* pResult)
      {
           NM_LISTVIEW* pNMListView = (NM_LISTVIEW*)pNMHDR;
           // TODO: Add your control notification handler code here
   
           CString sTemp;
 
           if((pNMListView->uOldState & LVIS_FOCUSED) == LVIS_FOCUSED &&
            (pNMListView->uNewState & LVIS_FOCUSED) == 0)
           {
                sTemp.Format("%d losted focus",pNMListView->iItem);
           }
           else if((pNMListView->uOldState & LVIS_FOCUSED) == 0 &&
               (pNMListView->uNewState & LVIS_FOCUSED) == LVIS_FOCUSED)
           {
                sTemp.Format("%d got focus",pNMListView->iItem);
           }
 
           if((pNMListView->uOldState & LVIS_SELECTED) == LVIS_SELECTED &&
            (pNMListView->uNewState & LVIS_SELECTED) == 0)
           {
                sTemp.Format("%d losted selected",pNMListView->iItem);
           }
           else if((pNMListView->uOldState & LVIS_SELECTED) == 0 &&
            (pNMListView->uNewState & LVIS_SELECTED) == LVIS_SELECTED)
           {
                sTemp.Format("%d got selected",pNMListView->iItem);
           }
   
           *pResult = 0;
      }

17. 改变选中行的颜色

首先是添加以下消息

ON_NOTIFY( NM_CUSTOMDRAW, IDC_LIST1, OnDrawColorForMyList )  //为改变颜色添加的消息

再添加类成员函数,就OK了:

//改变 m_List 控件单行的颜色
void CSSDTDlg::OnDrawColorForMyList( NMHDR *pNmHdr, LRESULT *pResult )
{
 NMLVCUSTOMDRAW* pLVCD = reinterpret_cast<NMLVCUSTOMDRAW*>( pNmHdr );

    *pResult = CDRF_DODEFAULT;

 if ( CDDS_PREPAINT == pLVCD->nmcd.dwDrawStage )
 {
        *pResult = CDRF_NOTIFYITEMDRAW;
 }
    else if ( CDDS_ITEMPREPAINT == pLVCD->nmcd.dwDrawStage )
 {
        *pResult = CDRF_NOTIFYSUBITEMDRAW;
 }
    else if ( (CDDS_ITEMPREPAINT | CDDS_SUBITEM) == pLVCD->nmcd.dwDrawStage )
 {
  COLORREF clrNewTextColor, clrNewBkColor;
        
  int    nItem = static_cast<int>( pLVCD->nmcd.dwItemSpec );

  //选中行显示字体为红色,否则为黑色
  if(m_item == nItem)  //设置为红色
  {
   clrNewTextColor = RGB( 255, 0, 0 );
  }
  else  //设置为黑色
  {
   clrNewTextColor = RGB( 0, 0, 0 );
  }

  //设置背景色
  if( nItem%2 ==0 )
  {
   clrNewBkColor = RGB( 240, 240, 240 ); //偶数行背景色为灰色
  }
  else
  {
   clrNewBkColor = RGB( 255, 255, 255 ); //奇数行背景色为白色
  }

  pLVCD->clrText = clrNewTextColor;
  pLVCD->clrTextBk = clrNewBkColor;

        *pResult = CDRF_DODEFAULT;
 }
}

在程序中指定颜色一般试用RGB函数,分别输入R、G、B值。RGB函数返回颜色值(Long)。如果在程序中直接指定颜色对应的值，可以稍微加快程序的运行速度。特别在使单双行显示不同颜色等频繁调用RGB函数时，效果要好一些。     
    
   下表是一些常用颜色的值     
    
   Colour      Red      Green      Blue      值     
   黑色   Black    0   0    0    0     
   白色   White    255    255    255    16777215     
   灰色   Gray    192    192    192    12632256     
   深灰色    Dark    Grey    128    128    128    8421504     
   红色    Red    255    0    0    255     
   深红色    Dark    Red    128    0    0    128     
   绿色    Green    0    255    0    65280     
   深绿色    Dark    Green    0    128    0    32768     
   蓝色    Blue    0    0    255    16711680     
   深蓝色    Dark    Blue    0    0    128    8388608     
   紫红色    Magenta    255    0    255    16711935     
   深紫红    Dark    Magenta    128    0    128    8388736     
   紫色    Cyan    0    255    255    16776960     
   深紫    Dark    Cyan    0    128    128    8421376     
   黄色    Yellow    255    255    0    65535     
   棕色    Brown    128    128    0    32896     
   特殊颜色     
   Button    Face                79741120     
   Text                33554432     
   Background                1090519039     
   App.    Workspace                276856960     
    
   RGB函数计算公式:    颜色值    ＝    (65536    *    Blue)    +    (256    *    Green)    +    (Red)

==============================================

rgb(r,g,b)=r+g*256+b*256*256

=================================

Dim color As Double
Dim r, g, b As Integer
color = RGB(0, 0, 0)
r = color Mod 256
g = (color \ 256) Mod 256
b = (color \ 256 \ 256) Mod 256
Print r
Print g
Print b

//更多信息：http://www.webcha.com/gongju/chaxun1/search_121.htm

http://www.wy265.com/cha/rgbyanse.htm

BOOL CADOTestApp::InitInstance()                      　　
{ //初始化OLE/COM库环境                        
 AfxOleInit();
}

                        　　
2. 引入ADO库文件                        　　
使用ADO前必须在工程的stdafx.h文件里用直接引入符号＃import引入ADO库文件，以使编译器能正确编译。代码如下：

＃include 〈comdef.h〉                        　　 
＃import "c:\program files\common files\system\ado\msado15.dll"                       　　 
no_namespace                        　　 
rename ("EOF","adoEOF")

                        　　
头文件comdef.h使我们的应用程序能够使用Visual C＋＋中的一些特殊COM支持类，这些类使得处理OLE自治更为容易一些，OLE自治是ADO使用的数据类型。后三行使用＃import指令在我们的应用程序中输入ADO类库定义。                        　　
ADO类的定义是作为一种资源存储在ADO DLL(msado15.dll）中，在其内部称为类型库。类型库描述了自治接口，以及C＋＋使用的COM vtable接口。当使用＃import指令时，在运行时Visual C＋＋需要从ADO DLL中读取这个类型库，并以此创建一组C＋＋头文件。这些头文件具有.tli 和.tlh扩展名，读者可以在项目的目录下找到这两个文件。在C＋＋程序代码中调用的ADO类要在这些文件中定义。                        　　
程序的第三行指示ADO对象不使用名称空间。在有些应用程序中，由于应用程序中的对象与ADO中的对象之间可能会出现命名冲突，所以有必要使用名称空间。如果要使用名称空间，则可把第三行程序修改为： rename_namespace("AdoNS")。第四行代码将ADO中的EOF(文件结束)更名为adoEOF，以避免与定义了自己的EOF的其他库冲突。
                        　　
3．利用智能指针进行数据库操作                        　　
在CaboutDlg头文件中定义两个ADO智能指针类实例,并在对话框中加入一个ListCtrl。

_ConnectionPtr m_pConnection;                       
_RecordsetPtr m_pRecordset;                        　　
ClistCtrl m_List;

ADO库包含三个智能指针:_ConnectionPtr、_CommandPtr和_RecordsetPtr。              
_ConnectionPtr通常被用来创建一个数据连接或执行一条不返回任何结果的SQL语句，如一个存储过程。                       
_CommandPtr返回一个记录集。它提供了一种简单的方法来执行返回记录集的存储过程和SQL语句。在使用_CommandPtr接口时，可以利用全局_ConnectionPtr接口，也可以在_CommandPtr接口里直接使用连接串。                       
_RecordsetPtr是一个记录集对象。与以上两种对象相比，它对记录集提供了更多的控制功能，如记录锁定、游标控制等。
                        　　
在OnInitDialog()中加入以下代码:

BOOL CAboutDlg::OnInitDialog()
{
    CDialog::OnInitDialog();
    _variant_t TheValue;
    m_List.ResetContent();
    m_pConnection.CreateInstance(_uuidof(Connection));
    m_pRecordset.CreateInstance(_uuidof(Recordset));

    try
    {
        m_pConnection->Open("DSN=ADOTest","","",0); //连接叫作ADOTest的ODBC数据源
        m_pRecordset->Open("SELECT * FROM BlockDefine",(IDispatch*)m_pConnection,
        adOpenDynamic,
        adLockOptimistic,
        adCmdText);
        //执行SQL语句得到一个记录集
        while(!m_pRecordset->adoEOF)
        //遍历所有记录
        {
            TheValue = m_pRecordset->GetCollect("BlockIndex");
            //得到字段BlockIndex的值
            if(TheValue.vt!=VT_NULL)
                m_List.AddString((char*)_bstr_t(TheValue)); //将该值加入到列表控件中

            m_pRecordset->MoveNext();
        }
        m_pRecordset->Close();
        m_pConnection->Close();
    }
    catch(_com_error e) //异常处理
    {
        AfxMessageBox(e->ErrorMessage());
    }

    m_pRecordset = NULL;
    m_pConnection = NULL;
    return TRUE; // return TRUE unless you set the focus to a control
}

MFC microsoft foundation classes
API application programming interface
DLL dynamic link library
GUI graphics user interface
MDI multiple document interface
SDI sigle document interface
OLE object linking&embeded
SDM software development kit
UI user interface
WinApp windows application

windows程序是信息为基础，事件驱动 message based，event driven

windows程序分为程序编码和UI资源两部分，用rc编译器集成一个完整的exe文件

win32 程序开发流程：
资源描述文件.rc中描述各种UI资源，RC编译器RC.EXE读取RC文件描述的所有UI资源

文件集中制作一个.RES文件，再和程序编码结合在一起，成为一个完整的windows可

执行文件。

WINDOWS程序为什么必须使用导入函数库？
windows程序调用的函数分为：c runtimes 以及 windows api两大部分。
windows api，由操作系统本身提供（windows 三大模块

GUI32.DLL,USER32.DLL,KERNEL32.DLL）.
导入函数库，就是存放在链接的时候需要使用什么样的dll文件，以及这些文件存放

的地方。而三大模块所对应的导入函数库别为

GUI32.LIB,USER32.LIB,KERNEL32.LIB.

一般函数是存放到了上边的三大模块中，还有新的api函数，放在dll文件中，比如

COMMDLG.DLL,TOOLHELP.DLL,中，如果使用这些API，链接时还得加上这些dll对应的

导入函数，比如COMDLG32.LIB和TH32.LIB.

WINDOWS程序需要什么头文件？
windows程序必须包含windows.h.它包含的是三大模块所提供的api函数，如果用到

其他system dlls，比如COMMDLG.DLL,MAPI.DLL,TAPI.DLL,就要使用相对应的头文件

COMMDLG.H MAPI.H TAPI.H等等。

windows的运行机制？
信息为基础，以事件驱动。
windows程序运行依靠外部发生的事件来驱动的。程序等待任何可能的输入，然后判

断，最后做出适当处理。
输入是由操作系统捕捉到，以信息形式进入程序之中。
信息，就是windows内设的一种数据结构。

输入分类？
硬件设置所产生的信息：放到系统队列（system queue）
windows系统或是其他windows程序传送过来的信息：放到程序队列（application

queue）。

信息？
信息，就是windows内设的一种数据结构。
typedef struct tagMSG
{
 HWND hwnd;
 UINT message;(WM_)
 WPARAM wParam;(WM_MOUSEMOVE,WM_SIZE,WM_LBUTTONDOWN)
 LPARM lParm;
 DWORD time;
 POINT pt;
}MSG;
接受并处理信息的就是窗口。每个窗口都有一个函数负责处理信息，这个函数就叫

窗口函数（window procedure，window function）

窗口注册和窗口的诞生？
窗口函数就是窗口接收信息后的反应。
产生窗口前用API函数RegisterClass设定窗口属性（就是注册窗口）

窗口的注册用的是RegisterClass (被封装在InitApplication函数中)
窗口的诞生是用CreateWindow(被封装在InitInstance函数中)
InitApplication 和 InitInstance区别：

函数注册：窗口类只需要注册一次，以后可供同一程序的后继每一个实例

（instance）使用（所有进程公在一个地址空间中），因此将RegisterClass这个动

作放在“只有第一个实例才会进入”的InitApplication函数中。
一个进程是否是某个程序的第一个实例，可以用WinMain的参数hPrevInstance来判

断
产生窗口：CreateWindow是任何实例都可以进入，放到InitInstance函数中。

信息循环？
while(GetMessage(&msg,...))
{
 TranslateMessage(&msg);//为了将键盘信息转化
 DispatchMessage(&msg);//将信息传给窗口函数去处理
}

窗口函数？

DispatchMessage(&msg)是一种回调函数，就是你自己写的程序中的被windows系统

调用的函数。
窗口函数形式：
LRESULT CALLBACK WndProc(HWND hWnd,
   UINT message,
   WPARAM wParam,
   LPARAM lParam)
资源定义文件(.RC)：
.RC文件是一个用文字描述资源的地方。常用资源有九项：ICON（图标）,CURSOR（

指针）,BITMAP（位图）,FONT（字体）,DIALOG（对话框）,MENU（菜

单）,ACCELERATOR（加速器）,STRING（字符串）,VERSIONINFO.

核心对象？
系统的一种资源，一旦产生，任何应用程序都可以开启并使用这个对象。系统给核

心对象 一个计数值来管理它。
核心对象包括：             产生方法
event   CreateEvent
mutex   CreateMutex
semaphore  CreateSemphore
以上用于线程同步化
file   CreateFile
file-mapping  CreateFileMapping 用于内存映射文件
process   CreateProcess
thread   CreateThread

进程的诞生和死?
shell中以鼠标双击一个可执行文件图标，就可以执行这个(比如)App.exe的流程：
1shell调用CreateProcess启动App.exe。‘
2系统产生一个“进程核心对象”，计数值为1。
3系统为此进程建立一个4GB地址空间
4载入器将必要的数据载入到上述地址空间中，包括App.exe的程序，数据，以及所

需要的连接函数库（DLL）.载入器是根据.idata section中的（PE文件格式）的记

录文件。
5系统为此进程建立一个线程，称为主线程。线程才是分配cpu时间的分配对象。
6系统调用 C runtime函数库的Startup code。
7Startup code调用App程序的WinMain函数。
8App程序运行开始
9使用者关闭App主窗口，是WinMain中的信息循环结束掉，于是WinMain结束。
10 返回到Startup code。
11返回到系统，系统调用ExitProcess结束进程。

产生子进程？
用CreateProcess

结束进程？
VOID ExitProcess(UINT fuExitCode);

产生额外的线程?
CreateThread()

当进程建立起来后，系统会完成什么（就是已经有了主线程）？
1配置“线程对象”，其handle将成为CreateThread的返回值
2设定计数值为1
3配置线程的context（工作）
4保留线程的堆栈
5将context中的堆栈指针寄存器（ss）和指令指针寄存器（ip）设定妥当

线程优先级？
0－31 从低到高，

级别       代码    优先权值
idle           IDLE_PRIORITY_CLASS  4
normal  NORMAL_PRIORITY_CLASS    9
high  HIGH_PRIORITY_CLASS  13
realtime REALTIME_PRIORITY_CLASS  24

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;
}
就是上边的这个构造函数完成了连接工作。
一般使用的形式是：
class CView:public CWnd
{
 DECLARE_DYNAMIC(CView)
 ...
};
// in implementation file
IMPLEMENT_DYNAMIC(CView CWnd)
这两个宏就完成了构造数据链表的工作。

怎样生成mfc层次结构的类别型录？

.h文件中
class CObject{...};
class CCmdTarget:public CObject
{
 DECLARE_DYNCMIC (CCmdTarget)
 ...
};
class CWinThread:public CCmdTarget
{
 DECLARE_DYNAMIC (CWinThread)
 ...
};
class CWinApp:public CWinThread
{
 DECLARE_DYNAMIC (CWinApp)
 ...
};
class CDocument:public CCmdTarget
{
 DECLARE_DYNAMIC (CDocument)
 ... 
};
class CWnd:public CCmdTarget
{
 DECLARE_DYNAMIC (CWnd)
 ...
};
class CFrameWnd:public CWnd
{
 DECLARE_DYNAMIC (CFrameWnd)
 ...
};
class CView:public CWnd
{
 DECLARE_DYNAMIC (CView)
 ...
};
class CMyWinApp:public CWinApp
{...};
class CMyFrameWnd:public CFrameWnd
{...};
class CMyDoc:public CDocument
{...};
class CMyView:public CView
{...};

.cpp文件中
IMPLEMENT_DYNAMIC(CCmdTarget,CObject)
IMPLEMENT_DYNAMIC(CWinThread,CCmdTarget)
IMPLEMENT_DYNAMIC(CWinApp,CWinThread)
IMPLEMENT_DYNAMIC(CWnd,CCmdTarget)
IMPLEMENT_DYNAMIC(CView,CWnd)
IMPLEMENT_DYNAMIC(CFrameWnd,CWnd)
IMPLEMENT_DYNAMIC(CDocument,CCmdTarget)

IsKindOf是什么？
它是类型识别，就说在建立了“类别型录”网后，在某个类中存在这个函数，就是看这个指针是不是存在某个类的下支中。
比如：
CMyDoc * pMyDoc = new CMyDoc;
CMyView * pMyView = new CMyView;

cout<<pMyDoc->IsKindOf(RUNTIME_CLASS(CMyDoc));//TURE
cout<<pMyDoc->IsKindOf(RUNTIME_CLASS(CDocument));//TURE
cout<<pMyDoc->IsKindOf(RUNTIME_CLASS(CCmdTarget));//TURE
cout<<pMyDoc->IsKindOf(RUNTIME_CLASS(CObject));//TURE
cout<<pMyDoc->IsKindOf(RUNTIME_CLASS(CWinApp));//FALSE

怎样 自制Dynamic Create(动态生成)？

将类的大小记录在类别型录中，把构造函数也记录在类别型录中，当程序在运行时期获得一个类名字，它就可以在“类别型录网”中找到对应的元素，然后根据类的大小，调用构造函数，产生出该对象。

这里使用的是DECLARE_DYNCREATE/IMPLEMENT_DYNCREATE宏
使用和完成类别型录的方式差不多：
class CFrameWnd:public CWnd
{
 DECLARE_DYNCREATE(CFrameWnd)
 ...
};(就是在头文件中)

// in implement （就是在cpp文件中实现）
IMPLEMENT_DYNCREATE(CFrameWnd,CWnd)

怎样自制Persistence（永久保存）机制？
写到文件中去。
把数据写到文件中。方法是：在Document/View结构中，数据都放在一份document里头，我们只要把其中的成员变量陆续写进文件中即可。如果成员变量是个对象，就需要先记载类的名字，然后才是对象中的数据。

什么是Serialize机制？
就是把文件名的选择、文件的访问、缓冲区的建立、数据的读写、运算符（>>）和运算符(<<)的重载、对象的动态生成都包装起来。它的数据读写和对象的动代生成是关键，动态生成已经具有，这里就重点讨论数据的读写操作。

serialize机制就是考虑到每次记录对象内容的时候，先写入一个代码，表示此对象类是否曾在文件中记录过了。如果是新类，就记录类的名字，如果是就类，就用代码表示。还有就是可以控制版本号的问题。有一个专门的serialization函数，用于负责这些任务。
每一个可写到文件或可从文件中读出的类，都应该有它自己的serailize函数。负责它自己数据读写操作，并且应该改写“<<”“>>”,把数据导流导archive中。

怎样完成serialize？
使用DECLARE_SERIAL/IMPLEMENT_SERIAL宏。这个宏的功能是将“<<”和“>>”两个运算符重载，还可以将serialize函数放到类定义中。类能够进行文件读写，其前提是拥有动态生成的能力。
#define DECLARE_SERIAL(class_name)
 DECLARE_DYNCREATE(class_name)
 friend CArchive& AFXAPI operator >>(CArchive& ar,class_name *&pOb)
#define IMPLEMENT_SERIAL(class_name,base_name,wSchema)
 CObject * PASCAL class_name::CreateObject()
 {return new class_name;}
 _IMPLEMENT_RUNTIMECLASS(class_name,base_class_name,wSchema,
  class_name::CreateObject)
 CArchive& AFXAPI operator>>(CArchive& ar,class_name *&pOb)
 {pOb = (class_name*)ar.ReadObject(RUNTIME_CLASS(class_name));
 return ar;}

一个对象处理之前，判断是否第一次出现、记录版本号、记录文件名怎样实现？
用CRuntimeClass中的两个函数Load和Store。
struct CRuntimeClass
{
//attributes
 LPCSTR m_lpszClassName;
 int m_nObjectSize;
 UINT m_wSchema;//schema number of the loaded class
 CObject *(PASCAL * m_pfnCreateObject)();
 CRuntimeClass * m_pBaseClass;
  
 CObject *CreateObject();
 void Store (CArchive&ar)const;
 static CRuntimeClass * PASCAL Load(CArchive &ar,UINT *pwSchemaNum);
//CRuntimeClass objects linked together in simple list
 static CRuntimeClass * pFirstClass;//start of class list
 CRuntimeClass * m_pNextClass;//linked list of registered classes
};

为了让整个serialization机制运行起来，必须做定义为：
.h文件中必须有
class CScribDoc:public CDocument
{
 DECLARE_DYNCREATE(CScribDoc)
 ...
};
class CStroke:public CObject
{
 DECLARE_SERIAL(CStroke)
public:
 void Serialize(CArchive&);
...
};

class CRectangle :public CObject
{
 DECLARE_SERIAL(CRectangle)
public
 void Serialize(CArchive&)

};

class CCircle:public CObjcet
{
 DECLARE_SERIAL(CCircle)
public:
 void Seiralize(CArchive&);
...
};

.cpp文件中必须有
IMPLEMENT_DYNCREATE(CScribDoc,CDocument)
IMPLEMENT_SERIAL(CStroke,CObjcet,2)
IMPLEMENT_SERIAL(CRectangle,CObjcet,1)
IMPLEMENT_SERIAL(CCircle,CObjcet,1)

怎样自制Message Mapping(消息映射)？

当我们的类库成立，如果其中与信息有关的类（就是“信息标的类”mfc中就是CCmdTarget）都是一条链式地继承，我们应该为每一个“信息表的类”准备一个信息映射表，比且将基类与派生类的信息映射表连接起来。然后，当窗口函数做信息的比较时，我们就可以想办法引导它沿着这条路走过去。

定义消息映射的数据结构：
struct AFX_MSGMAP
{
 AFX_MSGMAP * pBaseMessagMap;
 AFX_MSGMAP_ENTRY *lpEntries;
};
其中的AFX_MSGMAP_ENTRY又是另一个数据结构：
struct AFX_MSGMAP_ENTRY
{
 UINT nMessage;
 UINT nCode;
 UINT nID;
 UINT nLastID;
 UINT nSig;
 AFX_PMSG pfn;
}
其中的AFX_PMSG定义为函数指针：
typedef void (CCmdTarget::*AFX_PMSG)(void);

之后定义的宏就是
#define DECLARE_MESSAGE_MAP();
static AFX_MSGMAP_ENTRY_ messageEntries[];
static AFX_MSGMAP messageMap;
virtual AFX_MSGMAP *GetMessageMap()const;

MFC对消息传递的规定是什么？（message routing）
如果是一般的windows信息（WM_xxx）,一定是从派生类流向基类。

MFC程序是不包括主要函数和时间循环。所有的事件处理都是作为CWinApp的一部分在后台处理的。而消息映射就是识别感兴趣的事件然后调用函数来响应这些事件。

一，首先是正常的程序

// button1.cpp
　　#include
　　#define IDB_BUTTON 100
　　// Declare the application class
　　class CButtonApp : public CWinApp
　　{
　　public:
　　virtual BOOL InitInstance();
　　};
　　// Create an instance of the application class
　　CButtonApp ButtonApp;
　　// Declare the main window class
　　class CButtonWindow : public CFrameWnd
　　{
　　CButton *button;
　　public:
　　CButtonWindow();
　　};
　　// The InitInstance function is called once
　　// when the application first executes
　　BOOL CButtonApp::InitInstance()
　　{
　　m_pMainWnd = new CButtonWindow();
　　m_pMainWnd->ShowWindow(m_nCmdShow);
　　m_pMainWnd->UpdateWindow();
　　return TRUE;
　　}
　　// The constructor for the window class
　　CButtonWindow::CButtonWindow()
　　{
　　CRect r;
　　// Create the window itself
　　Create(NULL,
　　"CButton Tests",
　　WS_OVERLAPPEDWINDOW,
　　CRect(0,0,200,200));
　　// Get the size of the client rectangle
　　GetClientRect(&r);
　　r.InflateRect(-20,-20);
　　// Create a button
　　button = new CButton();
　　button->Create("Push me",
　　WS_CHILD|WS_VISIBLE|BS_PUSHBUTTON,
　　r,
　　this,
　　IDB_BUTTON);
　　}

当你运行代码时，会注意到按钮响应了用户事件。既它加亮了。除此之外它没有做任何事情，因为我们还没有教它怎样去做。我们需要编写消息映射来使按钮做一些感兴趣的事情。

二，建立消息映射

// button2.cpp
　　#include
　　#define IDB_BUTTON 100
　　// Declare the application class
　　class CButtonApp : public CWinApp
　　{
　　public:
　　virtual BOOL InitInstance();
　　};
　　// Create an instance of the application class
　　CButtonApp ButtonApp;
　　// Declare the main window class
　　class CButtonWindow : public CFrameWnd
　　{
　　CButton *button;
　　public:
　　CButtonWindow();
　　afx_msg void HandleButton(); //
　　DECLARE_MESSAGE_MAP()
　　};
　　// The message handler function
　　void CButtonWindow::HandleButton()
　　{
　　MessageBeep(-1);
　　}
　　// The message map
　　BEGIN_MESSAGE_MAP(CButtonWindow, CFrameWnd)
　　ON_BN_CLICKED(IDB_BUTTON, HandleButton)
　　END_MESSAGE_MAP()

/*用宏来建立消息映射。在代码中，你可以看见BEGIN_MESSAGE_MAP宏接收两各参数。第一个指定了使用消息映射的类的名称。第二个是基类。然后是ON_BN_CLICKED宏，接受两个参数控制的ID和该ID发送命令消息时所调用的函数。最后，消息映射用END_MESSAGE_MAP来结束。

当用户单击按钮时，它向其包含该按钮的父窗口发送了一个包含其ID的命令消息。那是按钮的缺省行为，这就是该代码工作的原因。按钮向其父窗口发送消息，是因为它是子窗口。父窗口截取该消息并用消息映射来确定所要调用的函数。MFC来安排，只要指定的消息一出现，相应的函数就会被调用。
　　ON_BN_CLICKED消息是CButton发送的唯一感兴趣的消息。它等同于CWnd中的ON_COMMAND消息，只是一个更简单方便的同义词而已。*/
　　// The InitInstance function is called once
　　// when the application first executes
　　BOOL CButtonApp::InitInstance()
　　{
　　m_pMainWnd = new CButtonWindow();
　　m_pMainWnd->ShowWindow(m_nCmdShow);
　　m_pMainWnd->UpdateWindow();
　　return TRUE;
　　}
　　// The constructor for the window class
　　CButtonWindow::CButtonWindow()
　　{
　　CRect r;
　　// Create the window itself
　　Create(NULL,
　　"CButton Tests",
　　WS_OVERLAPPEDWINDOW,
　　CRect(0,0,200,200));
　　// Get the size of the client rectangle
　　GetClientRect(&r);
　　r.InflateRect(-20,-20);
　　// Create a button
　　button = new CButton();
　　button->Create("Push me",
　　WS_CHILD|WS_VISIBLE|BS_PUSHBUTTON,
　　r,
　　this,
　　IDB_BUTTON);
　　}

上边修改了两个地方，1增加了一个新的成员函数和一个新的表示消息映射的宏。HandleButton函数是正常的c++函数，它通过afx_msg标签确定为消息处理函数。该函数有一些特殊约束，比如它必须是void型并且不能接收任何参数。 DECLARE_MESSAGE_MAP宏建立了消息映射。函数和宏都必须是public型的。

对消息映射的理解：

消息映射智能用于MFC。使用消息映射的原因是解决虚拟函数的基本问题。 MFC文件中CWnd类，它包含200多个成员函数，所有成员函数当不使用消息映射都是虚拟的。MFC中大约有近30个类是以CWnd为基类的。这包括所有的可见控制如按钮、静态标签和列表。想象一下，mfc使用虚拟啊和你熟，并且你建立以应用程序包含20个控制.CWnd中200个虚拟函数中每个都需要自己的虚拟函数表，并且一个控制的每个例程都应有一组200个虚拟函数与之关联。则程序可能就有近4000个虚拟函数表在内存中，这对内存有限的及其来书是个大问题，因为其中的大部分是不用的。

消息映射复制了虚拟函数表的操作，但是它是基于需要的基础之上的。消息映射就是对系统说“当你看见一个特殊的消息时，请调用制定的函数”，只有这些函数实际上被重载到消息映射中，就节省二楼内存和cpu的负担。

效果一：改变鼠标进入按钮时的形状(超链接效果)

CButtonST    m_btn;

m_btn.SubclassDlgItem(IDC_BUTTON1,this);
m_btn.SetIcon(IDI_ICON1);
m_btn.OffsetColor(CButtonST::BTNST_COLOR_BK_IN, 30);
m_btn.SetURL("www.scut.edu.cn");
m_btn.SetTooltipText("www.scut.edu.cn");
m_btn.SetBtnCursor(IDC_CURSOR1);

效果二：菜单按钮

CButtonST    m_btn;

m_btn.SubclassDlgItem(IDC_BUTTON1,this);
m_btn.SetIcon(IDI_ICON1);
m_btn.OffsetColor(CButtonST::BTNST_COLOR_BK_IN, 30);
m_btn.SetMenu(IDR_MENU, m_hWnd);

效果三：位图按钮

CButtonST    m_btn;

m_btn.SubclassDlgItem(IDC_BUTTON1,this);
m_btn.SetBitmaps(IDB_BITMAP1,RGB(0,0,0));
m_btn.OffsetColor(CButtonST::BTNST_COLOR_BK_IN, 30);

效果四：按钮焦点

CButtonST    m_btn;

m_btn.SubclassDlgItem(IDC_BUTTON1,this);
m_btn.SetIcon(IDI_ICON1);
m_btn.SetAlign(CButtonST::ST_ALIGN_VERT);
m_btn.DrawFlatFocus(TRUE);

效果五：CheckBox按钮

CButtonST    m_btn;

m_btn.SubclassDlgItem(IDC_CHECK1,this);
m_btn.SetIcon(IDI_ICON1,IDI_ICON2);
m_btn.OffsetColor(CButtonST::BTNST_COLOR_BK_IN, 30);

效果六：透明按钮

CButtonST    m_btn;

m_btn.SubclassDlgItem(IDC_BUTTON1,this);
m_btn.SetIcon(IDI_ICON1);
m_btn.DrawTransparent(TRUE);

效果七：特殊的PictureBox

下载CButtonST示例源代码
下载CButtonST类的源代码

本篇主要包括了以下的效果：
1. 在按钮上加入Icon，使Icon和文字同时显示
2. 显示平面按钮
3. 使按钮上的图标可变
4. 设置按钮在不同状态下的底色和文字颜色
5. 设置图标和文字的位置
6. 根据Icon的形状设置按钮的形状
7. 添加Tooltips

以下是Basic Features的演示界面：


效果一：在按钮上加入Icon，使Icon和文字同时显示

假设按钮ID为IDC_BUTTON1
1. 添加成员变量

CButtonST	m_btn;

2. 添加Icon资源，设其ID设为IDI_ICON1
3. 在OnInitDialog函数中初始化按钮

m_btn.SubclassDlgItem(IDC_BUTTON1,this);
m_btn.SetIcon(IDI_ICON1);
m_btn.SetFlat(FALSE);

注意:为达到最好效果，请根据Icon的大小调整按钮的大小。
实例：演示程序中的Standar 按钮。

效果二：显示平面按钮
只需要在效果一的基础上把m_btn.SetFlat(FALSE);语句去掉。

效果三：使按钮上的图标可变
假设按钮ID为IDC_BUTTON1
1. 添加成员变量

CButtonST	m_btn;

2. 添加两个Icon资源，ID设为IDI_ICON1和IDI_ICON2
IDI_ICON1是普通状态的图标，IDI_ICON2是按下时的图标

3. 在OnInitDialog函数中初始化按钮

m_btn.SubclassDlgItem(IDC_BUTTON1,this);
m_btn.SetIcon(IDI_ICON2,IDI_ICON1);

实例：演示程序中的Halloween 按钮。

效果四：设置按钮在不同状态下的底色和文字颜色

假设按钮ID为IDC_BUTTON1
1. 添加成员变量

CButtonST	m_btn;

2. 添加Icon资源，设其ID设为IDI_ICON1
3. 在OnInitDialog函数中初始化按钮

m_btn.SubclassDlgItem(IDC_BUTTON1,this);
m_btn.SetIcon(IDI_ICON1);
m_btn.SetColor(CButtonST::BTNST_COLOR_BK_OUT, RGB(208,208,208));
m_btn.SetColor(CButtonST::BTNST_COLOR_BK_FOCUS, RGB(208,208,208));
m_btn.OffsetColor(CButtonST::BTNST_COLOR_BK_IN, 30);

提示：SetColor函数和OffsetColor函数的第一个参数表示按钮的各个状态，前景色就是文字的颜色，它们的取值表示：

BTNST_COLOR_BK_IN	//鼠标放在按钮内时的背景色
BTNST_COLOR_FG_IN,	//鼠标放在按钮内时的前景色
BTNST_COLOR_BK_OUT,	//普通状态时的背景色
BTNST_COLOR_FG_OUT,	//普通状态时的前景色
BTNST_COLOR_BK_FOCUS,	//按钮被按下后的背景色
BTNST_COLOR_FG_FOCUS,	//按钮被按下后的前景色

实例：演示程序中的48×48 icon 按钮、Zip按钮等。

效果五：设置图标和文字的位置

假设按钮ID为IDC_BUTTON1
1.添加成员变量

CButtonST	m_btn;

2.添加Icon资源，ID设为IDI_ICON1
3.在OnInitDialog函数中初始化按钮

m_btn.SubclassDlgItem(IDC_BUTTON1,this);
m_btn.SetIcon(IDI_ICON1);
m_btn.SetAlign(CButtonST::ST_ALIGN_VERT);

提示：SetAlign函数的第一个参数表示位置信息，缺省情况下，文字在图标右边

ST_ALIGN_HORIZ	// 文字在右
ST_ALIGN_VERT	//文字在下
ST_ALIGN_HORIZ_RIGHT// 文字在左

实例：演示程序中的Search 按钮。

效果六：根据Icon的形状设置按钮的形状

假设按钮ID为IDC_BUTTON1
1.添加成员变量

CButtonST	m_btn;

2.添加Icon资源，设其ID设为IDI_ICON1
3.在OnInitDialog函数中初始化按钮

m_btn.SubclassDlgItem(IDC_BUTTON1,this);
m_btn.SetIcon(IDI_ICON1);
m_btn.DrawBorder(FALSE);
m_btn.SetColor(CButtonST::BTNST_COLOR_BK_OUT, RGB(208,208,208));
m_btn.SetColor(CButtonST::BTNST_COLOR_BK_IN, RGB(208,208,208));
m_btn.SetColor(CButtonST::BTNST_COLOR_BK_FOCUS, RGB(208,208,208));

注意:为达到最好效果，请根据Icon的大小调整按钮的大小。
并根据实际情况设置背景颜色。请事先将按钮的文字去掉。

效果七：添加Tooltips

假设按钮ID为IDC_BUTTON1
1.添加成员变量

CButtonST	m_btn;

2.添加Icon资源，设其ID设为IDI_ICON1
3. 在OnInitDialog函数中初始化按钮

m_btn.SubclassDlgItem(IDC_BUTTON1,this);
m_btn.SetIcon(IDI_ICON1);
m_btn.SetTooltipText(_T("This is a tooltip.\r\nMultiline!"));

查了很多资料，也试了很多办法，都解决不了。目前只能通过手动添加，这实在不是好办法。 

下面是网上收集的解决办法，解决方案：
1、重启VC/VS2005;

2、打开Resource.h文件看看，有些定义重复了，可以手动改掉，保存，编辑器重新加载;

3、关闭解决方案，删除ncb文件重新添加即可;（这个试过，是可以的）

4、实在不行就手动添加消息处理;

5、查看.h和.cpp文件的属性,有可能是只读的,修改属性后就可以了;

6、把你要添加事件的对话框相应的类文件（*.h和*.cpp）给关了就可以了;