跟踪程序到 _heap_alloc_dbg

void * __cdecl _heap_alloc_dbg(
        size_t nSize,
        int nBlockUse,
        const char * szFileName,
        int nLine
        )
{
        long lRequest;
        size_t blockSize;
        int fIgnore = FALSE;
        _CrtMemBlockHeader * pHead;

        /* verify heap before allocation */
        if (_crtDbgFlag & _CRTDBG_CHECK_ALWAYS_DF)
            _ASSERTE(_CrtCheckMemory());

        lRequest = _lRequestCurr;

        /* break into debugger at specific memory allocation */
        if (lRequest == _crtBreakAlloc)
            _CrtDbgBreak();
// here is the place were the app stops

// ... function continuous

_crtBreakAlloc 为 -1 。 lRequest 为 long 型，每 new 一次， _lRequestCurr 每调用一次 new ，自动加 1 ，当 2147483647 再加 1 变成 -2147483648 ，一直累加到 -1 ，然后调用 _CrtDbgBreak() ，出错。看似是这个原因，为了进一步确认，编写测试程序

class AA

{

       char aa1[10];

       char aa2[12];

};

int main(int argc, char* argv[])

{

       AA *pp;

       while(1)

       {

              pp=new AA;

              delete pp;

       }

}

几个小时后复现了此现象。

网上查找0X10212AD0 有如下线索：
http://www.experts-exchange.com/Programming/Programming_Languages/MFC/Q_21088390.html

基于IP Multicast的传输和实现

周承芳 汪志兵 唐昆 杜文 　　摘要：设计并实现了一个基于IP Multicast技术的远程数字音视频监控系统，提出了分布式音视频接入共享的解决方案，能够有效地节省网络带宽；针对视频、音频语音和控制数据的不同传输特点，对其所采用的传输技术作了详细探讨，给出了具体实现方法。 　　关键词：监控系统 分布式接入共享 网络传输 IP组播 Windows套接字 　　随着计算机网络技术、多媒体技术、计算机视觉与模式识别技术的发燕尾服，一种以数字化、智能化为特点的多媒体远程数字监控系统应运而生，即基于IP的数字监控系统，实现了由传统的模拟监控到数字监控质的飞跃。与传统的模拟监控系统相比较，数字远程监控系统几个最主要的优势是：可以借助网络实现远程监控；在远程不同地点的分控中心或同个分控中心可同时调看某一个或者几个监控现场的音视频数据，从而实现分布式的音频频接入和音视频数据共享，同时，可以与监控现场人员进行对讲；可以对远程监控现场的云台、摄像机等外围设备进行控制。视频、音频的实时、分布式传输及控制指令的可靠传输是远程数字监控系统的一个关键问题。本文设计并实现了远程数字音频频监控系统，采用IP Multicast技术作为分布式音视频执着入和共享的解决方案，并针对视频、音频语音和控制数据不同的特点，对其所采用的不同传输技术进行了探讨，给出了具体实现方法。 　　1 系统的总体结构 　　远程监控系统一般包括三部分：前端监控现场、通信设备和后端分控中心。整个系统基于Client/Server（客户机/服务器）模式。总体结构如图1所示。 　　（1）前端监控现场由监控现场主机及一些外围设备组成。外围设备包括摄像机、电动镜头、云台、防护罩、监视器、多功能解码器及报警器。监控现场主机运行客户前端软件，实现视频、音频数据的实时采集、压缩、解压缩（音频）（视频传输 单向的，音频传输是双向的）及打包传送；对压缩的视（音）频数据进行经存储（也可在分近中心进行）。存储方式为循环存储、定时存储、手动存储及运动视频检测启动存储。接收来自分控中心的控制指令（也可在本地实施），对云台动作（上、下、左、右及自动）电动镜头的三可变（光圈、焦距和聚焦）。 　　（2）通信设备是指所采用的传输信道和相关设备，通信网络为LAN及WAN。 　　（3）后端设备由若干分控中心计算机组成。各分控计算机运行服务器端软件，接收来自前端压缩视（音）频、显示（播放）；通过网络对前端云台、摄像机进行控制；采用组播技术，实现分布式视频执着入和分丰式视频共享：每个分控中心主机可以同时监控多个前端，即“一点对多点”；不同分控心也可以同时监控同一前端，即“多点对一点”。 　　2 网络传输模块的设计与实现 　　2.1 系统传输数据类型的特点及通信协议的选择 　　系统传输数据有：控制数据、音频、视频数据、后端分控中心通过网络向监控现场主机外围设备云台及摄像机发送控制信号，实现云台动作（上、下、左、右、自动）摄像机光圈、焦距及聚焦三可变，要求控制信号的传输准确无误；音频、视频是连续，数据量大，允许传输中存在一定的数据错误率及数据丢失率，但实时性要求很高。此外，在监控系统中，要实现音视频的分布式接入和数据共享，必须进行音视频的多点传输。样实现上述目标？首先是通信协议的选择，TCP/IP协议是广泛使用的网协议，其网络模型定义了四层（即网络接口层、网络层、传输层、应用层）网络通信协议。传输层包含两个协议：传输控制协议（TCP）和用户数据报协议（UDP）。IP是国际互联协议，位于网络层。TCP协议是面向连接的，提供可靠的流服务；UDP是无连接的，提供数据报服务；TCP采用提供确认与超时重发、滑动窗口机制等措施来保证传输的可靠性，正是这些措施增加了网络的开销。如果用TCP传输视（音）频数据，大量的数据容量引起重传。，使得网络负载大并会加大延迟；UDP协议是最简单的传输协议，不提供可靠性保证，正因为UDP协议不进行数据确认与重传国，大大提高了传输效率，具有高效快速的特点；Ipv4定义了三种IP数据包的传输：单播、广播及组播。要系统中实现视（音）频数据的多点传输，若采用单播，则同样的音、视频数据要发送多次，这样导致发送者负担重、延迟长、网络拥塞；若用广播，网络中的每个站点都将接收到数据，不管该结点否需要数据，增加了非接收者的开销；组播是一种允许一个或多个发送者（组播源）发送单一的数据包到多个接收者（一次的、同时的）的网络技术。组播源把数据包发送到特定组播组，而只有属于该组播组的地址才能接收到数据包。由于无论有多少个目的地址，在整个网络的任何一条链路上都只传送单一的数据包。因此组播提高了网络传输的效率，极大地节省了网络传输。组播方式只适用于UDP。综上所述，采用TCP/IP传输控制信号，即信令通道；采用UDP/IP传输音视频信号，即数据通道。 　　IP组播依赖一个特殊的地址组——“移播址”，即D类地址。范围在224.0.0.0-239.255.255.255之间（其中224.0.0.0-224.0.0.255是被保留的地址），D类地址是动态分配和恢复的瞬态地址。组播地址只能作为信宿地址使用，而不能出现在任何信源地址中。每一个组播组对应于动态分配 的一个D类地址。组播的特点：组播组的成员是动态的，主机可以任何时间加入或离开组播组，主机组中的成员在位置上和数量 旧没有限制的。 　　2.2 Windows下，IP组播的Winsock2实现 　　Windows环境下组播通信是基于WindowsSocket的。Windows Socket提供两种不同IP组播的实现方法：Windows Socket提供两种不同的IP组播的实现方法：Winsock1与Winsock2。在Windows2000平台实现VC++6.0开发工具，在本系统中实现了基于Winsock2的组播通信编程。 　　发送端（前端、客户端）实现步骤： 　　(1)加载Winsock2库，完成Winsock2的初始化： 　　WSAStarup(MAKEWORD(2,2),&wsaData)；(2)建立本地套接字（UDP）： m_socket=WSASocke(AF_INET,SOCK_DGRAM,IPPROTO_UDP,NULL,0, WSA_FLAG_MULTIPOINT_C_LEAF|WSA_FLAG_MULTIPOINT_D_LEAF); 　　//组播通信具有两个层面的重要特征：控制层面和数据层面。控制层面决定一个多播组建立通信的方式，数据层面决定通信成员间数据传输的方式。每一个层面有两种形式，一种是“有限的”，另一种是“无根的”；数据报IP组播在两个层面上都是“无根”的。任一用户发送的数据都将被传送到组中所有其它成员。最后一个参数表明新创建的套接字在控制层面与数据层面都是“无根的”。 可以通过setsocket函数设置套接字的属性，如地址重用，缓冲区是接收还是发送。 　　M_localAddr.sin_family = AF_INET; 　　M_localAddr.sin_port=m_iPort;//本地端口号 　　M_localAddr..sin _addr.S_un.S_addr=m_uLocalIP;//本地IP地址； 　　（3）绑定（将新创建的套字节与本地插口地址进行绑定）： 　　bind(m_socket,(PSOCKADDR)&(m_localAddr),sizeof(m_localAddr); 　　(4)设置生存时间（即数据包最多允许路由多少个网段）： 　　WSAIoctl(m_socket,SIO_MULTICAST_SCOPE,//设置数据报生存时间； 　　&iMcastTTL,//生存时间大小； 　　sizeof(iMcastTTL),NULL,0,&cbRet,NULL,NULL)； 　　（5）配置Loopback,以决定组播数据帧是否回送： 　　int bLoopback=FALSE; 　　WSAIoct(m_socket,SIO_MULTIPOINT_LOOPBACK,//允许或禁止组播数据帧回送； 　　&bLoopback,sizeof(bLoopback)，NULL,0,&cbRet,NULL,NULL); 　　(6)收发数据： 　　在发送方（前端、客户端）响应发送的消息函数中调用下面函数： 　　WSASendTo (m_socket,&stWSABuf,&cbRet,0,(struct sockaddr*)&stDestAddr,//发送的目的地址； 　　sizeof(struct(sockaddr),NULL,NULL); 　　在发送方（前端、客户端）响应接收消息函数中调用下面函数： 　　WSARecvFrom(m_socket,&stWSABuf,1,& cbRet,&Flag,(struct sockaddr*)&stSrcAddr,//源地址； 　　&iLen，NULL，NULL）； 　　（7）将组播套接字设置为异步I/O工作模式，在该套节字上接收事件为基础的网络事件通知： 　　WSAEventSelect(m_socket，m_hNetworkEvent，//网络事件句柄；将此套字节与该事件句柄并联在一起； 　　FD_WRITE|FD_READ）；//发生此两个事件之一，则将m_hNetworkEvent置为有信号状态； 　　（8）在工作线程中设置： 　　WSAWaitForMultipleEvent（3，//等待事件的个数）； 　　p->m_eventArray,//存放事件句柄的数组； 　　FALSE，WSA_INFINITE，FALSE）； 　　（9）关闭组播套字节： 　　closesocket(m_socket)； 　　接收端（后端、服务器端）实现步骤： 　　（1）-（3）与发送端（客户端）相同； 　　（4）调用WSAJLoinLeaf加入组播组： 　　SOCKET NetSock=WSAJoinLeaf(sock,//必须为组播标志进行创建，否则调用失败； 　　（PSOCKADDR）&（m_stDestAddr,//组播导址，与发送方的目的地址相同； 　　sizeof(m_stDestAddr),UNLL,NULL,NULL,NULL, 　　JL_BOTH));//允许接收和发送； 　　（5）与客户端（6）相同；（6）与客户端（7）相同；（7）与客户端（8）相同；（8）离开组播组；closesocket(NewSock)；//NewSock是调用WSAoinLeaf（）返回的套节字。 　　2.3 在监控系统中网络传输模块的设计 　　网络传输模块流程如图2所示。   　　发送端（前端监控现场主机、客户端）监控主机运行客户端程序。在主线程中，启动视同、音频两个线程分别对视频及音频进行采集，放入视（音）频缓冲区；视频在本地回放；同时，监听分控中心的连接请求，收到连接请求，TCP三次握手，建立TCP连接（信令通道）；通过信令通道，向分控心发送二组组播地址及端口号（对应视频及音频，音频两个线程；分别在视（音）频线程中完成；利用Winsock2建立视（音）频数据通道（UDP）（源码前已述及）；对视（音）频进行压缩编码、组播发送；音频线程接收分控中心的音频数据包，解码并播放；实现视频的单向传输和音频的双向传输。 　　接收端（后端分控中心、服务器端）分控中心主机运行服务器端程序，在主线程中向前端监控现场主机发出连接请求（CALL），三次握手建立TCP连接（信令通道）；后端接收到组播地址及端口号后，启动视（音）频两个线程，完成；利用Winsock2建立视（音）频数据通道（UDP），加入视（音）频组播组，接收压缩视（音）频包，并解码显示（播放）；其中音频线程，还要完成音频数据包解码显示（播放）；其中音频线程，还要完成音频数据包的压缩、发送；实现视频的单向传输、音频的双向传输。 　　一个后端分控中心可同时监控12路前端视频及音频信号，在设计服务器端监控程序时，采用多线程技术，每建立一对前端监控主机与后端分控中心（服务器）的TCP连接，就开两个接收线程（一个接收视频线程；一个接收音频线程），视频线程接收视频数据包进行解压缩及回放；音频线程接收音频数据包进行解压缩及播放。对云台及摄像机的控制指令通过信令通道传输。 　　本系统运行在Win2000平台上，用VC++6.0开发工具开发。 　　在远程数字音视频监控系统的传输模块设计中，根据音频频数据传输及控制信号传输的特点，运用IP组播技术极大地减轻了网络负担，避免了资源的浪费，节省了网络带宽；利用TCP/IP协议设计了信令通道（TCP）和数据通道（UDP）；运用Windows多线程机制实现了音频数据的实时、多点传输和控制信号的可靠传，提高了程序运行的效率。在该系统的基础上进行改造和扩展，可以应用到远程教学、远程医疗等多种多媒体通信；因此，远程数字音视频监控系统的设计和实现不仅具有监控方面的现实意义，而且对于许多应用都有借鉴和参考价值。

WSAEventSelect（开发网络通信程序入门的继续--转自CSDN）

   前面讨论的开发网络通信的经典入门采用的是WSAAsyncSelect的异步I/O模型，本文将讨论WSAEventSelect异步I/O模型。

       WSAEventSelect模型有点类似WSAAsyncSelect模型，不同的是他不是用消息映射的方式来响应网络事件，而是用等待多重事件的方式来响应网络事件。下面是用WSAEventSelect模型和多线程机制做的一个简单的服务器程序的.cpp和.h文件，应用程序基于MFC的标准对话框。实现接受多个客户端的连接请求，并记录下所有客户端的相关信息，显示在列表框中。

// serverDlg.cpp : implementation file
//

#include "stdafx.h"
#include "server.h"
#include "serverDlg.h"

#ifdef _DEBUG
#define new DEBUG_NEW
#undef THIS_FILE
static char THIS_FILE[] = __FILE__;
#endif

SOCKET Accept; file://用于新的一个连接通信的套接字
WSAEVENT NewEvent; file://对应于新的套接字的新事件
SOCKET Socket[WSA_MAXIMUM_WAIT_EVENTS];  file://存放所有生成的套接字
WSAEVENT Event[WSA_MAXIMUM_WAIT_EVENTS]; file://存放所有生成的事件对象
int EventTotal; file://创建的事件总数
int Index;      file://等待多重事件函数的返回值
WSANETWORKEVENTS NetworkEvents; file://用于接收套接字上发生的网络事件类型以及可能出现的错
误代码

/////////////////////////////////////////////////////////////////////////////
// CAboutDlg dialog used for App About

class CAboutDlg : public CDialog
{
public:
 CAboutDlg();

// Dialog Data
 file://{{AFX_DATA(CAboutDlg)
 enum { IDD = IDD_ABOUTBOX };
 file://}}AFX_DATA

 // ClassWizard generated virtual function overrides
 file://{{AFX_VIRTUAL(CAboutDlg)
 protected:
 virtual void DoDataExchange(CDataExchange* pDX);    // DDX/DDV support
 file://}}AFX_VIRTUAL

// Implementation
protected:
 file://{{AFX_MSG(CAboutDlg)
 file://}}AFX_MSG
 DECLARE_MESSAGE_MAP()
};

CAboutDlg::CAboutDlg() : CDialog(CAboutDlg::IDD)
{
 file://{{AFX_DATA_INIT(CAboutDlg)
 file://}}AFX_DATA_INIT
}

void CAboutDlg::DoDataExchange(CDataExchange* pDX)
{
 CDialog::DoDataExchange(pDX);
 file://{{AFX_DATA_MAP(CAboutDlg)
 file://}}AFX_DATA_MAP
}

BEGIN_MESSAGE_MAP(CAboutDlg, CDialog)
 file://{{AFX_MSG_MAP(CAboutDlg)
  // No message handlers
 file://}}AFX_MSG_MAP
END_MESSAGE_MAP()

/////////////////////////////////////////////////////////////////////////////
// CServerDlg dialog

CServerDlg::CServerDlg(CWnd* pParent /*=NULL*/)
 : CDialog(CServerDlg::IDD, pParent)
{
 file://{{AFX_DATA_INIT(CServerDlg)
  // NOTE: the ClassWizard will add member initialization here
 file://}}AFX_DATA_INIT
 // Note that LoadIcon does not require a subsequent DestroyIcon in Win32
 m_Connectnum = 0;
 m_NetworkID = 0;
 EventTotal = 0;
    for(int i = 0; i < MAX_CLIENT_NUM; i++)
 {
  ZeroMemory(&m_ClientInfo[i], sizeof(client_info));
 }

 m_hIcon = AfxGetApp()->LoadIcon(IDR_MAINFRAME);
}

void CServerDlg::DoDataExchange(CDataExchange* pDX)
{
 CDialog::DoDataExchange(pDX);
 file://{{AFX_DATA_MAP(CServerDlg)
  // NOTE: the ClassWizard will add DDX and DDV calls here
 file://}}AFX_DATA_MAP
}

BEGIN_MESSAGE_MAP(CServerDlg, CDialog)
 file://{{AFX_MSG_MAP(CServerDlg)
 ON_WM_SYSCOMMAND()
 ON_WM_PAINT()
 ON_WM_QUERYDRAGICON()
 ON_WM_TIMER()
 file://}}AFX_MSG_MAP
END_MESSAGE_MAP()

/////////////////////////////////////////////////////////////////////////////
// CServerDlg message handlers

BOOL CServerDlg::OnInitDialog()
{
 CDialog::OnInitDialog();

 // Add "About..." menu item to system menu.

 // IDM_ABOUTBOX must be in the system command range.
 ASSERT((IDM_ABOUTBOX & 0xFFF0) == IDM_ABOUTBOX);
 ASSERT(IDM_ABOUTBOX < 0xF000);

 CMenu* pSysMenu = GetSystemMenu(FALSE);
 if (pSysMenu != NULL)
 {
  CString strAboutMenu;
  strAboutMenu.LoadString(IDS_ABOUTBOX);
  if (!strAboutMenu.IsEmpty())
  {
   pSysMenu->AppendMenu(MF_SEPARATOR);
   pSysMenu->AppendMenu(MF_STRING, IDM_ABOUTBOX, strAboutMenu);
  }
 }

 // Set the icon for this dialog.  The framework does this automatically
 //  when the application's main window is not a dialog
 SetIcon(m_hIcon, TRUE);   // Set big icon
 SetIcon(m_hIcon, FALSE);  // Set small icon
 
 // TODO: Add extra initialization here

 WSADATA wsaData;
 int ret;

 ret = WSAStartup(MAKEWORD(2,2), &wsaData);
 if(ret != 0)
 {
  MessageBox("初始化套接字失败!");
  return FALSE;
 }

 file://创建一个套接字
 m_ListenSocket = socket(AF_INET, SOCK_STREAM, IPPROTO_TCP);
        if(m_ListenSocket == INVALID_SOCKET)
 {
  MessageBox("创建套接字失败!");
  closesocket(m_ListenSocket);
  WSACleanup();
  return FALSE;
 }

 file://绑定到指定的端口上
 sockaddr_in localaddr;
 localaddr.sin_family = AF_INET;
 localaddr.sin_port = htons(1688);
 localaddr.sin_addr.s_addr = 0;

 if(bind(m_ListenSocket, (const struct sockaddr*)&localaddr, sizeof(sockaddr))
                                                                 == SOCKET_ERROR)
 {
  MessageBox("绑定地址失败!");
  closesocket(m_ListenSocket);
  WSACleanup();
  return FALSE;
 }
 
 NewEvent = WSACreateEvent(); file://创建一个新的事件对象

 file://将创建的事件对象与前面创建的套接字关联在一起,并注册网络事件类型
        if(WSAEventSelect(m_ListenSocket, NewEvent, FD_ACCEPT | FD_CLOSE) == SOCKET_ERROR)
 {
  MessageBox("注册网络事件失败!");
  closesocket(m_ListenSocket);
  WSACleanup();
  return FALSE;
 }

 file://让创建的套接字处于监听状态
 listen(m_ListenSocket, 5);

 Event[EventTotal] = NewEvent;
 Socket[EventTotal] = m_ListenSocket;
 EventTotal++;

        file://设置List控件的图象列表
 HICON hIcon;

 m_imagelist.Create(16, 16, 0, 4, 4); // 32, 32 for large icons
 hIcon = AfxGetApp()->LoadIcon(IDI_CLIENT_INFO);
 
 m_imagelist.SetBkColor (RGB(248,232,224));
 m_imagelist.Add(hIcon);

 pList = (CListCtrl*)GetDlgItem(IDC_CLIENT_INFO);
 pList->SetImageList(&m_imagelist, LVSIL_SMALL);
 pList->SetBkColor(RGB(248,232,224));
 pList->SetTextBkColor(RGB(248,232,224));

 pList->InsertColumn(0,"   客户名",LVCFMT_CENTER,90, 0);
 pList->InsertColumn(1,"网络ID",LVCFMT_CENTER,50,1);
 pList->InsertColumn(2,"IP地址",LVCFMT_CENTER,100,2);
 pList->InsertColumn (3,"登录时间",LVCFMT_CENTER,120,3);
 pList->InsertColumn (4,"在线时间",LVCFMT_CENTER,100,4);

 SetTimer(1, 1000, NULL);

 file://启动核心处理线程
 AfxBeginThread(KernelWorkThread,this,THREAD_PRIORITY_NORMAL);

 return TRUE;  // return TRUE  unless you set the focus to a control
}

void CServerDlg::OnSysCommand(UINT nID, LPARAM lParam)
{
 if ((nID & 0xFFF0) == IDM_ABOUTBOX)
 {
  CAboutDlg dlgAbout;
  dlgAbout.DoModal();
 }
 else
 {
  CDialog::OnSysCommand(nID, lParam);
 }
}

// If you add a minimize button to your dialog, you will need the code below
//  to draw the icon.  For MFC applications using the document/view model,
//  this is automatically done for you by the framework.

void CServerDlg::OnPaint()
{
 if (IsIconic())
 {
  CPaintDC dc(this); // device context for painting

  SendMessage(WM_ICONERASEBKGND, (WPARAM) dc.GetSafeHdc(), 0);

  // Center icon in client rectangle
  int cxIcon = GetSystemMetrics(SM_CXICON);
  int cyIcon = GetSystemMetrics(SM_CYICON);
  CRect rect;
  GetClientRect(&rect);
  int x = (rect.Width() - cxIcon + 1) / 2;
  int y = (rect.Height() - cyIcon + 1) / 2;

  // Draw the icon
  dc.DrawIcon(x, y, m_hIcon);
 }
 else
 {
  CDialog::OnPaint();
 }
}

// The system calls this to obtain the cursor to display while the user drags
//  the minimized window.
HCURSOR CServerDlg::OnQueryDragIcon()
{
 return (HCURSOR) m_hIcon;
}

file://核 心处理线程, 响应并处理各种网络事件
UINT KernelWorkThread(LPVOID pParam)
{
 int len = sizeof(sockaddr);

 CServerDlg* dlg;
 dlg = (CServerDlg*)pParam;

 while(1)
 {
         Index = WSAWaitForMultipleEvents(EventTotal, Event, FALSE, WSA_INFINITE, FALSE);

  WSAEnumNetworkEvents(Socket[Index - WSA_WAIT_EVENT_0],
                     Event[Index - WSA_WAIT_EVENT_0],
                                     &NetworkEvents);
 
  if(NetworkEvents.lNetworkEvents & FD_ACCEPT)
  file://连接事件
  {
   if(NetworkEvents.iErrorCode[FD_ACCEPT_BIT] != 0)
   {
    dlg->MessageBox("接受连接事件失败!");
    break;
   }

   Accept = accept(Socket[Index - WSA_WAIT_EVENT_0],
                                 (struct sockaddr*)&(dlg->clientaddr), &len);
   if(Accept == INVALID_SOCKET)
   {
    dlg->MessageBox("接受连接失败!");
    break;
   }
   
   if(EventTotal > WSA_MAXIMUM_WAIT_EVENTS)
   {
    dlg->MessageBox("连接个数溢出,拒绝接受!");
    break;
   }

   NewEvent = WSACreateEvent();

   if(WSAEventSelect(Accept, NewEvent, FD_READ | FD_WRITE | FD_CLOSE)
                                                                   == SOCKET_ERROR)
   {
    dlg->MessageBox("注册网络事件失败!");
    closesocket(Accept);
    break;
   }

   Event[EventTotal] = NewEvent;
   Socket[EventTotal] = Accept;
   EventTotal ++;
  }

  if(NetworkEvents.lNetworkEvents & FD_READ)
  file://读取数据事件
  {
   if(NetworkEvents.iErrorCode[FD_READ_BIT] != 0)
   {
    dlg->MessageBox("读事件失败!");
    break;
   }

   if(dlg->OnReceive(Socket[Index - WSA_WAIT_EVENT_0]) == FALSE)
   {
    dlg->MessageBox("读取数据失败!");
    break;
   }
  }

  if(NetworkEvents.lNetworkEvents & FD_CLOSE)
  file://关闭套接字事件
  {
   if(NetworkEvents.iErrorCode[FD_CLOSE_BIT] != 0)
   {
    dlg->MessageBox("关闭事件失败!");
    break;
   }

   if(dlg->OnClose(Socket[Index - WSA_WAIT_EVENT_0]) == FALSE)
   {
    dlg->MessageBox("关闭套接字失败!");
    break;
   }
  }
 }

 return 0;
}

BOOL CServerDlg::OnClose(SOCKET pSocket)
{
 int i, exitnum;
 
 for(i = 0; i < m_Connectnum; i++)
 {
  if(m_ClientInfo[i].Client_Socket == pSocket)
  {
   exitnum = i;
  }
 }
 for(i = exitnum; i < m_Connectnum; i++)
 {
  memcpy(&m_ClientInfo[i], &m_ClientInfo[i+1], sizeof(client_info));
 }

 m_Connectnum --;

 file://向所有客户端发送在线客户信息的报文
 cmd_client_info ClientInfo;
 ClientInfo.cmd_type = CMD_CLIENT_INFO;
 ClientInfo.client_num = m_Connectnum;
 
 for(i=0; i<=m_Connectnum; i++)
 {
  ClientInfo.Networks_ID[i] = m_ClientInfo[i].Network_ID;
  strcpy(ClientInfo.users_name[i], m_ClientInfo[i].User_Name);
  strcpy(ClientInfo.clients_ipaddr[i], inet_ntoa(m_ClientInfo[i].Client_Addr.sin_addr));
 }
 for(i=0; i<=m_Connectnum; i++)
 {
  send(m_ClientInfo[i].Client_Socket, (char*)&ClientInfo, sizeof(cmd_client_info), NULL);
 }
 closesocket(pSocket);

        pList->DeleteItem(exitnum);
 
 return TRUE;
}

BOOL CServerDlg::OnReceive(SOCKET pSocket)
{
    static char rcvbuf[65535];   file://接收缓冲区
    int ret;
 int offset=0;
 find_type* pFindType;
 int i = 0;
 CTime m_current_time=CTime::GetCurrentTime ();
 CString strTime = m_current_time.Format("%c");
 CString networkid; file://列表框的网络ID项

    ret = recv(pSocket, rcvbuf, 65535, 0);
 if(ret == OPERATION_ERROR)
  return FALSE;

 while(offset < ret)
 {
  pFindType = (find_type*)(rcvbuf+offset);
  switch(pFindType->cmd_type)
  {
  case CMD_HELLO: 
   cmd_hello Hello;
   memcpy(&Hello, rcvbuf+offset, sizeof(cmd_hello));
   offset+=sizeof(cmd_hello);

   cmd_hello_resp HelloResp;
   m_NetworkID ++;
   HelloResp.cmd_type = CMD_HELLO_RESP;
   HelloResp.Network_ID = m_NetworkID;
   strcpy(HelloResp.user_name, Hello.user_name);

   memcpy((struct sockaddr*)&(m_ClientInfo[m_Connectnum].Client_Addr),
    (const struct sockaddr*)&clientaddr, sizeof(sockaddr));
   m_ClientInfo[m_Connectnum].Client_Socket = Accept;
   strcpy(m_ClientInfo[m_Connectnum].User_Name, HelloResp.user_name);
   m_ClientInfo[m_Connectnum].Network_ID = m_NetworkID;
   m_ClientInfo[m_Connectnum].Login_Time = m_current_time;
   send(pSocket, (char*)&HelloResp, sizeof(cmd_hello_resp), NULL);

   file://向登录的客户端发送回应报文
   Sleep(200);

   cmd_client_info ClientInfo;
   ClientInfo.cmd_type = CMD_CLIENT_INFO;
   ClientInfo.client_num = m_Connectnum +1;

   for(i=0; i<=m_Connectnum; i++)
   {
    ClientInfo.Networks_ID[i] = m_ClientInfo[i].Network_ID;
    strcpy(ClientInfo.users_name[i], m_ClientInfo[i].User_Name);
                                strcpy(ClientInfo.clients_ipaddr[i],
                                       inet_ntoa(m_ClientInfo[i].Client_Addr.sin_addr));
   }

   file://向所有在线客户端发送在线客户信息报文
   for(i=0; i<=m_Connectnum; i++)
   {
    send(m_ClientInfo[i].Client_Socket, (char*)&ClientInfo,
                                     sizeof(cmd_client_info), NULL);
   }

   file://刷新客户端信息列表
   networkid.Format("%d", m_NetworkID);

   LVITEM lvinsert;
   lvinsert.mask=LVIF_TEXT|LVIF_IMAGE|LVIF_PARAM;
   lvinsert.iItem=m_Connectnum;
   lvinsert.iSubItem=0;
   lvinsert.cchTextMax=20;
   lvinsert.pszText=HelloResp.user_name;
   lvinsert.iImage = 0;
   pList->InsertItem (&lvinsert);
   pList->SetItemText (m_Connectnum,1,networkid);
   pList->SetItemText(m_Connectnum,2,
                               inet_ntoa(m_ClientInfo[m_Connectnum].Client_Addr.sin_addr));
   pList->SetItemText (m_Connectnum,3,strTime);

   m_Connectnum ++;

   break;
  case CMD_ASK:
   cmd_ask Ask;
   cmd_ask_resp AskResp;
   memcpy(&Ask,rcvbuf+offset,sizeof(cmd_ask));
   offset+=sizeof(cmd_ask);
   AskResp.cmd_type = CMD_ASK_RESP;
   AskResp.Network_ID = Ask.Network_ID;
   for(i=0; i<m_Connectnum; i++)
   {
    if(m_ClientInfo[i].Network_ID == Ask.Network_ID)
    {
     strcpy(AskResp.pData1,m_ClientInfo[i].User_Name);
     strcat(AskResp.pData1, ":");
    }
   }
   strcpy(AskResp.pData2, Ask.pData);
   for(i=0; i<m_Connectnum; i++)
   {
    send(m_ClientInfo[i].Client_Socket, (char*)&AskResp, sizeof(AskResp), 0);
   }

   break;
  case CMD_GOODBYE:
   closesocket(pSocket);
   break;
  default:
   break;
  }
 }

 return TRUE;
}
BOOL CServerDlg::OnSend(SOCKET pSocket)
{
 return TRUE;
}

void CServerDlg::OnOK()
{
 closesocket(m_ListenSocket);
 WSACleanup();
 CDialog::OnOK();
}

void CServerDlg::OnTimer(UINT nIDEvent)
{
 CTime m_current_time = CTime::GetCurrentTime();
 CTimeSpan logintimes;
 CString login_times;
 CString networkid; file://列表框的网络ID项
 
 for(int i=0; i<m_Connectnum; i++)
 {
  logintimes = m_current_time - m_ClientInfo[i].Login_Time;
  login_times.Format("%d小时%d分%d秒", logintimes.GetHours(),
                                    logintimes.GetMinutes(),
            logintimes.GetSeconds());
 
  pList->SetItemText (i,4,login_times);
 }

 CDialog::OnTimer(nIDEvent);
}

// serverDlg.h : header file
//

#if !defined(AFX_SERVERDLG_H__B0AA0367_C1F4_11D4_AB1C_0080C8D6FEA5__INCLUDED_)
#define AFX_SERVERDLG_H__B0AA0367_C1F4_11D4_AB1C_0080C8D6FEA5__INCLUDED_

#if _MSC_VER > 1000
#pragma once
#endif // _MSC_VER > 1000

#include "global.h"

/////////////////////////////////////////////////////////////////////////////
// CServerDlg dialog

class CServerDlg : public CDialog
{
file://全局函数
    friend UINT KernelWorkThread(LPVOID pParam);
// Construction
public:
 CListCtrl* pList; file://客户端在线信息列表框对象
 CImageList m_imagelist;

 SOCKET m_ListenSocket; file://用于监听端口的套接字
 client_info m_ClientInfo[MAX_CLIENT_NUM]; file://保存在线客户端信息的结构体数组
 sockaddr_in clientaddr; file://保存发起连接的客户端地址
 int m_Connectnum; file://在线客户端个数
 int m_NetworkID;  file://返回给客户端的网络ID号

 BOOL OnSend(SOCKET pSocket);    file://发送数据网络事件的响应函数
 BOOL OnReceive(SOCKET pSocket); file://接收数据网络事件的响应函数 
 BOOL OnClose(SOCKET pSocket);   file://关闭套接字网络事件的响应函数

 CServerDlg(CWnd* pParent = NULL); // standard constructor

// Dialog Data
 file://{{AFX_DATA(CServerDlg)
 enum { IDD = IDD_SERVER_DIALOG };
  // NOTE: the ClassWizard will add data members here
 file://}}AFX_DATA

 // ClassWizard generated virtual function overrides
 file://{{AFX_VIRTUAL(CServerDlg)
 protected:
 virtual void DoDataExchange(CDataExchange* pDX); // DDX/DDV support
 file://}}AFX_VIRTUAL

// Implementation
protected:
 HICON m_hIcon;

 // Generated message map functions
 file://{{AFX_MSG(CServerDlg)
 virtual BOOL OnInitDialog();
 afx_msg void OnSysCommand(UINT nID, LPARAM lParam);
 afx_msg void OnPaint();
 afx_msg HCURSOR OnQueryDragIcon();
 virtual void OnOK();
 afx_msg void OnTimer(UINT nIDEvent);
 file://}}AFX_MSG
 DECLARE_MESSAGE_MAP()
};

1 什么是回调
软件模块之间总是存在着一定的接口，从调用方式上，可以把他们分为三类：同步调用、回调和异步调用。同步调用是一种阻塞式调用，调用方要等待对方执行完毕才返回，它是一种单向调用；回调是一种双向调用模式，也就是说，被调用方在接口被调用时也会调用对方的接口；异步调用是一种类似消息或事件的机制，不过它的调用方向刚好相反，接口的服务在收到某种讯息或发生某种事件时，会主动通知客户方（即调用客户方的接口）。回调和异步调用的关系非常紧密，通常我们使用回调来实现异步消息的注册，通过异步调用来实现消息的通知。同步调用是三者当中最简单的，而回调又常常是异步调用的基础，因此，下面我们着重讨论回调机制在不同软件架构中的实现。

对于不同类型的语言（如结构化语言和对象语言）、平台（Win32、JDK）或构架（CORBA、DCOM、WebService），客户和服务的交互除了同步方式以外，都需要具备一定的异步通知机制，让服务方（或接口提供方）在某些情况下能够主动通知客户，而回调是实现异步的一个最简捷的途径。

对于一般的结构化语言，可以通过回调函数来实现回调。回调函数也是一个函数或过程，不过它是一个由调用方自己实现，供被调用方使用的特殊函数。

在面向对象的语言中，回调则是通过接口或抽象类来实现的，我们把实现这种接口的类成为回调类，回调类的对象成为回调对象。对于象C++或Object Pascal这些兼容了过程特性的对象语言，不仅提供了回调对象、回调方法等特性，也能兼容过程语言的回调函数机制。

Windows平台的消息机制也可以看作是回调的一种应用，我们通过系统提供的接口注册消息处理函数（即回调函数），从而实现接收、处理消息的目的。由于Windows平台的API是用C语言来构建的，我们可以认为它也是回调函数的一个特例。

对于分布式组件代理体系CORBA，异步处理有多种方式，如回调、事件服务、通知服务等。事件服务和通知服务是CORBA用来处理异步消息的标准服务，他们主要负责消息的处理、派发、维护等工作。对一些简单的异步处理过程，我们可以通过回调机制来实现。

下面我们集中比较具有代表性的语言（C、Object Pascal）和架构（CORBA）来分析回调的实现方式、具体作用等。

2 过程语言中的回调（C）

2.1 函数指针
回调在C语言中是通过函数指针来实现的,通过将回调函数的地址传给被调函数从而实现回调。因此，要实现回调，必须首先定义函数指针，请看下面的例子：

void Func(char *s)；// 函数原型
void (*pFunc) (char *);//函数指针

可以看出，函数的定义和函数指针的定义非常类似。

一般的化，为了简化函数指针类型的变量定义，提高程序的可读性，我们需要把函数指针类型自定义一下。

typedef void(*pcb)(char *);

回调函数可以象普通函数一样被程序调用，但是只有它被当作参数传递给被调函数时才能称作回调函数。

被调函数的例子：

void GetCallBack(pcb callback)
{
/*do something*/
}
用户在调用上面的函数时，需要自己实现一个pcb类型的回调函数：
void fCallback(char *s) 
{
/* do something */
} 
然后，就可以直接把fCallback当作一个变量传递给GetCallBack,
GetCallBack（fCallback）;

如果赋了不同的值给该参数，那么调用者将调用不同地址的函数。赋值可以发生在运行时，这样使你能实现动态绑定。

2.2 参数传递规则
到目前为止，我们只讨论了函数指针及回调而没有去注意ANSI C/C++的编译器规范。许多编译器有几种调用规范。如在Visual C++中，可以在函数类型前加_cdecl，_stdcall或者_pascal来表示其调用规范（默认为_cdecl）。C++ Builder也支持_fastcall调用规范。调用规范影响编译器产生的给定函数名，参数传递的顺序（从右到左或从左到右），堆栈清理责任（调用者或者被调用者）以及参数传递机制（堆栈，CPU寄存器等）。

将调用规范看成是函数类型的一部分是很重要的；不能用不兼容的调用规范将地址赋值给函数指针。例如：

// 被调用函数是以int为参数，以int为返回值
__stdcall int callee(int); 

// 调用函数以函数指针为参数
void caller( __cdecl int(*ptr)(int)); 

// 在p中企图存储被调用函数地址的非法操作
__cdecl int(*p)(int) = callee; // 出错

指针p和callee()的类型不兼容，因为它们有不同的调用规范。因此不能将被调用者的地址赋值给指针p，尽管两者有相同的返回值和参数列

2.3 应用举例
C语言的标准库函数中很多地方就采用了回调函数来让用户定制处理过程。如常用的快速排序函数、二分搜索函数等。

快速排序函数原型：

void qsort(void *base, size_t nelem, size_t width, int (_USERENTRY *fcmp)(const void *, const void *));
二分搜索函数原型：
void *bsearch(const void *key, const void *base, size_t nelem,
				 size_t width, int (_USERENTRY *fcmp)(const void *, const void *));

其中fcmp就是一个回调函数的变量。

下面给出一个具体的例子：

#include <stdio.h>
#include <stdlib.h>

int sort_function( const void *a, const void *b);
int list[5] = { 54, 21, 11, 67, 22 };

int main(void)
{
   int  x;

   qsort((void *)list, 5, sizeof(list[0]), sort_function);
   for (x = 0; x < 5; x++)
      printf("%i\n", list[x]);
   return 0;
}

int sort_function( const void *a, const void *b)
{
   return *(int*)a-*(int*)b;
}

2.4 面向对象语言中的回调（Delphi）

Dephi与C++一样，为了保持与过程语言Pascal的兼容性，它在引入面向对象机制的同时，保留了以前的结构化特性。因此，对回调的实现，也有两种截然不同的模式，一种是结构化的函数回调模式，一种是面向对象的接口模式。

2.4.1 回调函数

回调函数类型定义：

type
   TCalcFunc=function (a:integer;b:integer):integer;

按照回调函数的格式自定义函数的实现，如

function Add(a:integer;b:integer):integer
begin
  result:=a+b;
end;
function Sub(a:integer;b:integer):integer
begin
  result:=a-b;
end;

回调的使用

function Calc(calc:TcalcFunc;a:integer;b:integer):integer

下面，我们就可以在我们的程序里按照需要调用这两个函数了

c:=calc(add,a,b);//c=a+b
c:=calc(sub,a,b);//c=a-b

2.4.2 回调对象

什么叫回调对象呢，它具体用在哪些场合？首先，让我们把它与回调函数对比一下，回调函数是一个定义了函数的原型，函数体则交由第三方来实现的一种动态应用模式。要实现一个回调函数，我们必须明确知道几点：该函数需要那些参数，返回什么类型的值。同样，一个回调对象也是一个定义了对象接口，但是没有具体实现的抽象类（即接口）。要实现一个回调对象，我们必须知道：它需要实现哪些方法，每个方法中有哪些参数，该方法需要放回什么值。

因此，在回调对象这种应用模式中，我们会用到接口。接口可以理解成一个定义好了但是没有实现的类，它只能通过继承的方式被别的类实现。Delphi中的接口和COM接口类似，所有的接口都继承与IInterface（等同于IUnknow），并且要实现三个基本的方法QueryInterface, _AddRef, 和_Release。

• 定义一个接口
  

  type IShape=interface(IInterface) procedure Draw; end

• 实现回调类
  

  type TRect=class(TObject,IShape) protected function QueryInterface(const IID: TGUID; out Obj): HResult; stdcall; function _AddRef: Integer; stdcall; function _Release: Integer; stdcall; public procedure Draw; end; type TRound=class(TObject,IShape) protected function QueryInterface(const IID: TGUID; out Obj): HResult; stdcall; function _AddRef: Integer; stdcall; function _Release: Integer; stdcall; public procedure Draw; end;

• 使用回调对象
  

  procedure MyDraw(shape:IShape); var shape:IShape; begin shape.Draw; end;

如果传入的对象为TRect，那么画矩形；如果为TRound，那么就为圆形。用户也可以按照自己的意图来实现IShape接口，画出自己的图形：

MyDraw(Trect.Create);
MyDraw(Tround.Create);

2.4.3 回调方法

回调方法(Callback Method)可以看作是回调对象的一部分，Delphi对windows消息的封装就采用了回调方法这个概念。在有些场合，我们不需要按照给定的要求实现整个对象，而只要实现其中的一个方法就可以了，这是我们就会用到回调方法。

回调方法的定义如下：

TNotifyEvent = procedure(Sender: TObject) of object; 
TMyEvent=procedure(Sender:Tobject;EventId:Integer) of object;

TNotifyEvent 是Delphi中最常用的回调方法，窗体、控件的很多事件，如单击事件、关闭事件等都是采用了TnotifyEvent。回调方法的变量一般通过事件属性的方式来定义，如TCustomForm的创建事件的定义：

property OnCreate: TNotifyEvent read FOnCreate write FOnCreate stored IsForm;

我们通过给事件属性变量赋值就可以定制事件处理器。

用户定义对象（包含回调方法的对象）：

type TCallback=Class
    procedure ClickFunc(sender:TObject);
end;
procedure Tcallback.ClickFunc(sender:TObject);
begin
  showmessage('the caller is clicked!');
end;

窗体对象：

type TCustomFrm=class(TForm)
  public
	procedure RegisterClickFunc(cb:procedure(sender:Tobject) of object);
end;

procedure TcustomFrm..RegisterClickFunc(cb:TNotifyEvent);
begin
  self.OnClick=cb;
end;

使用方法：

var
  frm:TcustomFrm;
begin
  frm:=TcustomFrm.Create(Application);
  frm.RegisterClickFunc(Tcallback.Create().ClickFunc);
end;

3 回调在分布式计算中的应用（CORBA）

3.1 回调接口模型
CORBA的消息传递机制有很多种，比如回调接口、事件服务和通知服务等。回调接口的原理很简单，CORBA客户和服务器都具有双重角色，即充当服务器也是客户客户。

回调接口的反向调用与正向调用往往是同时进行的，如果服务端多次调用该回调接口，那么这个回调接口就变成异步接口了。因此，回调接口在CORBA中常常充当事件注册的用途，客户端调用该注册函数时，客户函数就是回调函数，在此后的调用中，由于不需要客户端的主动参与，该函数就是实现了一种异步机制。

从CORBA规范我们知道，一个CORBA接口在服务端和客户端有不同的表现形式，在客户端一般使用桩（Stub）文件，服务端则用到框架（Skeleton）文件，接口的规格采用IDL来定义。而回调函数的引入，使得服务端和客户端都需要实现一定的桩和框架。下面是回调接口的实现模型：

3.1.1 范例

下面给出了一个使用回调的接口文件，服务端需要实现Server接口的框架，客户端需要实现CallBack的框架：

module cb
{
	interface CallBack;
	interface Server;

interface CallBack 
{
    	void OnEvent(in long Source,in long msg);
};
  	interface Server 
{
    	long RegisterCB(in CallBack cb);
		void UnRegisterCB(in long hCb);
};
};

客户端首先通过同步方式调用服务端的接口RegistCB，用来注册回调接口CallBack。服务端收到该请求以后，就会保留该接口引用，如果发生某种事件需要向客户端通知的时候就通过该引用调用客户方的OnEvent函数，以便对方及时处理。  

from gushizuozhe

load data infile "zuozhe.txt" into table gushizuozhe fields optionally enclosed by '\"' terminated by

',' (ID,name,zi,hao);

grant select on *.* to "public@192.168.%" identified by 'public';

revoke select on *.* from "public@192.168.%"
revoke 并不能删除用户，delete from mysql.user where user like "public%"

flush flush_option[,flush_option]

kill thread_id   unix/linux下进行
show processlist
select user()

set password for www@localhost=password("www")

set option_setting

写锁、读锁
lock tables gushi write,gushizuozhe write;
unlock tables

MYSQL编程接口
MYSQL C API
1、数据类型
1)my_ulonglong
2)my_bool
3)MYSQL_FIELD_OFFSET
4)MYSQL
5)MYSQL_RES
6)MYSQL_ROW
7)MYSQL_FIELD
{
char *name;
char *table;
char *def;
enum enum_field_types type;//列的数据类型
unsigned int length;//列定义的长度
unsigned int max_length;//数据实际的最大长度
unsigned int flags;//列的属性
}
8)unsigned int decimals//小数位数

