2 消息类型

1) 系统定义消息(System-Defined Messages)

在SDK中事先定义好的消息，非用户定义的，其范围在[0x0000, 0x03ff]之间， 可以分为以下三类：

1>窗口消息(Windows Message)

与窗口的内部运作有关，如创建窗口，绘制窗口，销毁窗口等。可以是一般的窗口，也可以是Dialog,控件等。

如：WM_CREATE, WM_PAINT, WM_MOUSEMOVE, WM_CTLCOLOR, WM_HSCROLL...

2>命令消息(Command Message)

与处理用户请求有关， 如单击菜单项或工具栏或控件时， 就会产生命令消息。

WM_COMMAND, LOWORD(wParam)表示菜单项，工具栏按钮或控件的ID。如果是控件, HIWORD(wParam)表示控件消息类型

3> 控件通知(Notify Message)

控件通知消息， 这是最灵活的消息格式， 其Message, wParam, lParam分别为：WM_NOTIFY, 控件ID，指向NMHDR的指针。NMHDR包含控件通知的内容， 可以任意扩展。

2) 程序定义消息(Application-Defined Messages)

用户自定义的消息， 对于其范围有如下规定：

WM_USER: 0x0400-0x7FFF    (ex. WM_USER+10)

WM_APP(winver>4.0): 0x8000-0xBFFF (ex.WM_APP+4)

RegisterWindowMessage: 0xC000-0xFFFF

3 消息队列(Message Queues)

Windows中有两种类型的消息队列

1) 系统消息队列(System Message Queue)

这是一个系统唯一的Queue，设备驱动(mouse, keyboard)会把操作输入转化成消息存在系统队列中，然后系统会把此消息放到目标窗口所在的线程的消息队列(thread-specific message queue)中等待处理

2) 线程消息队列(Thread-specific Message Queue)

每一个GUI线程都会维护这样一个线程消息队列。(这个队列只有在线程调用GDI函数时才会创建，默认不创建)。然后线程消息队列中的消息会被送到相应的窗口过程(WndProc)处理.

注意： 线程消息队列中WM_PAINT，WM_TIMER只有在Queue中没有其他消息的时候才会被处理，WM_PAINT消息还会被合并以提高效率。其他所有消息以先进先出（FIFO）的方式被处理。

4 队列消息(Queued Messages)和非队列消息(Non-Queued Messages)

1)队列消息(Queued Messages)

消息会先保存在消息队列中，消息循环会从此队列中取消息并分发到各窗口处理

如鼠标，键盘消息。

2) 非队列消息(NonQueued Messages)

消息会绕过系统消息队列和线程消息队列直接发送到窗口过程被处理

如： WM_ACTIVATE, WM_SETFOCUS, WM_SETCURSOR， WM_WINDOWPOSCHANGED

注意: postMessage发送的消息是队列消息，它会把消息Post到消息队列中； SendMessage发送的消息是非队列消息， 被直接送到窗口过程处理

5 PostMessage(PostThreadMessage), SendMessage

PostMessage:把消息放到指定窗口所在的线程消息队列中后立即返回。 PostThreadMessage：把消息放到指定线程的消息队列中后立即返回。

SendMessage：直接把消息送到窗口过程处理， 处理完了才返回。

6 GetMessage, PeekMessage

PeekMessage会立即返回  可以保留消息

GetMessage在有消息时返回 会删除消息

7 TranslateMessage, TranslateAccelerator

TranslateMessage: 把一个virtual-key消息转化成字符消息(character message)，并放到当前线程的消息队列中，消息循环下一次取出处理。

TranslateAccelerator: 将快捷键对应到相应的菜单命令。它会把WM_KEYDOWN 或 WM_SYSKEYDOWN转化成快捷键表中相应的WM_COMMAND 或WM_SYSCOMMAND消息， 然后把转化后的 WM_COMMAND或WM_SYSCOMMAND直接发送到窗口过程处理， 处理完后才会返回。

8(消息死锁( Message Deadlocks)

假设有线程A和B， 现在有以下下步骤

1) 线程A SendMessage给线程B, A等待消息在线程B中处理后返回

2) 线程B收到了线程A发来的消息，并进行处理， 在处理过程中，B也向线程A SendMessgae，然后等待从A返回。

因为此时， 线程A正等待从线程B返回， 无法处理B发来的消息， 从而导致了线程A,B相互等待， 形成死锁。多个线程也可以形成环形死锁。

可以使用 SendNotifyMessage或SendMessageTimeout来避免出现死锁。

9 BroadcastSystemMessage

我们一般所接触到的消息都是发送给窗口的， 其实， 消息的接收者可以是多种多样的，它可以是应用程序(applications), 可安装驱动(installable drivers), 网络设备(network drivers), 系统级设备驱动(system-level device drivers)等，

BroadcastSystemMessage这个API可以对以上系统组件发送消息

这种方法的优点是使人能够通过变量的名字来辨别变量的类型,而不比去查找它的定义.遗憾的是,这种方法不仅使变量名字非常绕口,而且使改变变量类型的工作变得十分艰巨.在Windows3.1中,整型变量为16为宽.如果我们在开始时采用了一个整型变量,但是在通过30---40个函数的计算之后,发现采用整型变量宽度不够,这时我们不仅要改变这个变量的类型,而且要改变这个变量在这30--40个函数中的名字.

因为不切实际,除了一些顽固的Windows程序员外已经没有人再使用"匈牙利表示法"了.毫无疑问,在某种场合它依然存在,但大部分人现在已经抛弃它了.一般而言,输入前缀是一种糟糕的想法,因为它把变量于其类型紧紧地绑在了一起.

对于30行以下的函数，匈牙利方法一般有优势。

尤其是对界面编程，有优势。

但对于有强烈的算法要求、尤其是有很多抽象类型的C++程序，匈牙利方法简直是一个灾难。

看你用在什么地方。

现在有了很好的IDE工具,如:VC,SourceInsight等.

选中变量,会自动提示告诉你它的声明和定义,这样

