要消除窗口对象,必须清楚窗口对象的构成.在一个通常的程序中，先创建c++窗口对象,然后由Windows创建实际的窗口结构,并返回句柄与c++对象连接.也就是说,窗口对象包含c++窗口对象和Windows窗口对象,两者通过句柄HWND联系.

现在,让我们看看"正规"的窗口对象清除流程.所谓对象的清除是指释放对象所占的资源,窗口对象中Windows窗口对象占有的是系统资源,c++对象占有的是内存资源.释放系统资源相对要简单一些:调用虚函数DestroyWindow删除Windows窗口对象.如果DestroyWindow删除的是父窗口,Windows会自动为子窗口调用DestroyWindow.一般来说,程序不必调用DestroyWindow.因为当用户关闭窗口时,Windows便发送WM_CLOSE消息,WM_CLOSE的缺省消息处理函数CWnd::OnClose调用DestroyWindow.

到这时,清除工作已经完成了一半,屏幕上的窗口已经不见了!但是别忘了,在内存中还有一个c++窗口对象.让我们再看看c++对象清除的过程:当窗口被取消时,窗口最后发送的一个消息是WM_NCDESTROY.它缺省的消息处理函数CWnd::OnNcDestroy把c++窗口对象与句柄HWND分离,并调用一个很重要的虚函数PostNcDestroy.这个函数是搞清窗口对象清除的关键.Cwnd中的PostNcDestroy什么都不做.有些MFC窗口类会重载它,并加入delete this代码删除c++对象.这些窗口类常常是以new操作符建立在堆中的.由于重载了PostNcDestroy,使窗口有自动清除功能.因此,我们不用关心清除问题了.另外的一些MFC窗口类一般是以变量形式创建的,MFC没有为也没必要为它们重载PostNcDestroy函数.

不具备自动清除功能的窗口类,一般在堆栈中创建或嵌入于其它c++对象中:

所有标准的Windows控件类(如CStatic, CEdit, CListBox等等)

由CWnd类直接派生出来的子窗口对象(如用户定制的控件)

拆分窗口类(CSplitterWnd)

缺省的控制条类(CControlBar的派生类)

对话框类(CDialog)在堆栈上创建的模态对话框类

所有的Windows通用对话框(除CFindReplaceDialog)

由ClassWizard创建的对话框

具有自动清除功能的窗口类,一般在堆中创建:

主框架窗口类(直接或间接从CFrameWnd类派生)

视图类(直接或间接从CView类派生)

从某种程度上来说,MFC的"服务到家"使初学者有些找不着北.不过,不得不承认:MFC干的很漂亮!

谈到这里,我们应该明白c++里一条重要的准则:用DestroyWindow清除窗口对象,不要用"delete".

对于不具备自动清除功能的窗口类使用"delete"时,"delete"先调用析构函数里的DestroyWindow,由于在析构函数中,虚机制不起作用,这里只能调用本地版本(Cwnd类)DestroyWindow函数,显然这不是我们想要的.对于有自动清除功能的窗口类,好象问题更严重一点,前面提到了重载的PostNcDestroy已经含有了"delete this",这样c++对象就被释放了两次.

很多人认为,vc++同vb一样,是一个完全可视化的产品,不用在看c++的书了.通过上面对窗口对象的清除的介绍,可以发现,Windows程序是与Windows紧密结合的,而且牵涉到很多c++的知识(如虚函数、析构函数、new操作符等).要对vc++有进一步理解,必须理解Windows机制,深入学习c++.

　　一、与加速键表有关的几个API函数和结构。

　　操作加速键表使用的几个API函数（关于这几个函数的详细说明请参考有关书籍）：
　　HACCEL LoadAccelerators(HINSTANCE hInstance, LPCTSTR lpTableNAme);
　　LoadAccelerators函数从程序的资源中加载一个加速键表，加载成功后返回一个加速健表的句柄。其中：
　　hInstance　　应用程序的实例句柄。
　　lpTableName　指向加速键表名称字符串的指针。

　　HACCEL CreateAcceleratorTable(LPACCEL lpaccl, int cEntries);
　　CreateAcceleratorTable函数根据一个ACCEL结构数组创建一个加速键表。该函数与LoadAccelerators不同的是：LoadAccelerators函数加载的加速键表在程序结束后系统会自动将该加速键表从内存中清除，但CreateAcceleratorTable函数创建的加速键表需要使用函数DestoryAceleratorTable函数进行清除。
　　lpaccl　　　一个指向ACCEL结构数组的指针。
　　cEntries　　数组中元素的个数。

　　BOOL　DestoryAcceleratorTable(HACCEL hAccel);
　　DestoryAcceleratorTable函数清除由CreateAcceleratorTable函数创建的加速键表，成功则返回TRUE。其中：
　　hAccel　　　需要清除的加速键表句柄。

　　int TranslateAccelerator(HWND hWd, HACCEL hAccTable, LPMSG lpMsg);
　　TranslateAccelerator函数负责翻译加速键。其中：
　　hWnd　　　　 窗口句柄，翻译后的消息将被发往该窗口
　　hAccTable　　加速键表句柄。
　　lpMsg　　　　指向MSG结构的指针。

　　ACCEL结构的定义：
typedef struct tagACCEL{
    BYTE    fVirt;
    WORD    key;
    WORD    cmd;
}ACCEL,*LPACCEL;

其中：
　　fVirt　　　加速键的标记。
　　key　　　　键的代码。如fVirt成员包含FVIRTKEY标志，则key指一个虚键码，否则是一个ASCII码。
　　cmd　　　　命令ID号，该参数将被放入WM＿COMMAND或WM＿SYSCOMMAND消息的wParam参数的低位字发至窗口。

　　二、在windows下如何使用加速键表。

　　在window下使用加速键表一般有两种方法：1，创建一个加速键资源，在程序中使用API函数LoadAccelerators来将加速键表加载入内存。并在消息循环中使用API函数TranslateAccelerator来翻译该加速键表。2、在程序中填充一个ACCEL数组。然后调用API函数CreateAcceleratorTable来创建加速表，翻译加速键同上，但不要忘记在退出程序前使用API函数DestoryAcceleratorTable来清除它。下面分别给出一个例子：

/*例1:使用LoadAccelerators。
　假设你已经建立了一个加速键资源，ID为IDR＿ACCEL。
　假设你已经定义了初始化函数InitApplication(HINSTANCE hInstance,int nCmdShow),
　该函数执行注册窗口类和创建窗口操作。
*/
#include <windows.h>
#include "rc/resource.h"
BOOL InitApplication(HINSTANCE hInstance,int nCmdShow);

int APIENTRY WinMain(HINSTANCE hInstance,
                     HINSTANCE hPrevInstance,
                     LPSTR     lpCmdLine,
                     int       nCmdShow)
{
     MSG msg;
     HANDLE hAccelTable;
     // 初始化应用程序，并生成主窗口.
     if (!InitApplication(hInstance, nCmdShow))
     {
         return FALSE;           // 初始化失败
     }
      //使用函数LoadAccelerators从程序资源中加载加速键表
      hAccelTable = LoadAccelerators(hInstance, MAKEINTRESOURCE(IDR_ACCEL));
      // 取得并分发消息直到接收到 WM_QUIT 消息.
     while (GetMessage(&msg, NULL, 0, 0))
     {
         //在分发消息前首先试着用加速键表进行翻译，如果是一个加速键则由
         //TranslateAccelerator函数进行翻译，不再继续处理该消息。
         if (!TranslateAccelerator(msg.hwnd, hAccelTable, &msg))
         {
             TranslateMessage(&msg);
             DispatchMessage(&msg);
         }
     }
     return msg.wParam;  // Returns the value from PostQuitMessage
}
 