2、函数
1)my_bool mysql_change_user(MYSQL *mysql,const char *user,const char *password,const char *db)
2)void mysql_close(MYSQL *mysql)
3)MYSQL *mysql_init(MYSQL *mysql)
4)int mysql_option(MYSQL *mysql,enum mysql_option,const char *arg)指定更精确的连接参数选项
5)int mysql_ping(MYSQL *mysql)//检查连接是否正常
6)MYSQL *mysql_real_connect(MYSQL *mysql,const char *host,const char *user,const char *password,const

char *db,unsiged int port,const char *unix_socket,unsigned int client_flag)
7)int mysql_select_db(MYSQL *mysql,const char *db)//选择数据库db为当前数据库
8)int mysql_query(MYSQL *mysql,const char *query)
9)int mysql_real_query(MYSQL *mysql,const char *query,unsigned int length)
10)char *mysql_info(MYSQL *mysql)//返回最后执行的一次操作的有关信息。
11)MYSQL_RES *mysql_store_result(MYSQL *mysql)//读取一个查询的全部结果。
12)MYSQL_RES *mysql_use_result(MYSQL *mysql)//初始化一个结果集，但是不把结果读到客户端，仍然保留在服务器

上
13)void mysql_free_result(MYSQL_RES *result)//释放结果集使用的内存。
14)my_ulonglong mysql_affected_rows(MYSQL *mysql)//返回最后一个update,delete,insert操作影响的记录数。
15)my_ulonglong mysql_num_rows(MYSQL *mysql)//mysql_store_result()返回的结果集中的记录数。
16)MYSQL_ROW_OFFSET mysql_row_seek(MYSQL_RES *result,MYSQL_ROW_OFFSET offset)
17)MYSQL_ROW_OFFSET mysql_row_tell(MYSQL_RES *result)//当前光标位置
18)MYSQL_ROW_OFFSET mysql_data_seek(MYSQL_RES *result,unsigned long long offset)
19)MYSQL_ROW mysql_fetch_row(MYSQL_RES *result)//结果集中的下一条记录
20)unsigned int mysql_fetch_lengths(MYSQL_RES *result)//结果集中当前记录的长度
21)unsigned int mysql_num_fields(MYSQL_RES *result)//结果集中列的数目
22)MYSQL_FIELD_OFFSET mysql_field_seek(MYSQL_RES *result,MYSQL_FIELD_OFFSET offset)
23)MYSQL_FIELD_OFFSET mysql_field_tell(MYSQL_RES *result)//当前光标位置
24)MYSQL_FIELD *mysql_fetch_field(MYSQL_RES *result)//结果集中当前列信息
25)MYSQL_FIELD *mysql_fetch_fields(MYSQL_RES *result)//结果集中所有列信息
26)MYSQL_RES *mysql_list_dbs(MYSQL *mysql,const char *wild)//与wild正则表达式匹配的数据库信息
27)MYSQL_RES *mysql_list_tables(MYSQL *mysql,const char *wild)//与wild正则表达式匹配的表信息
28)MYSQL_RES *mysql_list_fields(MYSQL *mysql,const char * table,const char *wild)//与当前表，匹配wild正