匈牙利命名法就没有很大的必要了.

无非就是为了程序可读性较好.

实际上良好的代码书写习惯比强制使用匈牙利命名法更重要.

系统性。整体性。可读性。分类要清楚。要有注释！

匈牙利命名法是微软推广的一种关于变量、函数、对象、前缀、宏定义等各种类型的符号的命名规范。匈牙利命名法的主要思想是：在变量和函数名中加入前缀以增进人们对程序的理解。它是由微软内部的一个匈牙利人发起使用的，结果它在微软内部逐渐流行起来，并且推广给了全世界的Windows开发人员。下面将介绍匈牙利命名法，后面的例子里也会尽量遵守它和上面的代码风格。还是那句话，并不是要求所有的读者都要去遵守，但是希望读者作为一个现代的软件开发人员都去遵守它。

a       Array                                 数组

  b       BOOL (int)                            布尔(整数)

  by      Unsigned Char (Byte)                  无符号字符(字节)

  c       Char                                  字符(字节)

  cb      Count of bytes                        字节数

  cr      Color reference value                 颜色(参考)值

  cx      Count of x (Short)                    x的集合(短整数)

  dw      DWORD   (unsigned long)                 双字(无符号长整数)

  f       Flags   (usually multiple bit values)   标志(一般是有多位的数值)

  fn      Function                              函数

  g_      global                                全局的

  h       Handle                                句柄

  i       Integer                               整数

  l       Long                                  长整数

  lp      Long pointer                          长指针

  m_      Data member of a class                一个类的数据成员

  n       Short int                             短整数

  p       Pointer                               指针

  s       String                                字符串

  sz      Zero terminated String                以0结尾的字符串

  tm      Text metric                           文本规则

  u       Unsigned int                          无符号整数

  ul      Unsigned long (ULONG)                 无符号长整数

  w       WORD (unsigned short)                 无符号短整数

  x,y     x, y coordinates (short)              坐标值/短整数

  v       void                                  空

有关项目的全局变量用g_开始，类成员变量用m_，局部变量若函数较大则可考虑用l_用以显示说明其是局部变量。

前缀       类型       例子

g_    全局变量       g_Servers

C     类或者结构体       CDocument，CPrintInfo

m_   成员变量       m_pDoc，m_nCustomers

VC常用前缀列表：

前缀       类型       描述       例子

ch    char 8位字符    chGrade

ch    TCHAR       16位UNICODE类型字符       chName

b     BOOL       布尔变量       bEnabled

n     int    整型（其大小由操作系统决定）       nLength

n     UINT       无符号整型（其大小由操作系统决定）       nLength

w    WORD       16位无符号整型    wPos

l      LONG       32位有符号整型    lOffset

dw   DWORD       32位无符号整型       dwRange

p     *       Ambient memory model pointer 内存模块指针，指针变量    pDoc

lp     FAR*       长指针       lpDoc

lpsz  LPSTR       32位字符串指针       lpszName

lpsz  LPCSTR       32位常量字符串指针       lpszName

lpsz  LPCTSTR       32位UNICODE类型常量指针       lpszName

h     handle       Windows对象句柄       hWnd

lpfn  (*fn)()       回调函数指针 Callback Far pointer to CALLBACK function       lpfnAbort

Windows对象名称缩写：

Windows对象       例子变量       MFC类       例子对象

HWND    hWnd;       CWnd*       pWnd;

HDLG     hDlg;       CDialog*       pDlg;

HDC       hDC;       CDC*       pDC;

HGDIOBJ       hGdiObj;       CGdiObject*     pGdiObj;

HPEN     hPen;       CPen*       pPen;

HBRUSH hBrush;       CBrush*       pBrush;

HFONT   hFont;       CFont*       pFont;

HBITMAP       hBitmap;       CBitmap*       pBitmap;

HPALETTE       hPalette;       CPalette*       pPalette;

HRGN     hRgn;       CRgn*       pRgn;

HMENU hMenu;       CMenu*       pMenu;

HWND    hCtl;       CStatic*       pStatic;

HWND    hCtl;       CButton*       pBtn;

HWND    hCtl;       CEdit*       pEdit;

HWND    hCtl;       CListBox*       pListBox;

HWND    hCtl;       CComboBox*       pComboBox;

2、解决办法：
　　在图形图象处理编程过程中,双缓冲是一种基本的技术。我们知道,如果窗体在响应WM_PAINT消息的时候要进行复杂的图形处理，那么窗体在重绘时由于过频的刷新而引起闪烁现象。解决这一问题的有效方法就是双缓冲技术。

　　因为窗体在刷新时，总要有一个擦除原来图象的过程OnEraseBkgnd，它利用背景色填充窗体绘图区，然后在调用新的绘图代码进行重绘，这样一擦一写造成了图象颜色的反差。当WM_PAINT的响应很频繁的时候，这种反差也就越发明显。于是我们就看到了闪烁现象。

　　我们会很自然的想到，避免背景色的填充是最直接的办法。但是那样的话，窗体上会变的一团糟。因为每次绘制图象的时候都没有将原来的图象清除，造成了图象的残留，于是窗体重绘时，画面往往会变的乱七八糟。所以单纯的禁止背景重绘是不够的。我们还要进行重新绘图，但要求速度很快，于是我们想到了使用BitBlt函数。它可以支持图形块的复制，速度很快。我们可以先在内存中作图，然后用此函数将做好的图复制到前台，同时禁止背景刷新，这样就消除了闪烁。以上也就是双缓冲绘图的基本的思路。

３、具体步骤：
　　假设我们建立了一个Draw的工程，我们要在DrawView中进行绘图操作。

　　在双缓冲方法中，首先要做的是屏蔽背景刷新。背景刷新其实是在响应WM_ERASEBKGND消息。我们在视类（CDrawView）中添加对这个消息的响应，可以看到缺省的代码如下：

　BOOL CDrawView::OnEraseBkgnd(CDC* pDC)
　{
     　 //return CDrawView::OnEraseBkgnd(pDC);
　　return TRUE;
　}