/*例2:使用CreateAcceleratorTable。
　假设你已经定义了初始化函数InitApplication(HINSTANCE hInstance,int nCmdShow),
　该函数执行注册窗口类和创建窗口操作。
*/

#include <windows.h>
#include "rc/resource.h"

＃define ID_CMD_A      0x00000230
＃define ID_CMD_B      0x00000231
＃define ID_CMD_C      0x00000232
＃define ID_CMD_D      0x00000233
＃define ID_CMD_E      0x00000234
＃define ID_CMD_F      0x00000235
＃define ID_CMD_G      0x00000236

//定义了七个加速键,请在消息回调函数中处理这七个命令ID。
static ACCEL accel[]={
    {FVIRTKEY|FCONTROL,VK_F5,ID_CMD_A},
    {FVIRTKEY|FCONTROL,VK_F6,ID_CMD_B},
    {FVIRTKEY|FCONTROL,VK_HOME,ID_CMD_C},
    {FVIRTKEY|FCONTROL,VK_END,ID_CMD_D},
    {FVIRTKEY|FCONTROL,"G",ID_CMD_E},
    {FVIRTKEY|FCONTROL,VK_SPACE,ID_CMD_F},
    {FVIRTKEY|FCONTROL,"K",ID_CMD_G},
};   

BOOL InitApplication(HINSTANCE hInstance,int nCmdShow);

int APIENTRY WinMain(HINSTANCE hInstance,
                     HINSTANCE hPrevInstance,
                     LPSTR     lpCmdLine,
                     int       nCmdShow)
{
     MSG msg;
     HANDLE hAccelTable;
     // 初始化应用程序，并生成主窗口.
     if (!InitApplication(hInstance, nCmdShow))
     {
         return FALSE;           // 初始化失败
     }
      //使用函数CreateAcceleratorTable从数组accel中加载加速键表
      hAccelTable = CreateAcceleratorTable(accel, sizeof(accel)/sizeof(ACCEL));
      // 取得并分发消息直到接收到 WM_QUIT 消息.
     while (GetMessage(&msg, NULL, 0, 0))
     {
         //在分发消息前首先试着用加速键表进行翻译，如果是一个加速键则由
         //TranslateAccelerator函数进行翻译，不再继续处理该消息。
         if (!TranslateAccelerator(msg.hwnd, hAccelTable, &msg))
         {
             TranslateMessage(&msg);
             DispatchMessage(&msg);
         }
     }
     //删除加速键表
     DestoryAcceleratorTable(hAccelTable);
     return msg.wParam;  // Returns the value from PostQuitMessage
}
 

　　在MFC程序设计中，有关于加速键表的操作已经被CFrameWnd类进行了封装。通常，我们的程序的主框架类CMainFrame从CFrameWnd类派生（SDI界面程序），或者从CMDIFrameWnd类派生（MDI界面程序），而CMDIFrameWnd类也是从CFrameWnd类派生的。所以，我们并不用去关心那个资源号为IDR_MAINFRAME的加速键表是如何加载的，如果你只是需要一个这样的静态的加速键表的话。
　　那么我们能不能使用自己的加速键表呢？答案是：可以的。
　　创建加速键表的方法同前。由于在MFC中，WinMain函数被隐藏，我们不能直接修改WinMain函数，所以，加速键表的创建将在CMainFrame的OnCreate函数中创建。
　　1、在CMainFrame类中添加一个HACCEL类型保护成员变量：m_hMyAccel。在构造函数中初始化为NULL。
　　2、在CMainFrame::OnCreate函数的 “return 0;”句前增加创建加速键表的代码。返回的加速键表句柄保存在m_hMyAccel中：

　　　方法1：(IDR＿MYACCEL为你定义的加速键表资源号)
　　　m_hMyAccel=LoadAccelerators(AfxGetApp()->m_hInstance,MAKEINTRESOURCE(IDR_MYACCEL));

　　　方法2：(accel同前面的例子一样在本文件的开头部分进行定义)
　　　m_hMyAccel=CreateAcceleratorTable(accel,sizeof(accel)/sizeof(ACCEL));

　　3、如果是使用CreateAccelTable函数创建的，则重载虚拟函数DestoryWindow()。在该函数的“return CMDIFrameWnd::DestroyWindow();”前增加如下代码:

    if(m_hMyAccel!=NULL){
        DestroyAcceleratorTable(m_hMyAccel);
        m_hMyAccel=NULL;
    }

　　通过前面的三步，加速键表已经能正确地被创建和删除了，但是它还没有工作。下面就是要让我们刚才所创建的加速键表工作起来。
　　在API程序设计中大家已经知道了加速键是如何工作的。也就是在消息还没有分发出去之前先检查是不是一个加速键。我们通过API函数TranslateAccelerator来实现。在MFC中，消息机制已经被封装了，我们不能去修改消息循环。但是，框架在分发消息前会调用虚拟函数PerTranslateMessage，并且如果该函数返回TRUE，则不再处理该消息。这正是我们所需要的。
　　让我们再回到CMainFrame类，生成PerTranslateMessage函数的覆盖版本。修改函数体如下：

BOOL CMainFrame::PreTranslateMessage(MSG* pMsg)
{
    // TODO: Add your specialized code here and/or call the base class
    if(m_hMyAccel&&TranslateAccelerator(m_hWnd, m_hMyAccel, pMsg))
        return TRUE;
    return CMDIFrameWnd::PreTranslateMessage(pMsg);
}

　　好了，现在我们的加速键已经能正常地工作了。以上方法用在其它窗口同样有效（如对话框中，你不妨在对话框中试试）。

　　三、可在运行时编辑的加速键表。

　　通过上面的叙述，你可能已经对可编辑的加速键表有了一定的轮廓。其实其实现思想很简单：只要对一个ACCEL数组进行修改，然后重新生成加速键表就行了。
　　为了区分命令，我们为每个命令取一个名字。在CMainFrame类定义的前面加上下面的一个结构定义：

typedef struct{
    char cCmd[32];
    ACCEL accel;
}ACCELITEM,*LPACCELITEM;

　　我们将使用该结构来保存加速键表的数据。在CMainFrame类中添加两个保护成员变量：

    LPACCELITEM m_lpAccel;
    DWORD m_dwAccelCount;

　　在构造函数中将m_lpAccel初始化为NULL，m_dwAccelCount初始化为0。在数组accel的定义下面增加一个字符串数组的静态变量的定义（用来指定命令的名称,请仿照下面自己定义，个数多少不限，字符串长度不要超过31个字符）：

static char strCmd[][32]={
    "Command One",
    "Command Two",
    "Command Three",
    "Command Four",
    "Command Five"
};

　　在CMainFrame类中添加一个保护成员函数LoadAccel(),该函数用来将加速键表装入，定义如下：