则表达式的所有列名的结果集
29)MYSQL_RES *mysql_list_processes(MYSQL *mysql)
30)char *mysql_stat(MYSQL *mysql)//当前服务器的信息
31)char *mysql_get_server_info(MYSQL *mysql)
32)char *mysql_get_client_info(MYSQL *mysql)
33)char *mysql_get_host_info(MYSQL *mysql)
34)char *mysql_get_proto_info(MYSQL *mysql)
35)unsiged long mysql_thread_id(MYSQL *mysql)
36)int mysql_kill(MYSQL *mysql,unsiged long pid)
37)int mysql_shutdown(MYSQL *mysql)
38)void mysql_debug(char *debug)
39)int mysql_dump_debug_info(char *debug)
40)unsigned int mysql_errno(MYSQL *mysql)
41)char *mysql_error(MYSQL *mysql)

得到工具栏尺寸
CSize sizeBar;
CToolBar m_wndToolBar;
m_wndToolBar.GetToolBarCtrl().GetMaxSize(&sizeBar);

在工具栏上添加编辑框 
CRect rect;
m_wndToolBar.SetButtonInfo(9,ID_SEPARATOR,TBBS_SEPARATOR,100);
m_wndToolBar.GetItemRect(9,&rect);

m_wndComboBox.Create(CBS_DROPDOWN|WS_VISIBLE|WS_VSCROLL|CBS_AUTOHSCROLL,rect, &m_wndToolBar,105);

格式化一段源代码
Alt+F8

定位预处理#if，#endif
Ctrl+K

顶层窗口的实现
在PreCreateWindow()中加入
cs.dwExStyle=WS_EX_TOPMOST