接下来是双缓冲的实现步骤：

（1）增加成员变量（在DrawView.h文件中）

　//参数声明
　　CBitmap* m_pOldBitmap;
　　 CBitmap* m_pMemBitmap; //声明内存中承载临时图象的位图
　　CDC* m_pMemDC;   //声明用于缓冲作图的内存DC

（2）初始化变量（在DrawView的构造函数中）

　　m_pMemDC=new CDC();
　　m_pMemBitmap=new CBitmap();

（3）增加消息响应函数WM_CREATE（在DrawView.cpp中）

　int CDrawView::OnCreate(LPCREATESTRUCT lpCreateStruct)
　{
　　 if (CView::OnCreate(lpCreateStruct) == -1)
　　　 return -1;

　　 int x=GetSystemMetrics(SM_CXSCREEN);
　　 int y=GetSystemMetrics(SM_CYSCREEN);

　　CDC* pDC=GetDC();
　　m_pMemDC->CreateCompatibleDC(pDC); //依附窗口DC创建兼容内存DC
　　m_pMemBitmap->CreateCompatibleBitmap(pDC,x,y); //创建兼容位图
　 　m_pOldBitmap=m_pMemDC->SelectObject(m_pMemBitmap); //将位图选进内存DC,原位图保存到m_pOldBitmap

　　 CBrush brush(RGB(255,255,255));
　　m_pMemDC->FillRect(CRect(0,0,x,y),&brush);    //设置客户区背景为白色

　　ReleaseDC(pDC);

　　return 0;
　}
（4）修改OnDraw()函数(DrawView.cpp中)

　　void CDrawView::OnDraw(CDC* pDC)
　　{
　　　CDocument* pDoc = GetDocument();
　　　CRect rc;
　　　GetClientRect(&rc);
　　　DrawSomething();   //在这个函数里你可以画你想画的东西
　　　pDC->BitBlt(0,0,rc.Width(),rc.Height(),m_pMemDC,0,0,SRCCOPY);
　　　　//这里就是将内存里面的画布复制到显示设备的buffer了
　　}

（5）自己的绘图函数(DrawView.cpp中)

　　void DrawSomething()
　　{
    　　m_pMemDC->Rectangle(0,0,100,100);        //此处画了个矩形
    　　 Invalidate();
　　}

（6）delete掉new的东西（在DrawView的析构函数中）

　　delete m_pBitmap;
    　delete m_pMemDC;

　　我们会很自然的想到，避免背景色的填充是最直接的办法。但是那样的话，窗体上会变的一团糟。因为每次绘制图象的时候都没有将原来的图象清除，造成了图象的残留，于是窗体重绘时，画面往往会变的乱七八糟。所以单纯的禁止背景重绘是不够的。我们还要进行重新绘图，但要求速度很快，于是我们想到了使用BitBlt函数。它可以支持图形块的复制，速度很快。我们可以先在内存中作图，然后用此函数将做好的图复制到前台，同时禁止背景刷新，这样就消除了闪烁。以上也就是双缓冲绘图的基本的思路。

　　先按普通做图的方法进行编程。即在视类的OnDraw函数中添加绘图代码。在此我们绘制若干同心圆，代码如下：
 CBCDoc* pDoc = GetDocument();
 ASSERT_VALID(pDoc);
 CPoint ptCenter;
 CRect rect,ellipseRect;
 GetClientRect(&rect);
 ptCenter = rect.CenterPoint();
 for(int i=20;i>0;i--)
 {
      ellipseRect.SetRect(ptCenter,ptCenter);
      ellipseRect.InflateRect(i*10,i*10);
      pDC->Ellipse(ellipseRect);
 }

编译运行程序，尝试改变窗口大小，可以发现闪烁现象。

　　在双缓冲方法中，首先要做的是屏蔽背景刷新。背景刷新其实是在响应WM_ERASEBKGND消息。我们在视类中添加对这个消息的响应，可以看到缺省的代码如下：

BOOL CMYView::OnEraseBkgnd(CDC* pDC) 
{
     return CView::OnEraseBkgnd(pDC);
}

是调用父类的OnEraseBkgnd函数，我们屏蔽此调用，只须直接return TRUE;即可。

　　下面是内存缓冲作图的步骤。

 CPoint ptCenter;
 CRect rect,ellipseRect;
 GetClientRect(&rect);
 ptCenter = rect.CenterPoint();
 CDC dcMem;                                                 //用于缓冲作图的内存DC
 CBitmap bmp;                                                //内存中承载临时图象的位图
 dcMem.CreateCompatibleDC(pDC);              //依附窗口DC创建兼容内存DC
 bmp.CreateCompatibleBitmap(&dcMem,rect.Width(),rect.Height());//创建兼容位图
 dcMem.SelectObject(&bmp);                         //将位图选择进内存DC
 dcMem.FillSolidRect(rect,pDC->GetBkColor());//按原来背景填充客户区，不然会是黑色
 for(int i=20;i>0;i--)                                         //在内存DC上做同样的同心圆图象
 {
      ellipseRect.SetRect(ptCenter,ptCenter);
      ellipseRect.InflateRect(i*10,i*10);
      dcMem.Ellipse(ellipseRect);
 }
 pDC->BitBlt(0,0,rect.Width(),rect.Height(),&dcMem,0,0,SRCCOPY);//将内存DC上的图象拷贝到前台
 dcMem.DeleteDC();                                      //删除DC
 bm.DeleteObject();                                       //删除位图

由于复杂的画图操作转入后台，我们看到的是速度很快的复制操作，自然也就消除了闪烁现象。

对于可以接收数据的控件，如编辑控件来说，UpdateData()函数至关重要。当控件内容发生变化时，对应的控件变量的值并没有跟着变化，同

样，当控件变量值变化时，控件内容也不会跟着变。
UpdateData()函数就是解决这个问题的。

UpdateData(true);把控件内容装入控件变量
UpdateData(false);用控件变量的值更新控件