BOOL CMainFrame::LoadAccel()
{
    ASSERT(m_hActAccel==NULL);
    ASSERT(m_lpAccel==NULL);
    m_dwAccelCount=sizeof(accel)/sizeof(ACCEL);
    m_lpAccel=new ACCELITEM[m_dwAccelCount];
    memset(m_lpAccel,0,sizeof(ACCELITEM)*m_dwAccelCount);
    DWORD dwCmdStr=sizeof(strCmd)/sizeof(char[32]);
    for(DWORD dw=0;dw<m_dwAccelCount;dw++){
        m_lpAccel[dw].accel=accel[dw];
        strcpy(m_lpAccel[dw].cCmd,dw<dwCmdStr?strCmd[dw]:"Command Unknow");
    }

    m_hActAccel=CreateAcceleratorTable(accel,m_dwAccelCount);
    return TRUE;

}

　　删除OnCreate函数中原来创建加速键表的代码，改成对LoadAccel()的调用：

    LoadAccel();

　　在CMainFrame的析构函数中增加以下内容：

    if(m_lpAccel)
        delete[] m_lpAccel;

　　为了能够对加速键数据进行编辑，我们在工程中添加一个对话框资源，ID为“IDD_ACCELEDIT”，在对话框上放置三个成组框（Group Box），左边一个标题为“命令”；中间一个标题为“组合键”；右边一个标题为“虚键值”。在左边成组框中放置一个列表框（List Box），ID为“IDC_LST_CMD”。在中间成组框中放置三个核选框（Check Box），上下排列。上面的核选框的ID为“IDC_CHK_ALT”，标题为“Alt”，并勾选“Group”属性；中间的核选框的ID为“IDC_CHK_SHIFT”，标题为“Shift”，取消“Group”属性；下面的核选框的ID为“IDC_CHK_CTRL”，标题为“Ctrl”，取消“Group”属性。在右边的成组框中放置一个列表框，ID为“IDC_LST_KEY”。调整各个控件的尺寸及位置至合适。设置控件的TAB跳转顺序，从左至右、从上到下。依次为：左成组框、IDC_LST_CMD列表框、中成组框、IDC_CHK_ALT核选框、IDC_CHK_SHIFT核选框、IDC_CHK_CTRL核选框、右成组框、IDC_LST_KEY列表框、OK按钮、CANCEL按钮。
　　打开类向导，为对话框新建一个类，类名为“CDlgEditAccel”。为两个列表框和三个核选框映射变量，如下：
　　控件ID:ID_LST_CMD；类型:Control/CListBox；名称:m_LstCmd；
　　控件ID:ID_LST_KEY；类型:Control/CListBox；名称:m_LstKey；
　　控件ID:ID_CHK_ALT；类型:Control/CButton；名称:m_ChkAlt；
　　控件ID:ID_CHK_SHIFT；类型:Control/CButton；名称:m_ChkShift；
　　控件ID:ID_CHK_CTRL；类型:Control/CButton；名称:m_ChkCtrl；

　　在类CDlgEditAccel的定义前加入下面的定义：
typedef struct tag_KeyName{
    CString m_strName;
    WORD m_wID;
    tag_KeyName(CString str,WORD id){m_strName=str,m_wID=id;}
}KEYNAME,*LPKEYNAME;

typedef struct tag_ActAccel{
    CString m_strCmd;
    ACCEL m_Accel;
}ACTACCEL,*LPACTACCEL;

class CActAccelList
{
public:
    CActAccelList();
    ~CActAccelList();

protected:
    LPACTACCEL m_lpActAccel;
    int m_iCount;

public:
    ACTACCEL& operator[](int index);
    BOOL SetSize(int iSize);
    int GetSize();
};

　　在文件DlgEditAccel.cpp文件中定义类CActAccelList的成员函数，代码如下：
CActAccelList::CActAccelList()
{
    m_lpActAccel=NULL;
   m_iCount=0;
}

CActAccelList::~CActAccelList()
{
    if(m_iCount>0&&m_lpActAccel)
        delete[] m_lpActAccel;
}

int CActAccelList::GetSize()
{
    return m_iCount;
}

ACTACCEL& CActAccelList::operator []( int index)
{
    if(!(index>=0&&index<m_iCount))
    AfxThrowMemoryException();
    return m_lpActAccel[index];
}

BOOL CActAccelList::SetSize(int iSize)
{
    if(iSize<0)
        return FALSE;
    if(m_iCount>0&&m_lpActAccel)
        delete[] m_lpActAccel;
    m_iCount=0;
    m_lpActAccel=new ACTACCEL[iSize];
    if(m_lpActAccel==NULL)
        return FALSE;
    m_iCount=iSize;
    return TRUE;
}

　　在DlgAccelEdit.cpp文件头部定义全局变量－－数组key：
static KEYNAME key[]={
    KEYNAME("Left mouse button",VK_LBUTTON),
    KEYNAME("Right mouse button",VK_RBUTTON),
    KEYNAME("Control-break processing",VK_CANCEL),
    KEYNAME("Middle mouse button",VK_MBUTTON),
    KEYNAME("Back Space",VK_BACK),
    KEYNAME("Tab",VK_TAB),
    KEYNAME("Clear",VK_CLEAR),
    KEYNAME("Enter",VK_RETURN),
    KEYNAME("Shift",VK_SHIFT),
    KEYNAME("Ctrl",VK_CONTROL),
    KEYNAME("Alt",VK_MENU),
    KEYNAME("Pause",VK_PAUSE),
    KEYNAME("Caps Lock",VK_CAPITAL),
    KEYNAME("Esc",VK_ESCAPE),
    KEYNAME("Space",VK_SPACE),
    KEYNAME("Page Up",VK_PRIOR), 
    KEYNAME("Page Down",VK_NEXT),
    KEYNAME("End",VK_END),
    KEYNAME("Home",VK_HOME),
    KEYNAME("Left",VK_LEFT),
    KEYNAME("Up",VK_UP),
    KEYNAME("Right",VK_RIGHT),
    KEYNAME("Down",VK_DOWN),
    KEYNAME("Select",VK_SELECT),
    KEYNAME("Excute",VK_EXECUTE),
    KEYNAME("Print Screen",VK_SNAPSHOT),
    KEYNAME("Insert",VK_INSERT),
    KEYNAME("Delete",VK_DELETE),
    KEYNAME("Help",VK_HELP),
    KEYNAME("0",'0'),
    KEYNAME("1",'1'),
    KEYNAME("2",'2'),
    KEYNAME("3",'3'),
    KEYNAME("4",'4'),
    KEYNAME("5",'5'),
    KEYNAME("6",'6'),
    KEYNAME("7",'7'),
    KEYNAME("8",'8'),
    KEYNAME("9",'9'),
    KEYNAME("A",'A'),
    KEYNAME("B",'B'),
    KEYNAME("C",'C'),
    KEYNAME("D",'D'),
    KEYNAME("E",'E'),
    KEYNAME("F",'F'),
    KEYNAME("G",'G'),
    KEYNAME("H",'H'),
    KEYNAME("I",'I'),
    KEYNAME("J",'J'),
    KEYNAME("K",'K'),
    KEYNAME("L",'L'),
    KEYNAME("M",'M'),
    KEYNAME("N",'N'),
    KEYNAME("O",'O'),
    KEYNAME("P",'P'),
    KEYNAME("Q",'Q'),
    KEYNAME("R",'R'),
    KEYNAME("S",'S'),
    KEYNAME("T",'T'),
    KEYNAME("U",'U'),
    KEYNAME("V",'V'),
    KEYNAME("W",'W'),
    KEYNAME("X",'X'),
    KEYNAME("Y",'Y'),
    KEYNAME("Z",'Z'),
    KEYNAME("Left windows",VK_LWIN),
    KEYNAME("Right windows",VK_RWIN),
    KEYNAME("Applications",VK_APPS),
    KEYNAME("Numeric keypad 0", VK_NUMPAD0),
    KEYNAME("Numeric keypad 1", VK_NUMPAD1),
    KEYNAME("Numeric keypad 2", VK_NUMPAD2),
    KEYNAME("Numeric keypad 3", VK_NUMPAD3),
    KEYNAME("Numeric keypad 4", VK_NUMPAD4),
    KEYNAME("Numeric keypad 5", VK_NUMPAD5),
    KEYNAME("Numeric keypad 6", VK_NUMPAD6),
    KEYNAME("Numeric keypad 7", VK_NUMPAD7),
    KEYNAME("Numeric keypad 8", VK_NUMPAD8),
    KEYNAME("Numeric keypad 9", VK_NUMPAD9),
    KEYNAME("Multiply",VK_MULTIPLY),
    KEYNAME("Add",VK_ADD),
    KEYNAME("Separator",VK_SEPARATOR),
    KEYNAME("Subtract",VK_SUBTRACT),
    KEYNAME("Decimal Point",VK_DECIMAL),
    KEYNAME("Divide",VK_DIVIDE),
    KEYNAME("F1",VK_F1),
    KEYNAME("F2",VK_F2),
    KEYNAME("F3",VK_F3),
    KEYNAME("F4",VK_F4),
    KEYNAME("F5",VK_F5),
    KEYNAME("F6",VK_F6),
    KEYNAME("F7",VK_F7),
    KEYNAME("F8",VK_F8),
    KEYNAME("F9",VK_F9),
    KEYNAME("F10",VK_F10),
    KEYNAME("F11",VK_F11),
    KEYNAME("F12",VK_F12),
    KEYNAME("F13",VK_F13),
    KEYNAME("F14",VK_F14),
    KEYNAME("F15",VK_F15),
    KEYNAME("F16",VK_F16),
    KEYNAME("F17",VK_F17),
    KEYNAME("F18",VK_F18),
    KEYNAME("F19",VK_F19),
    KEYNAME("F20",VK_F20),
    KEYNAME("F21",VK_F21),
    KEYNAME("F22",VK_F22),
    KEYNAME("F23",VK_F23),
    KEYNAME("F24",VK_F24),
    KEYNAME("Attn",VK_ATTN),
    KEYNAME("CrSel",VK_CRSEL),
    KEYNAME("ExSel",VK_EXSEL),
    KEYNAME("Erase",VK_EREOF),
    KEYNAME("Play",VK_PLAY),
    KEYNAME("Zoom",VK_ZOOM),
    KEYNAME("Reserved for future use",VK_NONAME ),
    KEYNAME("PA1",VK_PA1),
    KEYNAME("Clear(OEM)",VK_OEM_CLEAR ),

    KEYNAME("file://",'//'),
    KEYNAME("-",'-'),
    KEYNAME("=",'='),
    KEYNAME("[",'['),
    KEYNAME("]",']'),
    KEYNAME(";",';'),
    KEYNAME("\'",'\''),
    KEYNAME(",",','),
    KEYNAME(".",'.'),
    KEYNAME("/",'/'),
    KEYNAME("`",'`')
};

　　在类CDlgAccelEdit中响应Windows消息：WM_INITDIALOD，代码如下：
BOOL CDlgEditAccel::OnInitDialog()
{
    CDialog::OnInitDialog();

    // TODO: Add extra initialization here
    SetWindowText("Edit Accelerator Table");

    int iCount=m_AccelList.GetSize();
    int i;
    for(i=0;i<iCount;i++){
        m_LstCmd.AddString(m_AccelList[i].m_strCmd);
    }
    for(i=0;i<sizeof(key)/sizeof(KEYNAME);i++)
    {
        m_LstKey.AddString(key[i].m_strName);
    }
    m_LstCmd.SetCurSel(0);
    OnSelchangeLstCmd();
    return TRUE;  // return TRUE unless you set the focus to a control
                  // EXCEPTION: OCX Property Pages should return FALSE
}

　　为类CDglAccelEdit增加一个保护成员函数：
    void SaveChange(int index=-1);

　　在文件DlgAccelEdit中定义该函数，代码如下：

void CDlgEditAccel::SaveChange(int index)
{
    if(index>=0||(index=m_LstCmd.GetCurSel())>=0)
    {
        if(m_LstKey.GetCurSel()<0){
            AfxMessageBox("你必需选择一个键码!");
            return;
        }
        BYTE btCmp=((m_ChkAlt.GetCheck()==1)?FALT:NULL)|
                   ((m_ChkCtrl.GetCheck()==1)?FCONTROL:NULL)|
                   ((m_ChkShift.GetCheck()==1)?FSHIFT:NULL)|FVIRTKEY;
        WORD wKey=key[m_LstKey.GetCurSel()].m_wID;

        m_AccelList[index].m_Accel.fVirt=btCmp;
        m_AccelList[index].m_Accel.key=wKey;
        return;
    }
}

　　响应列表框ID_LST_CMD的通知消息“LBN_SELCHANGE”，函数代码如下：
void CDlgEditAccel::OnSelchangeLstCmd()
{
    // TODO: Add your control notification handler code here
    int iCmd=m_LstCmd.GetCurSel();
    WORD wKey=m_AccelList[iCmd].m_Accel.key;
    BYTE btCmp=m_AccelList[iCmd].m_Accel.fVirt;
    m_ChkAlt.SetCheck(btCmp&FALT);
    m_ChkCtrl.SetCheck(btCmp&FCONTROL);
    m_ChkShift.SetCheck(btCmp&FSHIFT);
    int iCount=sizeof(key)/sizeof(KEYNAME);
    int id=-1;
    for(int i=0;i<iCount;i++)
    {
        if(key[i].m_wID==wKey){
            id=i;
            break;
        }
    }
    m_LstKey.SetCurSel(id);

}

　　响应列表框ID_LST_KEY的通知消息“LBN_SELCHANGE”，函数代码如下：
void CDlgEditAccel::OnSelchangeLstKey()
{
    SaveChange(); 
}

　　响应核选框ID_CHK_ALT的通知消息“BN_CLICKED”，函数代码如下：
void CDlgEditAccel::OnChkAlt()
{
    SaveChange();
}

　　响应核选框ID_CHK_SHIFT的通知消息“BN_CLICKED”，函数代码如下：
void CDlgEditAccel::OnChkShift()
{
    SaveChange();
}

　　响应核选框ID_CHK_CTRL的通知消息“BN_CLICKED”，函数代码如下：
void CDlgEditAccel::OnChkCtrl()
{
    SaveChange();
}

　　至此，用于编辑加速键的对话框已经完成。我们现在要做的就是在程序中打开对话框来编辑了。让我们回到CMainFrame类中。我们将在该类中响应一个命令来打开编辑对话框，对加速键表进行编辑。完成后点按OK回到主程序中，然后更新加速键表。这样后，我们刚刚编辑好的加速键表就开始起作用了。
　　首先，打开菜单。在“查看”项后增加一个“工具(&T)”下拉菜单，在下拉菜单中增加一个了菜单：“编辑加速键表(&A)...”，ID为“ID_TOOL_ACCELEDIT”。打开类向导，选择CMainFrame类，响应“ID_TOOL_ACCELEDIT”命令。编辑响应函数如下：