如：有编辑控件IDC_EDIT1，对应的变量为字符串m_Edit1，
1、修改变量值并显示在控件中：
m_Edit1 = _T("结果为50");
UpdateData(false);
2、读取控件的值到变量中：
用ClassWizard为IDC_EDIT1添加EN_CHANGE消息处理函数，
void CEditView::OnChangeEdit1()
{
    UpdateData(true);
}

UINT_PTR SetTimer(
HWND hWnd,              // 窗口句柄
UINT_PTR nIDEvent,      // 定时器ID，多个定时器时，可以通过该ID判断是哪个定时器
UINT uElapse,           // 时间间隔,单位为毫秒
TIMERPROC lpTimerFunc   // 回调函数
);

SetTimer(m_hWnd,1,1000,NULL); //一个1秒触发一次的定时器

UINT SetTimer(1,100,NULL); 

void CALLBACK TimerProc(HWND hWnd,UINT nMsg,UINT nTimerid,DWORD dwTime);

void CTimerTestDlg::OnTimer(UINT nIDEvent)
{
switch (nIDEvent)
{
case 24:  ///处理ID为24的定时器
Draw1();
break;
case 25:  ///处理ID为25的定时器
Draw2();
break;
}
CDialog::OnTimer(nIDEvent);
}

void CALLBACK TimerProc(HWND hWnd,UINT nMsg,UINT nTimerid,DWORD dwTime)
{
switch(nTimerid)
{
case 1:  ///处理ID为1的定时器
Do1();
break;
case 2:  ///处理ID为2的定时器
Do2();
break;
}
}

BOOL KillTimer(
HWND hWnd,          // 窗口句柄
UINT_PTR uIDEvent   // ID
);

为了方便理解，先考虑一维情况下的线性插值
对于一个数列c，我们假设c[a]到c[a+1]之间是线性变化的
那么对于浮点数x(a<=x<a+1)，c(x)=c[a+1]*(x-a)+c[a]*(1+a-x);
这个好理解吧？

把这种插值方式扩展到二维情况
对于一个二维数组c，我们假设对于任意一个浮点数i,c(a,i)到c(a+1,i)之间是线性变化的,c(i,b)到c(i,b+1)之间也是线性变化的(a,b都是整数)
那么对于浮点数的坐标(x,y)满足(a<=x<a+1,b<=y<b+1)，我们可以先分别求出c(x,b)和c(x,b+1):
c(x,b) = c[a+1]*(x-a)+c[a]*(1+a-x);
c(x,b+1) = c[a+1][b+1]*(x-a)+c[a][b+1]*(1+a-x);
好，现在已经知道c(x,b)和c(x,b+1)了，而根据假设c(x,b)到c(x,b+1)也是线性变化的，所以:
c(x,y) = c(x,b+1)*(y-b)+c(x,b)*(1+b-y)
这就是双线性插值，

int i = 100;
long l = 2001;
float f=300.2;
double d=12345.119;
char username[]="程佩君";
char temp[200];
char *buf;
CString str;
_variant_t v1;
_bstr_t v2;

一、其它数据类型转换为字符串

• 短整型(int)
  itoa(i,temp,10);///将i转换为字符串放入temp中,最后一个数字表示十进制
  itoa(i,temp,2); ///按二进制方式转换
• 长整型(long)
  ltoa(l,temp,10);
• 浮点数(float,double)
  用fcvt可以完成转换,这是MSDN中的例子:
  int decimal, sign;
  char *buffer;
  double source = 3.1415926535;
  buffer = _fcvt( source, 7, &decimal, &sign );
  运行结果:source: 3.1415926535 buffer: '31415927' decimal: 1 sign: 0
  decimal表示小数点的位置,sign表示符号:0为正数，1为负数
• CString变量
  str = "2008北京奥运";
  buf = (LPSTR)(LPCTSTR)str;
• BSTR变量
  BSTR bstrValue = ::SysAllocString(L"程序员");
  char * buf = _com_util::ConvertBSTRToString(bstrValue);
  SysFreeString(bstrValue);
  AfxMessageBox(buf);
  delete(buf);
• CComBSTR变量
  CComBSTR bstrVar("test");
  char *buf = _com_util::ConvertBSTRToString(bstrVar.m_str);
  AfxMessageBox(buf);
  delete(buf);
  
• _bstr_t变量
  _bstr_t类型是对BSTR的封装，因为已经重载了=操作符，所以很容易使用
  _bstr_t bstrVar("test");
  const char *buf = bstrVar;///不要修改buf中的内容
  AfxMessageBox(buf);
  
  
• 通用方法(针对非COM数据类型)
  用sprintf完成转换
  

  char  buffer[200];
      char  c = '1';
      int   i = 35;
      long  j = 1000;
      float f = 1.7320534f;
      sprintf( buffer, "%c",c);
      sprintf( buffer, "%d",i);
      sprintf( buffer, "%d",j);
      sprintf( buffer, "%f",f);
      

二、字符串转换为其它数据类型
strcpy(temp,"123");

• 短整型(int)
  i = atoi(temp);
• 长整型(long)
  l = atol(temp);
• 浮点(double)
  d = atof(temp);
• CString变量
  CString name = temp;
• BSTR变量
  BSTR bstrValue = ::SysAllocString(L"程序员");
  ...///完成对bstrValue的使用
  SysFreeString(bstrValue);
  
• CComBSTR变量
  CComBSTR类型变量可以直接赋值
  CComBSTR bstrVar1("test");
  CComBSTR bstrVar2(temp);
  
• _bstr_t变量
  _bstr_t类型的变量可以直接赋值
  _bstr_t bstrVar1("test");
  _bstr_t bstrVar2(temp);
  
  

三、其它数据类型转换到CString
使用CString的成员函数Format来转换,例如:

• 整数(int)
  str.Format("%d",i);
• 浮点数(float)
  str.Format("%f",i);
• 字符串指针(char *)等已经被CString构造函数支持的数据类型可以直接赋值
  str = username;