void CMainFrame::OnToolAcceledit()
{
    // TODO: Add your command handler code here
    CDlgEditAccel dlg;

    DWORD i;
    dlg.m_AccelList.SetSize(m_dwAccelCount);
    for(i=0;i<m_dwAccelCount;i++){
        dlg.m_AccelList[i].m_strCmd=m_lpAccel[i].cCmd;
        dlg.m_AccelList[i].m_Accel=m_lpAccel[i].accel;
    }
    if(IDOK==dlg.DoModal()){
        ACCEL* pAccel=new ACCEL[m_dwAccelCount];
        for(DWORD dw=0;dw<m_dwAccelCount;dw++){
            m_lpAccel[dw].accel=pAccel[dw]=dlg.m_AccelList[dw].m_Accel;
        }

        if(m_hActAccel!=NULL)
        DestroyAcceleratorTable(m_hActAccel);
        m_hActAccel=CreateAcceleratorTable(pAccel,m_dwAccelCount);
    }
}

　　在该文件的头部包含类CDlgEditAccel的头文件：

#include "DlgEditAccel.h"

　　至此，可编辑的加速键表已经完成了。不妨试试看。

　　三、将加速键表保存至文件，并在程序运行时自动从文件中加载。

　　上面我们实现了可编辑的加速键表。但是，当程序退出后，我们编辑过的加速键数据就消失了，下次运行程序时还是和以前一样了。将加速键表保存起来以备下次使用，这是我们所希望的。下面讨论的方法是使用文件来保存我们的加速键表。
　　首先，在MainFrm.cpp文件的头部定义一个全局字符串，也就是用于保存加速键的文件名：

static char strAccelFileName[]="Accel.cus";

　　定义一个DWORD值作为文件头，我们通过该DWORD值来判断是否是一个有效格式的文件：

#define ACCEL_FILE_HEAD 0x00434341

　　其次，为CMainFrame类添加一个保护的成员函数：“BOOL SaveAccel()”，编辑其代码如下：
BOOL CMainFrame::SaveAccel()
{
    char lpAppName[256];
    char lpAppPath[256];
    char* lpFilePart=NULL;
    GetModuleFileName(AfxGetInstanceHandle(),lpAppName,255);
    GetFullPathName(lpAppName,255,lpAppPath,&lpFilePart);
    TRACE1("Application File Name:%s.\n",lpAppName);
    strcpy(lpFilePart,strAccelFileName);
    TRACE1("Accelerator File Name:%s.\n",lpAppPath);
    try
    {
        DWORD dwHead=ACCEL_FILE_HEAD;
        DWORD dwCount=m_dwAccelCount;

        CFile fAccel(lpAppPath,CFile::modeCreate|CFile::modeWrite);
        fAccel.SeekToBegin();
        fAccel.Write(&dwHead,sizeof(DWORD));
        fAccel.Write(&dwCount,sizeof(DWORD));
        for(DWORD dw=0;dw<dwCount;dw++)
        {
            fAccel.Write(m_lpAccel+dw,sizeof(ACCELITEM));
        }

        return TRUE;

    }

    catch(CFileException* e)
    {
        char buf[256];
        char buf2[512];
        int iError;
        iError=e->m_cause;
        e->GetErrorMessage(buf,256);
        sprintf(buf2,"将加速键表保存到文件 \"%s\" 中时发生错误!\n"
                     "错 误 号:%d\n"
                     "错误描述:%s\n"
                     "\0",
                     strAccelFileName,iError,buf);
        AfxMessageBox(buf2,MB_OK|MB_ICONSTOP|MB_DEFBUTTON1);
        return FALSE;
    }
}

　　再次，修改LoadAccel()函数如下：

BOOL CMainFrame::LoadAccel()
{
    char lpAppName[256];
    char lpAppPath[256];
    char* lpFilePart=NULL;
    GetModuleFileName(AfxGetInstanceHandle(),lpAppName,255);
    GetFullPathName(lpAppName,255,lpAppPath,&lpFilePart);
    TRACE1("Application File Name:%s.\n",lpAppName);
    strcpy(lpFilePart,strAccelFileName);
    TRACE1("Accelerator File Name:%s.\n",lpAppPath);
    try
    {
        DWORD dwHead;
        DWORD dwCount;

        CFile fAccel(lpAppPath,CFile::modeRead);
        fAccel.SeekToBegin();
        if(fAccel.Read(&dwHead,sizeof(DWORD))!=sizeof(DWORD))
            AfxThrowFileException(CFileException::endOfFile,12,lpAppPath);
        if(dwHead!=ACCEL_FILE_HEAD)
            AfxThrowFileException(CFileException::invalidFile,13,lpAppPath);

        if(fAccel.Read(&dwCount,sizeof(DWORD))!=sizeof(DWORD))
            AfxThrowFileException(CFileException::endOfFile,12,lpAppPath);
       
        ASSERT(m_lpAccel==NULL);
       
        m_lpAccel=new ACCELITEM[dwCount];
        memset(m_lpAccel,0,sizeof(ACCELITEM)*dwCount);
        m_dwAccelCount=dwCount;

        for(DWORD dw=0;dw<dwCount;dw++)
        {
            if(fAccel.Read(m_lpAccel+dw,sizeof(ACCELITEM))!=sizeof(ACCELITEM))
                AfxThrowFileException(CFileException::endOfFile,12,lpAppPath);
        }

        ACCEL* pAccel=new ACCEL[dwCount];
        for(dw=0;dw<dwCount;dw++){
            pAccel[dw]=m_lpAccel[dw].accel;
        }

        m_hActAccel=CreateAcceleratorTable(pAccel,dwCount);

        return TRUE;

    }

    catch(CFileException* e)
    {
        char buf[256];
        char buf2[512];
        int iError;
        iError=e->m_cause;
        e->GetErrorMessage(buf,256);
        sprintf(buf2,"从文件 \"%s\" 中加载加速键表时发生错误!\n"
                     "错 误 号:%d\n"
                     "错误描述:%s\n"
                     "是否生成默认的加速键表?\n\0",
                     strAccelFileName,iError,buf);
        if(IDYES==AfxMessageBox(buf2,MB_YESNO|MB_SYSTEMMODAL|MB_ICONSTOP|MB_DEFBUTTON1))
        {
            ASSERT(m_hActAccel==NULL);
            ASSERT(m_lpAccel==NULL);
            m_dwAccelCount=sizeof(accel)/sizeof(ACCEL);
            m_lpAccel=new ACCELITEM[m_dwAccelCount];
            memset(m_lpAccel,0,sizeof(ACCELITEM)*m_dwAccelCount);
            DWORD dwCmdStr=sizeof(strCmd)/sizeof(char[30]);
            for(DWORD dw=0;dw<m_dwAccelCount;dw++){
                m_lpAccel[dw].accel=accel[dw];
                strcpy(m_lpAccel[dw].cCmd,dw<dwCmdStr?strCmd[dw]:"Command Unknow");
            }
           
            m_hActAccel=CreateAcceleratorTable(accel,m_dwAccelCount);
            SaveAccel();
            return TRUE;
        }
        return FALSE;
    }
}

　　最后，在DestroyWindow()函数头部增加对SaveAccel()函数的调用：

    SaveAccel();
    ...

　　好了，你自己的加速键数据已经能保存在文件中了，并能从中正确加载。如果文件不存在或程序读取时发现错误则提醒你是否建立缺省的加速键表，如你确认的话则生成缺省的加速键表并立刻保存至文件中。
　　由于水平有限，其中难免有误，欢迎批评指正、发表你的意见。本人不胜感激。

一次偶然的情况下我发现以下代码竟然无法被编译通过（如果你的编译器，比如VC6或VC2003，允许它编译通过，我想你首先应该换个编译器，比如GCC或VC2005）：
void foo( const char* [] ) { }
int main( void )
{
    char* s[2];
    foo( s );
}
简化成更一般的形式是：
char** p1 = 0;
const char** p2 = p1;
错误是：invalid conversion from `char**' to `const char**'.

lostpencil更加仔细，使用C编译器给出的是一个警告：
initialization from incompatible pointer type.

随后hpho给出了合理的解释，同时comp.lang.c++.moderated上的Ulrich Eckhardt也用代码进行了说明。

用代码来说明最直观了：
const char* s = "abc";
int main( void )
{
    char* p0 = 0;
    char** p1 = &p0;
    const char** p2 = p1; // 先假设这一句是合法的 ( 测试时，可以先强制类型转化一下 )
    *p2 = s;
    *p0 = 'A'; // 通过p0在修改不应该被修改的s，这显然和const相违背，其运行结果不可知。
}

看了 **的 想到的
tekyDec 29, 2005 -  Show original item

看完后.明白**讲的为什么char** 不能自动转化为 const char**,(原文)但对我影响最深的是下面的话:

==================================================================
char *p="abc" 能不能编译通过要看你使用的编译器。鉴于大量遗留代码的存在，大部分编译器允许其通过，或者给个警告。当然，程序员自己必须保证绝不去修改其值。

程序员不应该在代码中出现*p='A'这样的语句。这是当初约定好了的：编译器允许char *p="abc"通过，而程序员保证不去修改它。
b. *p='A'编译时应该允许通过，因为单就这条语句而言，它完全合法。
c. 运行时*p='A'能不能通过要看实际的运行环境，包括你使用的操作系统、编译器、编译器选项 等等，一句话，其运行结果由不得你，且不应该由你去关心，因为这种行为本身已经违反约定了。
==================================================================

工作关系吧,用CString 和string用的太多了,很少这样定义字符串 char *p=“abcde“了
匝一看,还不适应,:(,渐渐的回想才想起一些来(哎,还是太生疏,赶快写下来,以后别忘了)

这样定义的字符串char *p=“abcde“ ; char *p1=“123445667“;

正如上面提到的是不能再 *p='A',运行的时候会出错,同样,strcpy(p,p1)也会出错哟,

"abcde"字符串可以看做是个常量字符串了,是不能被修改的,

但如果 char p[]=“abcde“ 这样定义,就没有问题,你可以修改*p='A',只要不越界就ok.

并且发现这样两种定义
char *p=“abcde“

char p[]=“abcde“

在运行的时候,p指向的地址也不是一样的,可见char *p=“abcde“还是有特殊的处理 :),具体怎么处理就不知道了,高手请指教:)

随着测试,又发现个问题,可能是个老问题了吧:

int main(int argc, char* argv[])
{
 int t[10];
 char p1[7]="123456";
 const char *p2="1234567890123213123";
 
 int len(0);
 
  //*p1='C';  err

 len=strlen(p1);
 printf("%d\n",len);
 
 strcpy(p1,p2);   ///??????????
 
 printf("%s\n",p1);
 
 len=strlen(p1);
 
 printf("%d\n",len);
 return 0;
}

我定义的是7个字符数组, 但用strcpy把p2拷到p1中,p1是放不下的,但程序却正常执行,warning ,err都没有,运行也正常?

输出

6
1234567890123213123
19

应该是使用内存越界了阿??怎么会正常运行呢?

难道对于内存越界的使用,运气好才崩溃表现出来,运气不好就正常运行??

posted on 2006-02-22 13:04 Vincent.Chen 阅读(232) 评论(0)  编辑  收藏 所属分类: 杂

还是来说说原理把(本人也是菜鸟啊)!
远程注入就是在目标进程中用VirtualAllocEx申请一段内存,
然后用WriteProcessMemory函数将自己dll的完整路径复制到远程进程中,
然后在Kernel32中计算LoadLibraryA的地址,再调用LoadLibraryA函数加载远程dll,
并在CreateRemoteThread创建远程进程!
Code Language : C
#include \"stdafx.h\"
#include \"windows.h\"
#include \"tlhelp32.h\"
#include \"stdio.h\"
#pragma comment(lib,\"ws2_32\")
 