• 对于Format所不支持的数据类型，可以通过上面所说的关于其它数据类型转化到char *的方法先转到char *，然后赋值给CString变量。
  

四、BSTR、_bstr_t与CComBSTR

• CComBSTR 是ATL对BSTR的封装，_bstr_t是C++对BSTR的封装,BSTR是32位指针,但并不直接指向字串的缓冲区。
  char *转换到BSTR可以这样:
  BSTR b=_com_util::ConvertStringToBSTR("数据");///使用前需要加上comutil.h和comsupp.lib
  SysFreeString(bstrValue);
  反之可以使用
  char *p=_com_util::ConvertBSTRToString(b);
  delete p;
  具体可以参考一，二段落里的具体说明。
  
  CComBSTR与_bstr_t对大量的操作符进行了重载，可以直接进行=,!=,==等操作，所以使用非常方便。
  特别是_bstr_t,建议大家使用它。
  

五、VARIANT 、_variant_t 与 COleVariant

• VARIANT的结构可以参考头文件VC98\Include\OAIDL.H中关于结构体tagVARIANT的定义。
  对于VARIANT变量的赋值：首先给vt成员赋值，指明数据类型，再对联合结构中相同数据类型的变量赋值，举个例子：
  VARIANT va;
  int a=2001;
  va.vt=VT_I4;///指明整型数据
  va.lVal=a; ///赋值
  
  对于不马上赋值的VARIANT，最好先用Void VariantInit(VARIANTARG FAR* pvarg);进行初始化,其本质是将vt设置为VT_EMPTY,下表我们列举vt与常用数据的对应关系:
  
  

  Byte bVal;	// VT_UI1.
  Short iVal;	// VT_I2.
  long lVal;	// VT_I4.
  float fltVal;	// VT_R4.
  double dblVal;	// VT_R8.
  VARIANT_BOOL boolVal;	// VT_BOOL.
  SCODE scode;	// VT_ERROR.
  CY cyVal;	// VT_CY.
  DATE date;	// VT_DATE.
  BSTR bstrVal;	// VT_BSTR.
  DECIMAL FAR* pdecVal	// VT_BYREF|VT_DECIMAL.
  IUnknown FAR* punkVal;	// VT_UNKNOWN.
  IDispatch FAR* pdispVal;	// VT_DISPATCH.
  SAFEARRAY FAR* parray;	// VT_ARRAY|*.
  Byte FAR* pbVal;	// VT_BYREF|VT_UI1.
  short FAR* piVal;	// VT_BYREF|VT_I2.
  long FAR* plVal;	// VT_BYREF|VT_I4.
  float FAR* pfltVal;	// VT_BYREF|VT_R4.
  double FAR* pdblVal;	// VT_BYREF|VT_R8.
  VARIANT_BOOL FAR* pboolVal;	// VT_BYREF|VT_BOOL.
  SCODE FAR* pscode;	// VT_BYREF|VT_ERROR.
  CY FAR* pcyVal;	// VT_BYREF|VT_CY.
  DATE FAR* pdate;	// VT_BYREF|VT_DATE.
  BSTR FAR* pbstrVal;	// VT_BYREF|VT_BSTR.
  IUnknown FAR* FAR* ppunkVal;	// VT_BYREF|VT_UNKNOWN.
  IDispatch FAR* FAR* ppdispVal;	// VT_BYREF|VT_DISPATCH.
  SAFEARRAY FAR* FAR* pparray;	// VT_ARRAY|*.
  VARIANT FAR* pvarVal;	// VT_BYREF|VT_VARIANT.
  void FAR* byref;	// Generic ByRef.
  char cVal;	// VT_I1.
  unsigned short uiVal;	// VT_UI2.
  unsigned long ulVal;	// VT_UI4.
  int intVal;	// VT_INT.
  unsigned int uintVal;	// VT_UINT.
  char FAR * pcVal;	// VT_BYREF|VT_I1.
  unsigned short FAR * puiVal;	// VT_BYREF|VT_UI2.
  unsigned long FAR * pulVal;	// VT_BYREF|VT_UI4.
  int FAR * pintVal;	// VT_BYREF|VT_INT.
  unsigned int FAR * puintVal;	//VT_BYREF|VT_UINT.

  
  
• _variant_t是VARIANT的封装类，其赋值可以使用强制类型转换，其构造函数会自动处理这些数据类型。
  使用时需加上#include <comdef.h>
  例如：
  long l=222;
  ing i=100;
  _variant_t lVal(l);
  lVal = (long)i;
  
  
• COleVariant的使用与_variant_t的方法基本一样，请参考如下例子：
  COleVariant v3 = "字符串", v4 = (long)1999;
  CString str =(BSTR)v3.pbstrVal;
  long i = v4.lVal;
  
  

六、其它一些COM数据类型

• 根据ProgID得到CLSID
  HRESULT CLSIDFromProgID( LPCOLESTR lpszProgID,LPCLSID pclsid);
  CLSID clsid;
  CLSIDFromProgID( L"MAPI.Folder",&clsid);
  
• 根据CLSID得到ProgID
  WINOLEAPI ProgIDFromCLSID( REFCLSID clsid,LPOLESTR * lplpszProgID);
  例如我们已经定义了 CLSID_IApplication,下面的代码得到ProgID
  LPOLESTR pProgID = 0;
  ProgIDFromCLSID( CLSID_IApplication,&pProgID);
  ...///可以使用pProgID
  CoTaskMemFree(pProgID);//不要忘记释放
  

七、ANSI与Unicode
Unicode称为宽字符型字串,COM里使用的都是Unicode字符串。

• 将ANSI转换到Unicode
  (1)通过L这个宏来实现，例如: CLSIDFromProgID( L"MAPI.Folder",&clsid);
  (2)通过MultiByteToWideChar函数实现转换,例如:
  char *szProgID = "MAPI.Folder";
  WCHAR szWideProgID[128];
  CLSID clsid;
  long lLen = MultiByteToWideChar(CP_ACP,0,szProgID,strlen(szProgID),szWideProgID,sizeof(szWideProgID));
  szWideProgID[lLen] = '\0';
  (3)通过A2W宏来实现,例如:
  USES_CONVERSION;
  CLSIDFromProgID( A2W(szProgID),&clsid);