int EnableDebugPriv(const char * name)//提提权函数
{
  HANDLE hToken;
  TOKEN_PRIVILEGES tp;
  LUID luid;
  //打开进程令牌环
  if(!OpenProcessToken(GetCurrentProcess(),
  TOKEN_ADJUST_PRIVILEGES|TOKEN_QUERY,
    &hToken))
  {
    MessageBox(NULL,\"OpenProcessToken Error!\",\"Error!\",MB_OK);
     return 1;
 }
 //获得进程本地唯一ID
 if(!LookupPrivilegeValue(NULL,name,&luid))
 {
   MessageBox(NULL,\"LookupPrivivlegeValue Error!\",\"Error\",MB_OK);
 }
 tp.PrivilegeCount=1;
 tp.Privileges[0].Attributes=SE_PRIVILEGE_ENABLED;
 tp.Privileges[0].Luid=luid;
 //调整权限
 if(!AdjustTokenPrivileges(hToken,0,&tp,sizeof(TOKEN_PRIVILEGES),NULL,NULL))
 {
   MessageBox(NULL,\"AdjustTokenPrivileges Error!\",\"Error\",MB_OK);
   return 1;
 }
 return 0;
}
BOOL injectit(const char *DllPath,const DWORD dwRemoteProcessld)//注入主函数
{
 HANDLE hrp;
 if(EnableDebugPriv(SE_DEBUG_NAME))
 {
   MessageBox(NULL,\"Add Privilege Error!\",\"Error\",MB_OK);
   return FALSE;
 }
 if((hrp=OpenProcess(PROCESS_CREATE_THREAD|//允许远程创建线程
   PROCESS_VM_OPERATION|//允许远程VM操作
   PROCESS_VM_WRITE,//允许远程VM写
   FALSE,dwRemoteProcessld))==NULL)
 {
   MessageBox(NULL,\"OpenProcess Error!\",\"Error\",MB_OK);
   return FALSE;
 }
 char *psLibFileRemote;
 //使用VirtualAllocEx函数在远程进程的内存地址空间分配DLL文件名缓冲
 psLibFileRemote=(char *)VirtualAllocEx(hrp,NULL,lstrlen(DllPath)+1,
   MEM_COMMIT,PAGE_READWRITE);
 if(psLibFileRemote==NULL)
 {
   MessageBox(NULL,\"VirtualAllocEx Error!\",\"Error\",MB_OK);
   return FALSE;
 }
 //使用WriteProcessMemory函数将DLL的路径名复制到远程的内存空间
 if(WriteProcessMemory(hrp,psLibFileRemote,(void *)DllPath,lstrlen(DllPath)+1,NULL)==0)
 {
   MessageBox(NULL,\"WriteProcessMemory Error!\",\"Error\",MB_OK);
   return FALSE;
 }
 //计算LoadLibraryA的入口地址
 PTHREAD_START_ROUTINE pfnStartAddr=(PTHREAD_START_ROUTINE)
   GetProcAddress(GetModuleHandle(TEXT(\"Kernel32\")),\"LoadLibraryA\");
 if(pfnStartAddr==NULL)
 {
   MessageBox(NULL,\"GetProcAddress Error!\",\"Error\",MB_OK);
   return FALSE;
 }
 //pfnStartAddr地址就是LoadLibraryA的入口地址
 
 
 HANDLE hrt;
 if((hrt=CreateRemoteThread(hrp,
   NULL,
   0,
   pfnStartAddr,
   psLibFileRemote,
   0,
   NULL))==NULL)
 {
   MessageBox(NULL,\"CreateRemote Error!\",\"Error\",MB_OK);
   return FALSE;
 }
 return TRUE;
}
unsigned long getpid(char *pn)//得到进程pid
{
 BOOL b;
 HANDLE hnd;
 PROCESSENTRY32 pe;
 //得到进程快照
 hnd=CreateToolhelp32Snapshot(TH32CS_SNAPPROCESS,0);
 pe.dwSize=sizeof(pe);
 b=Process32First(hnd,&pe);
 while(b)
 {
   if(strcmp(pn,pe.szExeFile)==0)
     return pe.th32ProcessID;
   b=Process32Next(hnd,&pe);
 }
}
 
int main(int argc, char* argv[])
{
 if(argc<2)
 {
   printf(\"++++++++++++++++++++++++++++++++++++++++++++++++++++++\n\");
   printf(\"injectpro V1.0!\nAuthor:text QQ:52674548\nusage:\n injectpro.exe targetprocess youdll\n\");
   printf(\" eg:injectpro.exe iexplorer.exe c:\\youdll.dll\n\");
   printf(\"++++++++++++++++++++++++++++++++++++++++++++++++++++++\n\");
   return 0;
 }
 EnableDebugPriv(SE_DEBUG_NAME);//自身提权
 DWORD pid=getpid(argv[1]);
 //printf(\"%d\",pid);
 if(pid==0)
   return 1;
   if(injectit(argv[2],pid))
   {
     printf(\"inject success!\");
   }
   else
   {
     printf(\"inject error!\");
   }
 return 0;
}

本篇文章来源于 黑反在线-信息安全第一站 原文链接：http://www.hf110.com/hack/hackprg/200809/203556.html

int WideCharToMultiByte (
    UINT    CodePage,                //1 Unicode编码的字符页，Unicode编码有字符页的概念，比如gb2312/936，big5/950等
    DWORD   dwFlags,                //2 如何处理复合unicode字符，详细查google
    LPCWSTR lpWideCharStr,        //3 待转换的unicode串
    int     cchWideChar,                //4 表示参数3的长度  传递-1表示以0x00结尾
    LPSTR   lpMultiByteStr,            //5 接受转换后的串的字符缓冲
    int     cbMultiByte,                    //6 表示参数5lpMutiByteStr的字节大小 通常sizeof一下
    LPCSTR  lpDefaultChar,        //7 NULL 具体google
    LPBOOL  lpUsedDefaultChar//8 NULL 具体google
);

2. 调用CRT函数wcstombs()

size_t wcstombs (
    char*          mbstr,
    const wchar_t* wcstr,
    size_t         count );

3. 使用CString构造器或赋值操作

// 假设有一个Unicode串wszSomeString

CString str1 ( wszSomeString ); // 用构造器转换
CString str2;

str2 = wszSomeString; // 用赋值操作转换

4. 使用ATL串转换宏

#include <atlconv.h>

// 还是假设有一个Unicode串wszSomeString

{
    char szANSIString [MAX_PATH];
    USES_CONVERSION; // 声明这个宏要使用的局部变量

    lstrcpy ( szANSIString, OLE2A(wszSomeString) );
}

　　那么什么是BSTR、LPSTR以及LPWSTR呢？

　　BSTR(Basic STRing，Basic字符串)是一个OLECHAR*类型的Unicode字符串。它被描述成一个与自动化相兼容的类型。由于操作系统提供相应的API函数(如SysAllocString)来管理它以及一些默认的调度代码，因此BSTR实际上就是一个COM字符串，但它却在自动化技术以外的多种场合下得到广泛使用。图1描述了BSTR的结构，其中DWORD值是字符串中实际所占用的字节数，且它的值是字符串中Unicode字符的两倍。

　　LPSTR和LPWSTR是Win32和VC++所使用的一种字符串数据类型。LPSTR被定义成是一个指向以NULL(‘\0’)结尾的8位ANSI字符数组指针，而LPWSTR是一个指向以NULL结尾的16位双字节字符数组指针。在VC++中，还有类似的字符串类型，如LPTSTR、LPCTSTR等，它们的含义如图2所示。

　　例如，LPCTSTR是指“long pointer to a constant generic string”，表示“一个指向一般字符串常量的长指针类型”，与C/C++的const char*相映射，而LPTSTR映射为 char*。

　　一般地，还有下列类型定义：

#ifdef UNICODE
typedef LPWSTR LPTSTR;
typedef LPCWSTR LPCTSTR;
#else
typedef LPSTR LPTSTR;
typedef LPCSTR LPCTSTR;
#endif

二、CString、CStringA 和 CStringW

　　Visual C++.NET中将CStringT作为ATL和MFC的共享的“一般”字符串类，它有CString、CStringA和CStringW三种形式，分别操作不同字符类型的字符串。这些字符类型是TCHAR、char和wchar_t。TCHAR在Unicode平台中等同于WCHAR(16位Unicode字符)，在ANSI中等价于char。wchar_t通常定义为unsigned short。由于CString在MFC应用程序中经常用到，这里不再重复。

三、VARIANT、COleVariant 和_variant_t

　　在OLE、ActiveX和COM中，VARIANT数据类型提供了一种非常有效的机制，由于它既包含了数据本身，也包含了数据的类型，因而它可以实现各种不同的自动化数据的传输。下面让我们来看看OAIDL.H文件中VARIANT定义的一个简化版：

struct tagVARIANT {
VARTYPE vt;
union {
short iVal; // VT_I2.
long lVal; // VT_I4.
float fltVal; // VT_R4.
double dblVal; // VT_R8.
DATE date; // VT_DATE.
BSTR bstrVal; // VT_BSTR.
…
short * piVal; // VT_BYREF|VT_I2.
long * plVal; // VT_BYREF|VT_I4.
float * pfltVal; // VT_BYREF|VT_R4.
double * pdblVal; // VT_BYREF|VT_R8.
DATE * pdate; // VT_BYREF|VT_DATE.
BSTR * pbstrVal; // VT_BYREF|VT_BSTR.
};
};

　　显然，VARIANT类型是一个C结构，它包含了一个类型成员vt、一些保留字节以及一个大的union类型。例如，如果vt为VT_I2，那么我们可以从iVal中读出VARIANT的值。同样，当给一个VARIANT变量赋值时，也要先指明其类型。例如：

VARIANT va;
:: VariantInit(&va); // 初始化
int a = 2002;
va.vt = VT_I4; // 指明long数据类型
va.lVal = a; // 赋值

　　为了方便处理VARIANT类型的变量，Windows还提供了这样一些非常有用的函数：

　　VariantInit —— 将变量初始化为VT_EMPTY；

　　VariantClear —— 消除并初始化VARIANT；

　　VariantChangeType —— 改变VARIANT的类型；

　　VariantCopy —— 释放与目标VARIANT相连的内存并复制源VARIANT。

　　COleVariant类是对VARIANT结构的封装。它的构造函数具有极为强大大的功能，当对象构造时首先调用VariantInit进行初始化，然后根据参数中的标准类型调用相应的构造函数，并使用VariantCopy进行转换赋值操作，当VARIANT对象不在有效范围时，它的析构函数就会被自动调用，由于析构函数调用了VariantClear，因而相应的内存就会被自动清除。除此之外，COleVariant的赋值操作符在与VARIANT类型转换中为我们提供极大的方便。例如下面的代码：

COleVariant v1("This is a test"); // 直接构造
COleVariant v2 = "This is a test";
// 结果是VT_BSTR类型，值为"This is a test"
COleVariant v3((long)2002);
COleVariant v4 = (long)2002;
// 结果是VT_I4类型，值为2002

　　_variant_t是一个用于COM的VARIANT类，它的功能与COleVariant相似。不过在Visual C++.NET的MFC应用程序中使用时需要在代码文件前面添加下列两句：

　　#include "comutil.h"

　　#pragma comment( lib, "comsupp.lib" )

四、CComBSTR和_bstr_t

　　CComBSTR是对BSTR数据类型封装的一个ATL类，它的操作比较方便。例如：

CComBSTR bstr1;
bstr1 = "Bye"; // 直接赋值
OLECHAR* str = OLESTR("ta ta"); // 长度为5的宽字符
CComBSTR bstr2(wcslen(str)); // 定义长度为5
wcscpy(bstr2.m_str, str); // 将宽字符串复制到BSTR中
CComBSTR bstr3(5, OLESTR("Hello World"));
CComBSTR bstr4(5, "Hello World");
CComBSTR bstr5(OLESTR("Hey there"));
CComBSTR bstr6("Hey there");
CComBSTR bstr7(bstr6);
// 构造时复制，内容为"Hey there"

　　_bstr_t是是C++对BSTR的封装，它的构造和析构函数分别调用SysAllocString和SysFreeString函数，其他操作是借用BSTR API函数。与_variant_t相似，使用时也要添加comutil.h和comsupp.lib。

五、BSTR、char*和CString转换

　　(1) char*转换成CString

　　若将char*转换成CString，除了直接赋值外，还可使用CString::Format进行。例如：

char chArray[] = "This is a test";
char * p = "This is a test";

　　或

LPSTR p = "This is a test";

　　或在已定义Unicode应的用程序中

TCHAR * p = _T("This is a test");

　　或

LPTSTR p = _T("This is a test");
CString theString = chArray;
theString.Format(_T("%s"), chArray);
theString = p;

　　(2) CString转换成char*

　　若将CString类转换成char*(LPSTR)类型，常常使用下列三种方法：

　　方法一，使用强制转换。例如：

CString theString( "This is a test" );
LPTSTR lpsz =(LPTSTR)(LPCTSTR)theString;

　　方法二，使用strcpy。例如：

CString theString( "This is a test" );
LPTSTR lpsz = new TCHAR[theString.GetLength()+1];
_tcscpy(lpsz, theString);

　　需要说明的是，strcpy(或可移值Unicode/MBCS的_tcscpy)的第二个参数是 const wchar_t* (Unicode)或const char* (ANSI)，系统编译器将会自动对其进行转换。

　　方法三，使用CString::GetBuffer。例如：

CString s(_T("This is a test "));
LPTSTR p = s.GetBuffer();
// 在这里添加使用p的代码
if(p != NULL) *p = _T('\0');
s.ReleaseBuffer();
// 使用完后及时释放，以便能使用其它的CString成员函数

　　(3) BSTR转换成char*

　　方法一，使用ConvertBSTRToString。例如：

#include "comutil.h"
#pragma comment(lib, "comsupp.lib")
int _tmain(int argc, _TCHAR* argv[]){
BSTR bstrText = ::SysAllocString(L"Test");
char* lpszText2 = _com_util::ConvertBSTRToString(bstrText);
SysFreeString(bstrText); // 用完释放
delete[] lpszText2;
return 0;
}

   ** 此方法不好，会造成内存泄露，SysFreeString也没有效果。

　　方法二，使用_bstr_t的赋值运算符重载。例如：

_bstr_t b = bstrText;
char* lpszText2 = b;   

* 不会有内存泄露，推荐方法

　　(4) char*转换成BSTR

　　方法一，使用SysAllocString等API函数。例如：

BSTR bstrText = ::SysAllocString(L"Test");
BSTR bstrText = ::SysAllocStringLen(L"Test",4);
BSTR bstrText = ::SysAllocStringByteLen("Test",4);

　　方法二，使用COleVariant或_variant_t。例如：

//COleVariant strVar("This is a test");
_variant_t strVar("This is a test");
BSTR bstrText = strVar.bstrVal;

　　方法三，使用_bstr_t，这是一种最简单的方法。例如：

BSTR bstrText = _bstr_t("This is a test");

　　方法四，使用CComBSTR。例如：

BSTR bstrText = CComBSTR("This is a test");

　　或

CComBSTR bstr("This is a test");
BSTR bstrText = bstr.m_str;

　　方法五，使用ConvertStringToBSTR。例如：

char* lpszText = "Test";
BSTR bstrText = _com_util::ConvertStringToBSTR(lpszText);

　　(5) CString转换成BSTR

　　通常是通过使用CStringT::AllocSysString来实现。例如：

CString str("This is a test");
BSTR bstrText = str.AllocSysString();
…
SysFreeString(bstrText); // 用完释放

　　(6) BSTR转换成CString

　　一般可按下列方法进行：

BSTR bstrText = ::SysAllocString(L"Test");
CStringA str;
str.Empty();
str = bstrText;

　　或

CStringA str(bstrText);

　　(7) ANSI、Unicode和宽字符之间的转换

　　方法一，使用MultiByteToWideChar将ANSI字符转换成Unicode字符，使用WideCharToMultiByte将Unicode字符转换成ANSI字符。

　　方法二，使用“_T”将ANSI转换成“一般”类型字符串，使用“L”将ANSI转换成Unicode，而在托管C++环境中还可使用S将ANSI字符串转换成String*对象。例如：

TCHAR tstr[] = _T("this is a test");
wchar_t wszStr[] = L"This is a test";
String* str = S”This is a test”;

　　方法三，使用ATL 7.0的转换宏和类。ATL7.0在原有3.0基础上完善和增加了许多字符串转换宏以及提供相应的类，它具有如图3所示的统一形式：

　　其中，第一个C表示“类”，以便于ATL 3.0宏相区别，第二个C表示常量，2表示“to”，EX表示要开辟一定大小的缓冲。SourceType和DestinationType可以是A、T、W和OLE，其含义分别是ANSI、Unicode、“一般”类型和OLE字符串。例如，CA2CT就是将ANSI转换成一般类型的字符串常量。下面是一些示例代码：

LPTSTR tstr= CA2TEX<16>("this is a test");
LPCTSTR tcstr= CA2CT("this is a test");
wchar_t wszStr[] = L"This is a test";
char* chstr = CW2A(wszStr);