• 将Unicode转换到ANSI
  (1)使用WideCharToMultiByte,例如:
  // 假设已经有了一个Unicode 串 wszSomeString...
  char szANSIString [MAX_PATH];
  WideCharToMultiByte ( CP_ACP, WC_COMPOSITECHECK, wszSomeString, -1, szANSIString, sizeof(szANSIString), NULL, NULL );
  (2)使用W2A宏来实现,例如:
  USES_CONVERSION;
  pTemp=W2A(wszSomeString);

八、其它

• 对消息的处理中我们经常需要将WPARAM或LPARAM等32位数据（DWORD)分解成两个16位数据（WORD),例如：
  LPARAM lParam;
  WORD loValue = LOWORD(lParam);///取低16位
  WORD hiValue = HIWORD(lParam);///取高16位
  
  
• 对于16位的数据(WORD)我们可以用同样的方法分解成高低两个8位数据(BYTE),例如:
  WORD wValue;
  BYTE loValue = LOBYTE(wValue);///取低8位
  BYTE hiValue = HIBYTE(wValue);///取高8位
  
  
• 两个16位数据（WORD）合成32位数据(DWORD,LRESULT,LPARAM,或WPARAM)
  LONG MAKELONG( WORD wLow, WORD wHigh );
  WPARAM MAKEWPARAM( WORD wLow, WORD wHigh );
  LPARAM MAKELPARAM( WORD wLow, WORD wHigh );
  LRESULT MAKELRESULT( WORD wLow, WORD wHigh );
  
  
• 两个8位的数据(BYTE)合成16位的数据(WORD)
  WORD MAKEWORD( BYTE bLow, BYTE bHigh );
  
  
• 从R(red),G(green),B(blue)三色得到COLORREF类型的颜色值
  COLORREF RGB( BYTE byRed,BYTE byGreen,BYTE byBlue );
  例如COLORREF bkcolor = RGB(0x22,0x98,0x34);
  
  
• 从COLORREF类型的颜色值得到RGB三个颜色值
  BYTE Red = GetRValue(bkcolor); ///得到红颜色
  BYTE Green = GetGValue(bkcolor); ///得到绿颜色
  BYTE Blue = GetBValue(bkcolor); ///得到兰颜色
  

九、注意事项
假如需要使用到ConvertBSTRToString此类函数,需要加上头文件comutil.h,并在setting中加入comsupp.lib或者直接加上#pragma comment( lib, "comsupp.lib" )

2。在stdafx.cpp中加入:
int myInt;
然后在stdafx.h中加入:
extern int myInt
这样定义以后无论在什么文件中都是可见的.

3。比较规范的是，先定义一个Glbs.h，把所有的全局变量原始定义放进去。然后定义一个Externs.h，把你先前定义在Glbs.h中的变量都加上extern。注意：如果你在Glbs.h中设置了初值，那么在Externs.h中就不要加值了。然后调用时，第一次调用的＃i nclude <Glbs.h>，以后调用的＃i nclude <Externs.h>

另：

问：如何在VC++中使用全局变量，以使文档中的所有类都能访问。
　　答：把该变量放到该应用程序类的头文件中的attribute处。然后，在程序的任何地方，你都可以用下面的方法来访问该变量：
　　CMyApp *app=（CMyApp*）AfxGet-App（）；
　　app->MyGlobalVariable=…
　　用这个方法，不但可以定义全局变量，也可以定义全局对象。
　　例如：
　　MyClass MyObject；
　　CMyApp*app=（CMyApp*）AfxGet-App（）；
　　app->MyObject.MyFunction（）；

VC中使用全局变量的2种办法及防错措施

  
  1. 对于全局变量存在和函数一样的问题，为了在其他CPP文件中能够访问这些变量，必须在主文件的H文件中加上extern声明，格式如下：
extern varibletype var; （声明）
在主文件的CPP文件中定义
varibletype var; （定义）
例子:
AppWizard建立一个Test工程
那么在Test.h中声明extern CString cs;
在Test.app定义CString cs;

   如果要定义整个工程的全局变量，在任何一个CPP文件中进行定义，然后在需要引用这个变量的文件中进行声明。如全局变量很多可以选择使用定义全局变量的。h文件，在需要的地方直接include头文件即可，不需要写那么多extern了。
2.应用程序类的主头文件处定义变量varibletype var，然后，在程序的任何地方，都可以用下面的方法来访问该变量： 
　　CClassApp *app=(CClassApp*)AfxGetApp(); 
　　app->var=
　类似的，以上方法也可以定义全局对象
例子:
AppWizard建立一个Test工程
那么在Test.h中声明 CString cs;
使用的时候CTestApp *app=(CTestApp*)AfxGetApp(); 
    app->cs="Global"
 
防错措施：
若定义的函数和全局变量在多个文件包含且造成嵌套或多次调用的话，这样将导致这个头文件每被包含依次，函数或变量就被重新定义一次，在链接编译时会导致重定义错误。为此需要使用一种被称为Guard macro的技术来保证不出错。在一个头文件开头加上 
#ifndef   _MACRO_1_
#define   _MACRO_1_
在文件末尾增加 
#endif

打开VC＋＋6.0，建立一个基于对话框的MFC应用程序SCommTest;

2.在项目中插入MSComm控件  

选择Project菜单下Add To Project子菜单中的 Components and Controls…选项，在弹出的对话框中双击Registered ActiveX Controls项（稍等一会，这个过程较慢），则所有注册过的ActiveX控件出现在列表框中。 选择Microsoft Communications Control, version 6.0，，单击Insert按钮将它插入到我们的Project中来，接受缺省的选项。（如果你在控件列表中看不到Microsoft Communications Control, version 6.0，那可能是你在安装VC6时没有把ActiveX一项选上，重新安装VC6，选上ActiveX就可以了），

这时在ClassView视窗中就可以看到CMSComm类了，（注意：此类在ClassWizard中看不到，重构clw文件也一样），并且在控件工具栏Controls中出现了电话图标（如图1所示），现在要做的是用鼠标将此图标拖到对话框中，程序运行后，这个图标是看不到的。

3.利用ClassWizard定义CMSComm类控制对象

打开ClassWizard－>Member Viariables选项卡，选择CSCommTestDlg类，为IDC_MSCOMM1添加控制变量：m_ctrlComm，这时你可以看一看，在对话框头文件中自动加入了//{{AFX_INCLUDES() ＃i nclude "mscomm.h" //}}AFX_INCLUDES 。

再打开ClassWizard－>Member Viariables选项卡，选择CSCommTestDlg类， 为IDC_EDIT_RXDATA添加CString变量m_strRXData， 为IDC_EDIT_TXDATA添加CString变量m_strTXData。说明： m_strRXData和m_strTXData分别用来放入接收和发送的字符数据。

5.添加串口事件消息处理函数OnComm()

打开ClassWizard－>Message Maps，选择类CSCommTestDlg，选择IDC_MSCOMM1，双击消息OnComm，将弹出的对话框中将函数名改为OnComm。

这个函数是用来处理串口消息事件的，如每当串口接收到数据，就会产生一个串口接收数据缓冲区中有字符的消息事件，我们刚才添加的函数就会执行，我们在OnComm()函数加入相应的处理代码就能实现自已想要的功能了。请你在函数中加入如下代码：

void CSCommTestDlg::OnComm()
{
    // TODO: Add your control notification handler code here
    VARIANT variant_inp;
    COleSafeArray safearray_inp;
    LONG len,k;
    BYTE rxdata[2048]; //设置BYTE数组 An 8-bit integerthat is not signed.
    CString strtemp;
    if(m_ctrlComm.GetCommEvent()==2) //事件值为2表示接收缓冲区内有字符
    {             ////////以下你可以根据自己的通信协议加入处理代码
        variant_inp=m_ctrlComm.GetInput(); //读缓冲区
        safearray_inp=variant_inp; //VARIANT型变量转换为ColeSafeArray型变量
        len="safearray"_inp.GetOneDimSize(); //得到有效数据长度
        for(k=0;k<len;k++)
            safearray_inp.GetElement(&k,rxdata+k);//转换为BYTE型数组
        for(k=0;k<len;k++) //将数组转换为Cstring型变量
        {
            BYTE bt=*(char*)(rxdata+k); //字符型
            strtemp.Format("%c",bt); //将字符送入临时变量strtemp存放
            m_strRXData+=strtemp; //加入接收编辑框对应字符串
        }
    }
    UpdateData(FALSE); //更新编辑框内容
}

到目前为止还不能在接收编辑框中看到数据，因为我们还没有打开串口，但运行程序不应该有任何错误，不然，你肯定哪儿没看仔细，因为我是打开VC6对照着做一步写一行的，运行试试。没错吧？那么做下一步：

6.打开串口和设置串口参数

你可以在你需要的时候打开串口，例如在程序中做一个开始按钮，在该按钮的处理函数中打开串口。现在我们在主对话框的CSCommTestDlg::OnInitDialog()打开串口，加入如下代码：

// TODO: Add extra initialization here
if(m_ctrlComm.GetPortOpen())
m_ctrlComm.SetPortOpen(FALSE);

m_ctrlComm.SetCommPort(1); //选择com1
if( !m_ctrlComm.GetPortOpen())
m_ctrlComm.SetPortOpen(TRUE);//打开串口
else
AfxMessageBox("cannot open serial port");

m_ctrlComm.SetSettings("9600,n,8,1"); //波特率9600，无校验，8个数据位，1个停止位

m_ctrlComm.SetInputModel(1); //1：表示以二进制方式检取数据
m_ctrlComm.SetRThreshold(1);
//参数1表示每当串口接收缓冲区中有多于或等于1个字符时将引发一个接收数据的OnComm事件
m_ctrlComm.SetInputLen(0); //设置当前接收区数据长度为0
m_ctrlComm.GetInput();//先预读缓冲区以清除残留数据

现在你可以试试程序了，将串口线接好后（不会接？去看看我写的串口接线基本方法），打开串口调试助手，并将串口设在com2，选上自动发送，也可以等会手动发送。再执行你编写的程序，接收框里应该有数据显示了。

7.发送数据

先为发送按钮添加一个单击消息即BN_CLICKED处理函数，打开ClassWizard－>Message Maps，选择类CSCommTestDlg，选择IDC_BUTTON_MANUALSEND，双击BN_CLICKED添加OnButtonManualsend()函数，并在函数中添加如下代码：

void CSCommTestDlg::OnButtonManualsend()
{
// TODO: Add your control notification handler code here
UpdateData(TRUE); //读取编辑框内容
m_ctrlComm.SetOutput(COleVariant(m_strTXData));//发送数据
}

运行程序，在发送编辑框中随意输入点什么，单击发送按钮，啊！看看，在另一端的串口调试助手（或别的调试工具）接收框里出现了什么。

如果你真是初次涉猎串口编程，又一次成功，那该说声谢谢我了，因为我第一次做串口程序时可费劲了，那时网上的资料也不好找。开开玩笑，谢谢你的支持，有什么好东西别忘了给我寄一份。

说明：

由于用到VC控件，在没有安装VC的计算机上运行时要从VC中把mscomm32.ocx、msvcrt.dll、mfc42.dll拷到Windows目录下的System子目录中（win2000为System32）并再进行注册设置。

3.1 static_cast
用法：static_cast < type-id > ( expression )     
该运算符把expression转换为type-id类型，但没有运行时类型检查来保证转换的安全性。它主要有如下几种用法：
①用于类层次结构中基类和子类之间指针或引用的转换。
　　进行上行转换（把子类的指针或引用转换成基类表示）是安全的；
　　进行下行转换（把基类指针或引用转换成子类表示）时，由于没有动态类型检查，所以是不安全的。
②用于基本数据类型之间的转换，如把int转换成char，把int转换成enum。这种转换的安全性也要开发人员来保证。
③把空指针转换成目标类型的空指针。
④把任何类型的表达式转换成void类型。

注意：static_cast不能转换掉expression的const、volitale、或者__unaligned属性。

3.2 dynamic_cast
用法：dynamic_cast < type-id > ( expression )
该运算符把expression转换成type-id类型的对象。Type-id必须是类的指针、类的引用或者void *；
如果type-id是类指针类型，那么expression也必须是一个指针，如果type-id是一个引用，那么expression也必须是一个引用。

dynamic_cast主要用于类层次间的上行转换和下行转换，还可以用于类之间的交叉转换。
在类层次间进行上行转换时，dynamic_cast和static_cast的效果是一样的；
在进行下行转换时，dynamic_cast具有类型检查的功能，比static_cast更安全。
class B{
public:
       int m_iNum;
       virtual void foo();
};

class D:public B{
    public:
       char *m_szName[100];
};

void func(B *pb){
    D *pd1 = static_cast<D *>(pb);
    D *pd2 = dynamic_cast<D *>(pb);
}

在上面的代码段中，如果pb指向一个D类型的对象，pd1和pd2是一样的，并且对这两个指针执行D类型的任何操作都是安全的；
但是，如果pb指向的是一个B类型的对象，那么pd1将是一个指向该对象的指针，对它进行D类型的操作将是不安全的（如访问m_szName），
而pd2将是一个空指针。

另外要注意：B要有虚函数，否则会编译出错；static_cast则没有这个限制。
这是由于运行时类型检查需要运行时类型信息，而这个信息存储在类的虚函数表（
关于虚函数表的概念，详细可见<Inside c++ object model>）中，只有定义了虚函数的类才有虚函数表，
没有定义虚函数的类是没有虚函数表的。

另外，dynamic_cast还支持交叉转换（cross cast）。如下代码所示。
class A{
public:
        int m_iNum;
        virtual void f(){}
};

class B:public A{
};

class D:public A{
};

void foo(){
    B *pb = new B;
    pb->m_iNum = 100;

    D *pd1 = static_cast<D *>(pb);    //compile error
    D *pd2 = dynamic_cast<D *>(pb);  //pd2 is NULL
    delete pb;
}

在函数foo中，使用static_cast进行转换是不被允许的，将在编译时出错；而使用 dynamic_cast的转换则是允许的，结果是空指针。

3.3 reinpreter_cast
用法：reinpreter_cast<type-id> (expression)
type-id必须是一个指针、引用、算术类型、函数指针或者成员指针。
它可以把一个指针转换成一个整数，也可以把一个整数转换成一个指针（先把一个指针转换成一个整数，
在把该整数转换成原类型的指针，还可以得到原先的指针值）。

该运算符的用法比较多。

3.4 const_cast
用法：const_cast<type_id> (expression)
该运算符用来修改类型的const或volatile属性。除了const 或volatile修饰之外， type_id和expression的类型是一样的。
常量指针被转化成非常量指针，并且仍然指向原来的对象；
常量引用被转换成非常量引用，并且仍然指向原来的对象；常量对象被转换成非常量对象。

Voiatile和const类试。举如下一例：
class B{
public:
     int m_iNum;
}
void foo(){
 const B b1;
 b1.m_iNum = 100;            //comile error
 B b2 = const_cast<B>(b1);
 b2. m_iNum = 200;           //fine
}
上面的代码编译时会报错，因为b1是一个常量对象，不能对它进行改变；
使用const_cast把它转换成一个常量对象，就可以对它的数据成员任意改变。注意：b1和b2是两个不同的对象。

VC项目文件说明
.dsp   (developer studio project) 是VC++的项目文件,文本格式。项目参数配置文件，这个文件太重要，重点保护对象。    
.dsw (developer studio worksapce )工作区文件，重要性一般，因为它信息不我，容易恢复。它可以指向一个或多个.dsp文件
.c：源代码文件，按C语言用法编译处理。
.cpp：源代码文件，按C++语法编译处理。
.rc：资源文件。
      
以下文件在项目中是可丢弃的，有些文件删除后，VC会自动生成的。
.clw ClassWizard信息文件,实际上是INI文件的格式,有兴趣可以研究一下.有时候ClassWizard出问题,手工修改CLW文件可以解决.如果此文件不存在的话,每次用ClassWizard的时候绘提示你是否重建.
.ncb 无编译浏览文件(no compile browser)。当自动完成功能出问题时可以删除此文件。build后会自动生成。
.opt 工程关于开发环境的参数文件。如工具条位置等信息；(可丢弃)     
.aps (AppStudio File),资源辅助文件,二进制格式,一般不用去管他.
.plg 是编译信息文件,编译时的error和warning信息文件（实际上是一个html文件）,一般用处不大.在Tools->Options里面有个选项可以控制这个文件的生成. (建立日志文件)
.hpj (Help Project)是生成帮助文件的工程,用microsfot Help Compiler可以处理.
.mdp (Microsoft DevStudio Project)是旧版本的项目文件,如果要打开此文件的话,会提示你是否转换成新的DSP格式.
.bsc 是用于浏览项目信息的,如果用Source Brower的话就必须有这个文件.如果不用这个功能的话,可以在Project Options里面去掉Generate Browse Info File,可以加快编译速度.
.map 是执行文件的映像信息纪录文件,除非对系统底层非常熟悉,这个文件一般用不着.
.pch (Pre-Compiled File)是预编译文件,可以加快编译速度,但是文件非常大.
.pdb (Program Database)记录了程序有关的一些数据和调试信息,在调试的时候可能有用.
.exp 只有在编译DLL的时候才会生成,记录了DLL文件中的一些信息.一般也没什么用.