vc 知识总结

－）. 下面是常见的Afx全局函数： AfxFormatString1：类似printf一般地将字符串格式化 AfxFormatString2：类似printf一般地将字符串格式化 AfxMessageBox：类似Windows API 函数 MessageBox AfxOuputDebugString：将字符串输往除错装置 AfxGetApp：获得application object (CwinApp派生对象)的指针 AfxGetMainWnd：获得程序主窗口的指针 AfxGetInstance：获得程序的instance handle （二）. CString 与char []之间的转换. 在VC中，恐怕这两个是经常要进行转换的吧 char str[10] = ”str”; CString sstr = “sstr”; sstr.Format(“%s”,str); strcpy(str,(LPCTSTR)sstr); （三）. 关闭程序: PostQuitMessage(WM_CLOSE); 或者PostQuitMessage(WM_DESTROY); 更绝的是关闭所有的程序：::ExitWindows (); （四）. 在关闭窗口时，当要对文件进行保存时，可在这里添加函数： 1.）在CMainFrame里的OnClose（）里，用MessageBox("内容","标题",组合形式);组合形式可以查看MSDN的MESSAGEBOX( ) Function 2.）在CXXXDoc::SaveModified() 里，只能用AfxMessageBox(""); 不能用MessageBox（）函数 （五）. 如何修改窗体的标题： 1.）修改主窗口的标题：m_pMainWnd->SetWindowText("你的标题"); 2.）如果在你的document.中进行改，则直接调用SetTitle("...")，如果在你的view类中改，则Getdocument.)->SetTitle("...") 3.）如果想使窗口的标题全部替换，则用：AfxGetMainWnd()->SetWindowText("你的标题"); (六）. 得到窗体的标题： 1.）AfxGetMainWnd()->GetWindowText(); 2.）先FindWindow()找到窗口的HWND,在GetWindowText(); （七）. 在多文档/视图中： 1.）子窗口的最大化：       void CChildFrame::ActivateFrame(int nCmdShow)       {         // TODO: Add your specialized code here and/or call the base class         nCmdShow=SW_MAXIMIZE;         CMDIChildWnd::ActivateFrame(nCmdShow);       } 2.）屏蔽子对话框：在APP类里把这两句话屏蔽掉       if (!ProcessShellCommand(cmdInfo))         return FALSE; 3.）关闭子窗口： ::SendMessage(::AfxGetMainWnd()->m_hWnd, WM_COMMAND,ID_FILE_CLOSE,0); （八）. 在装进自定义的光标后，在移动的过程中，鼠标的形状总是在自定义和默认的光标之间晃动，可以这样解决，在视中的PreCreateWindow（）中加入如下几句： BOOL CXXXXView::PreCreateWindow(CREATESTRUCT& cs) {        // TODO: Modify the Window class or styles here by modifying        // the CREATESTRUCT cs       cs.lpszClass =AfxRegisterWndClass(CS_HREDRAW|CS_VREDRAW,0,                    (HBRUSH)::GetStockObject (WHITE_BRUSH),0);        return CView::PreCreateWindow(cs); } （九）. 怎样禁止改变窗口的大小和不能移动的窗口：          再 CMainFrame的OnCreate函数中加入：          CMenu *pTopMenu=GetSystemMenu(false);          pTopMenu->RemoveMenu(4,MF_BYPOSITION);//最大化窗口不可用        pTopMenu->RemoveMenu(2,MF_BYPOSITION);//size        pTopMenu->RemoveMenu(1,MF_BYPOSITION);//使不可移动 （十）.使窗口始终在最前方： 只要在App类中的InitInstance()函数中加入以下代码就可以了: BOOL CwindowOnTopApp:: InitInstance() {    //此处略去了VC自动生成的代码    m_pMainWnd->showWindow(SW_SHOW);    m_pMainWnd->UpdateWindow();    m_pMainWnd->SetWindowPos(&CWnd::WndTopMost,0,0,0,0, SWP_NOMOVE|SWP_NOSIZE|SWP_NOACTIVATE);       Return true; }

图片处理
1. 在按钮上贴图
HINSTANCE hinstance；
   hInstance=::AfxGetInstanceHandle();//获得当前的应用程序实例句柄
HBITMAP hbitmap;
hBitmap =::LoadBitmap(hInstance,"IDB_MP3");//导入位图

m_BtMp3.SetBitmap(hBitmap);//把图片贴在按钮上
注释：位图IDB_MP3在资源文件中要打双引号
2.使图片和按钮或者对话框一样大
   // CDialog::OnPaint();
   CPaintDC dc(this);
        CRect rect;
        GetClientRect(&rect);//得到窗体的大小
        CDC dcMem;
        dcMem.CreateCompatibleDC(&dc); //创建设备
        CBitmap bmpBackground;
        bmpBackground.LoadBitmap(IDB_GROUPBACK);//加载背景图片
        BITMAP bitMap;
        bmpBackground.GetBitmap(&bitMap);
        CBitmap *pbmpOld=dcMem.SelectObject(&bmpBackground);
        dc.StretchBlt(0,0,rect.Width(),rect.Height(),&dcMem,0,0,bitMap.bmWidth,bitMap.bmHeight,SRCCOPY);//画窗体
注释：IDB_GROUPBACK为位图图片导入资源文件中
3.如果要把对话框的TOOLBAR去掉的话在初始化那里加入
ModifyStyle(WS_CAPTION,WS_MINIMIZEBOX,SWP_DRAWFRAME);

4.显示动态图片
先把动态图片.gif导入到资源文件里面去再图片一个图片控件定义变量为CPictureEx m_Flag;
//显示动态GIF图像logo
if(m_Flag.Load(MAKEINTRESOURCE(IDR_FLAG),_T("GIF")))
{
   m_Flag.SetBkColor(RGB(160,180,220));
   m_Flag.Draw();
}
定义一个类为CPictureEx
二.创建浮动的弹出式菜单
1。用菜单编辑器在工程的资源文件中插入一个新的空菜单
2。在左边的顶部输入一些字符，然后在所得到的弹出式菜单里加入单项
3。用CLASSWIZARD在视图类或其他接收鼠标右键单击的窗口类加入WM_Contextmenu消息控件函数
void CMyView::OnContextMenu(CWnd *pWnd, CPoint point)
{
CMenu menu;
menu.LoadMenu(IDR_MYELOATINGMENU);
menu.GetSubMenu(0)->TrackPopupMenu(TPM_LEFTALIGN|TPM_RIGHTBUTTON,point.x,point.y,this);
}

三如何打开文件
以浏览方式打开文件
例如：用CString strDir = BrowseForFolder(m_hWnd, "Select a directory:", BIF_RETURNONLYFSDIRS);调用下面这个函数
CString BrowseForFolder(HWND hWnd, LPCSTR lpszTitle, UINT nFlags)
{
// We're going to use the shell to display a
// "Choose Directory" dialog box for the user.
CString strResult = "";

LPMALLOC lpMalloc;

if (::SHGetMalloc(&lpMalloc) != NOERROR)
{
   // failed to get allocator
   return strResult;
}

char szBuffer[_MAX_PATH];
char szDisplayName[_MAX_PATH];

BROWSEINFO browseInfo;
browseInfo.hwndOwner = hWnd;
// set root at Desktop
browseInfo.pidlRoot = NULL;
browseInfo.pszDisplayName = szDisplayName;
browseInfo.lpszTitle = lpszTitle;
browseInfo.ulFlags = nFlags;
browseInfo.lpfn = NULL;
browseInfo.lParam = 0;

LPITEMIDLIST lpItemIDList;

if ((lpItemIDList = ::SHBrowseForFolder(&browseInfo)) != NULL)
{
   // Get the path of the selected folder from the item ID list.
   if (::SHGetPathFromIDList(lpItemIDList, szBuffer))
   {
    // At this point, szBuffer contains the path the user chose.
    if (szBuffer[0] == '/0')
    {
     // SHGetPathFromIDList failed, or SHBrowseForFolder failed.
     AfxMessageBox("Failed to get directory", MB_ICONSTOP|MB_OK);
     return strResult;
    }
    
    // We have a path in szBuffer!
    strResult = szBuffer;
    return strResult;
   }
   else
   {
    // The thing referred to by lpItemIDList
    // might not have been a file system object.
    // For whatever reason, SHGetPathFromIDList didn't work!
    AfxMessageBox("Failed to get directory", MB_ICONSTOP|MB_OK);
    return strResult; // strResult is empty
   }
   lpMalloc->Free(lpItemIDList);
   lpMalloc->Release();     
}
return strResult;
}

2。以对话框方式打开文本框
例如：
void CExam::OnFileFileopen()
{
char* szFilter="Text Files(*.txt)|*.txt|All Files(*.*)|*.*||";
CFileDialog dlg(TRUE,"txt",TEXT("Readme.txt"),OFN_HIDEREADONLY|OFN_OVERWRITEPROMPT,szFilter);
dlg.DoModal();
fileName=dlg.GetFileName();//返回选定文件的文件名字GetNextPathName是返回下一个选定文件的完整路径
        //GetPathName是返回选定文件的完整的路径
Invalidate();
}

三〉显示多文档编成让多文档文件变为显示器一样大可以用
把pMainFrame->ShowWindow(m_nCmdShow);改为
pMainFrame->ShowWindow(SW_SHOWMAXIMIZED);让子窗体变成和主窗体一样大可以在调用的时候设置
例如：设置主窗体的 类为CRaChildFrame

if(m_pMade!=NULL)
{
   m_pMade->MDIActivate();
   return;
}

m_pMade=new CRaChildFrame();
CCreateContext context;
context.m_pNewViewClass=RUNTIME_CLASS(CMadeCertView);
if(!m_pMade->LoadFrame(IDI_ICON5,WS_MAXIMIZE|WS_OVERLAPPEDWINDOW,this,&context))
   return;
m_pMade->ShowWindow(SW_SHOWMAXIMIZED);
m_pMade->InitialUpdateFrame(NULL,true);

2。让控件和窗体一样大的话可以用SetWindowPos设置大小:
例如:下面这个主要是以分辨率为1024*768为显示 下面这个是列表控件设置变量为:m_List
     m_List.SetWindowPos(NULL,0,0,1024,600,SWP_NOMOVE|SWP_NOZORDER | SWP_NOACTIVATE);
四。如何通过代码获得应用程序主窗口的指针?
主窗口的 指针保存在CWinThread::m_pMainWnd中,调用 AfxGetMainWnd实现。
AfxGetMainWnd() ->ShowWindow(SW_SHOWMAXMIZED); //使程序最大化.

//初始置窗体位于最顶层
SetWindowPos(&wndTopMost, 0, 0, 0, 0, SWP_NOMOVE | SWP_NOSIZE);

四 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。例如：

＃i nclude
#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;
}
方法二，使用_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);

一。文件的查找

在实际应用，经常要用到文件的查找，在WINDOWS 系统中，系统提供了相关的API 函数，
1． FindFirstFile(),它有两个参数，第一个是要查找的文件名，第二个是保存查找到的信息，类型为WIN32_FIND_DAT，返回一个句柄。
2． FindNextFile(),继续查找。
3． FindClose(),关闭查找。

程序的实现：

{
UpdateData();
if(!m_strfile.GetLength())
{
AfxMessageBox("请输入要查找的文件");
return ;
}
WIN32_FIND_DATA fd;
m_listfile.ResetContent();//m_listfile 用来保存查找结果
HANDLE hd=::FindFirstFile((LPCTSTR)m_strfile,&fd);//开始查找
if(hd==INVALID_HANDLE_VALUE)
{return;}
m_listfile.AddString(fd.cFileName);
while(FindNextFile(hd,&fd)) //继续查找
{
m_listfile.AddString(fd.cFileName);
};
FindClose(hd);//关闭查找
}

五.视频函数显示BMP位图

　　用普通方法显示BMP位图，占内存大，速度慢，在图形缩小时，失真严重,在低颜色位数的设备上显示高颜色位数的图形图形时失真大。本文采用视频函数显示BMP位图，可以消除以上的缺点。

---- 一、BMP文件结构

---- 1. BMP文件组成

---- BMP文件由文件头、位图信息头、颜色信息和图形数据四部分组成。

---- 2. BMP文件头 ---- BMP文件头数据结构含有BMP文件的类型、文件大小和位图起始位置等信息。 ---- 其结构定义如下:

typedef struct tagBITMAPFILEHEADER {

WORDbfType; // 位图文件的类型，必须为BM

DWORD bfSize; // 位图文件的大小，以字节为单位

WORDbfReserved1; // 位图文件保留字，必须为0

WORDbfReserved2; // 位图文件保留字，必须为0

DWORD bfOffBits; // 位图数据的起始位置，以相对于位图

// 文件头的偏移量表示，以字节为单位 } BITMAPFILEHEADER;

---- 3. 位图信息头

---- BMP位图信息头数据用于说明位图的尺寸等信息。

typedef struct tagBITMAPINFOHEADER{ DWORD biSize; // 本结构所占用字节数

LONGbiWidth; // 位图的宽度，以像素为单位

LONGbiHeight; // 位图的高度，以像素为单位

WORD biPlanes; // 目标设备的级别，必须为1

WORD biBitCount// 每个像素所需的位数，必须是1(双色),

// 4(16色)，8(256色)或24(真彩色)之一

DWORD biCompression; // 位图压缩类型，必须是 0(不压缩),

// 1(BI_RLE8压缩类型)或2(BI_RLE4压缩类型)之一

DWORD biSizeImage; // 位图的大小，以字节为单位

LONGbiXPelsPerMeter; // 位图水平分辨率，每米像素数

LONGbiYPelsPerMeter; // 位图垂直分辨率，每米像素数

DWORD biClrUsed;// 位图实际使用的颜色表中的颜色数

DWORD biClrImportant;// 位图显示过程中重要的颜色数 } BITMAPINFOHEADER;

---- 4. 颜色表

---- 颜色表用于说明位图中的颜色，它有若干个表项，每一个表项是一个RGBQUAD类型的结构，定义一种颜色。RGBQUAD结构的定义如下: typedef struct tagRGBQUAD { BYTErgbBlue;// 蓝色的亮度(值范围为0-255)

BYTErgbGreen; // 绿色的亮度(值范围为0-255)

BYTErgbRed; // 红色的亮度(值范围为0-255)

BYTErgbReserved;// 保留，必须为0 } RGBQUAD;

颜色表中RGBQUAD结构数据的个数有biBitCount来确定: 当biBitCount=1,4,8时，分别有2,16,256个表项; 当biBitCount=24时，没有颜色表项。 位图信息头和颜色表组成位图信息，BITMAPINFO结构定义如下:

　　typedef struct tagBITMAPINFO { BITMAPINFOHEADER bmiHeader; // 位图信息头

RGBQUAD bmiColors[1]; // 颜色表 } BITMAPINFO;

---- 5. 位图数据

---- 位图数据记录了位图的每一个像素值，记录顺序是在扫描行内是从左到右,扫描行之间是从下到上。位图的一个像素值所占的字节数: 当biBitCount=1时，8个像素占1个字节; 当biBitCount=4时，2个像素占1个字节; 当biBitCount=8时，1个像素占1个字节; 当biBitCount=24时,1个像素占3个字节; Windows规定一个扫描行所占的字节数必须是 4的倍数(即以long为单位),不足的以0填充， 一个扫描行所占的字节数计算方法:

DataSizePerLine= (biWidth* biBitCount+31)/8; // 一个扫描行所占的字节数

DataSizePerLine= DataSizePerLine/4*4; // 字节数必须是4的倍数 位图数据的大小(不压缩情况下): DataSize= DataSizePerLine* biHeight;

---- 二、BMP位图一般显示方法

---- 1. 申请内存空间用于存放位图文件

---- GlobalAlloc(GHND，FileLength);

---- 2. 位图文件读入所申请内存空间中

---- LoadFileToMemory( mpBitsSrc，mFileName);

---- 3. 在OnPaint等函数中用创建显示用位图

---- 用CreateDIBitmap()创建显示用位图，用CreateCompatibleDC()创建兼容DC,

---- 用SelectBitmap()选择显示位图。

---- 4. 用BitBlt或StretchBlt等函数显示位图

---- 5. 用DeleteObject()删除所创建的位图

---- 以上方法的缺点是: 1)显示速度慢; 2) 内存占用大; 3) 位图在缩小显示时图形失真大,(可通过安装字体平滑软件来解决); 4) 在低颜色位数的设备上(如256显示模式)显示高颜色位数的图形(如真彩色)图形失真严重。

---- 三、BMP位图缩放显示

---- 用DrawDib视频函数来显示位图，内存占用少，速度快，而且还可以对图形进行淡化(Dithering)处理。淡化处理是一种图形算法，可以用来在一个支持比图像所用颜色要少的设备上显示彩色图像。BMP位图显示方法如下:

---- 1. 打开视频函数DrawDibOpen()，一般放在在构造函数中

---- 2. 申请内存空间用于存放位图文件

---- GlobalAlloc(GHND，FileLength);

---- 3. 位图文件读入所申请内存空间中

---- LoadFileToMemory( mpBitsSrc，mFileName);

---- 4. 在OnPaint等函数中用DrawDibRealize()，DrawDibDraw()显示位图

---- 5. 关闭视频函数DrawDibClose(),一般放在在析构函数中

---- 以上方法的优点是: 1)显示速度快; 2) 内存占用少; 3) 缩放显示时图形失真小,4) 在低颜色位数的设备上显示高颜色位数的图形图形时失真小; 5) 通过直接处理位图数据，可以制作简单动画。

---- 四、CViewBimap类编程要点

---- 1. 在CViewBimap类中添加视频函数等成员

HDRAWDIB m_hDrawDib; // 视频函数

HANDLEmhBitsSrc; // 位图文件句柄(内存)

LPSTR mpBitsSrc; // 位图文件地址(内存)

BITMAPINFOHEADER *mpBitmapInfo; // 位图信息头

---- 2. 在CViewBimap类构造函数中添加打开视频函数

---- m_hDrawDib= DrawDibOpen();

---- 3. 在CViewBimap类析构函数中添加关闭视频函数

if( m_hDrawDib != NULL) { DrawDibClose( m_hDrawDib); m_hDrawDib = NULL; }

---- 4. 在CViewBimap类图形显示函数OnPaint中添加GraphicDraw() voidCViewBitmap::OnPaint() { CPaintDC dc(this); // device context for painting GraphicDraw( ); } voidCViewBitmap::GraphicDraw( void ) { CClientDC dc(this); // device context for painting BITMAPFILEHEADER *pBitmapFileHeader;

ULONG bfoffBits= 0;

Cpoint Wid; // 图形文件名有效 (=0 BMP)

if( mBitmapFileType < ID_BITMAP_BMP ) return; // 图形文件名有效 (=0 BMP)

// 准备显示真彩位图

pBitmapFileHeader= (BITMAPFILEHEADER *) mpBitsSrc;

bfoffBits= pBitmapFileHeader->bfOffBits; // 使用普通函数显示位图

if( m_hDrawDib == NULL || mDispMethod == 0) { HBITMAP hBitmap=::CreateDIBitmap(dc.m_hDC, mpBitmapInfo, CBM_INIT, mpBitsSrc+bfoffBits, (LPBITMAPINFO) mpBitmapInfo,DIB_RGB_COLORS); // 建立位图 HDC

hMemDC=::CreateCompatibleDC(dc.m_hDC);// 建立内存 HBITMAP

hBitmapOld= SelectBitmap(hMemDC, hBitmap); // 选择对象

// 成员Crect mDispR用于指示图形显示区域的大小.

// 成员Cpoint mPos用于指示图形显示起始位置坐标.

if( mPos.x > (mpBitmapInfo- >biWidth - mDispR.Width() ))

mPos.x= mpBitmapInfo->biWidth - mDispR.Width() ;

if( mPos.y > (mpBitmapInfo- >biHeight- mDispR.Height()))

mPos.y= mpBitmapInfo- >biHeight- mDispR.H

eight();

if( mPos.x < 0 ) mPos.x= 0;

if( mPos.y < 0 ) mPos.y= 0;

if( mFullViewTog == 0) { // 显示真彩位图 ::BitBlt(dc.m_hDC,0,0, mDispR.Width(), mDispR.Height(), hMemDC,mPos.x,mPos.y, SRCCOPY); }

else { ::StretchBlt(dc.m_hDC,0,0, mDispR.Width(), mDispR.Height(), hMemDC,0,0, mpBitmapInfo- >biWidth, mpBitmapInfo- >biHeight, SRCCOPY); }

// 结束显示真彩位图

视频流
typedef struct
{
　FOURCC fccType; //4字节，表示数据流的种类 vids 表示视频数据流
　//auds 音频数据流
　FOURCC fccHandler;//4字节 ，表示数据流解压缩的驱动程序代号
　DWORD dwFlags; //数据流属性
　WORD wPriority; //此数据流的播放优先级
　WORD wLanguage; //音频的语言代号
　DWORD dwInitalFrames;//说明在开始播放前需要多少桢
　DWORD dwScale; //数据量，视频每桢的大小或者音频的采样大小
　DWORD dwRate; //dwScale /dwRate = 每秒的采样数
　DWORD dwStart; //数据流开始播放的位置，以dwScale为单位
　DWORD dwLength; //数据流的数据量，以dwScale为单位
　DWORD dwSuggestedBufferSize; //建议缓冲区的大小
　DWORD dwQuality; //解压缩质量参数，值越大，质量越好
　DWORD dwSampleSize; //音频的采样大小
　RECT rcFrame; //视频图像所占的矩形
}AVIStreamHeader;

五.在普通类中调用本程序中的MFC窗体类的成员函数可以用以下方法:
        //获取应用程序主窗口
CServerPlusDlg* pDlg=(CServerPlusDlg*)::AfxGetMainWnd();[假设CServerPlusDlg为MFC窗体类]

六.在函数前面加static有什么用？函数体的后面加上const又是什么意思？？

1.在成员函数身上加上const是告诉编译器这个成员函数不允许修改  
对象本身的内容。  
class   test   {  
public:  
int   ss()   const   {t   =   100};   //错误，编译不通过，因为它修改了对象本身成员t的值。  
private:  
int   t;  
};  
static指的是静态函数，不需要生成对象就可直接调用（在实例化后只会生成一次）。  
class   myclass{  
public:  
static   int   test()   {   return   100};  
};  
   
int   ss;  
ss   =   myclass::test();  
2.函数后面加const 表函数内部不能改变成员变量的值...  
这是把整个函数修饰为const，意思是“函数体内不能对成员数据做任何改动”。如果你声明这个类的一个const实例，那么它就只能调用有const修饰的
加static   是标明此函数为静态函数,即此函数只能在本文件中使用
就是说不用实例化也可以使用的这个类的成员变量或者方法
向对象是C++的重要特性.
但是c++在c的基础上新增加的几点优化也是很耀眼的

就const直接可以取代c中的#define

以下几点很重要,学不好后果也也很严重

const
1. 限定符声明变量只能被读
     const int i=5;
     int j=0;
     ...
     i=j;     //非法，导致编译错误
     j=i;     //合法
2. 必须初始化
     const int i=5;      //合法
     const int j;        //非法，导致编译错误
3. 在另一连接文件中引用const常量
     extern const int i;       //合法
     extern const int j=10;    //非法，常量不可以被再次赋值
4. 便于进行类型检查
     用const方法可以使编译器对处理内容有更多了解。
     #define I=10
     const long &i=10;     /*dapingguo提醒：由于编译器的优化，使
        得在const long i=10; 时i不被分配内存，而是已10直接代入
        以后的引用中，以致在以后的代码中没有错误，为达到说教效
        果，特别地用&i明确地给出了i的内存分配。不过一旦你关闭所
        有优化措施，即使const long i=10;也会引起后面的编译错误。*/
     char h=I;        //没有错
     char h=i;        //编译警告，可能由于数的截短带来错误赋值。
5. 可以避免不必要的内存分配
     #define STRING "abcdefghijklmn/n"
     const char string[]="abcdefghijklm/n";
     ...
     printf(STRING);     //为STRING分配了第一次内存
     printf(string);     //为string一次分配了内存，以后不再分配
     ...
     printf(STRING);     //为STRING分配了第二次内存
     printf(string);
     ...
     由于const定义常量从汇编的角度来看，只是给出了对应的内存地址，
     而不是象#define一样给出的是立即数，所以，const定义的常量在
     程序运行过程中只有一份拷贝，而#define定义的常量在内存中有
     若干个拷贝。
6. 可以通过函数对常量进行初始化
     int value();
     const int i=value();
     dapingguo说：假定对ROM编写程序时，由于目标代码的不可改写，
     本语句将会无效，不过可以变通一下：
     const int &i=value();
     只要令i的地址处于ROM之外，即可实现：i通过函数初始化，而其
     值有不会被修改。
7. 是不是const的常量值一定不可以被修改呢？
     观察以下一段代码：
     const int i=0;
     int *p=(int*)&i;
     p=100;
     通过强制类型转换，将地址赋给变量，再作修改即可以改变const常量值。
8. 请分清数值常量和指针常量，以下声明颇为玩味：
     int ii=0;
     const int i=0;              //i是常量，i的值不会被修改
     const int *p1i=&i;          //指针p1i所指内容是常量，可以不初始化
     int    * const p2i=&ii;       //指针p2i是常量，所指内容可修改
     const int * const p3i=&i; //指针p3i是常量，所指内容也是常量
     p1i=&ii;                    //合法
     *p2i=100;                   //合法

关于C++中的const关键字的用法非常灵活，而使用const将大大改善程序的健壮性，参考了康建东兄的const使用详解一文，对其中进行了一些补充，写下了本文。

1. const常量，如const int max = 100;
优点：const常量有数据类型，而宏常量没有数据类型。编译器可以对前者进行类型安全检查，而对后者只进行字符替换，没有类型安全检查，并且在字符替换时可能会产生意料不到的错误（边际效应）

2.const 修饰类的数据成员。如：
class A
{
      const int size;

      …
}

const数据成员只在某个对象生存期内是常量，而对于整个类而言却是可变的。因为类可以创建多个对象，不同的对象其const数据成员的值可以不同。所以不能在类声明中初始化const数据成员，因为类的对象未被创建时，编译器不知道const 数据成员的值是什么。如

class A
{
const int size = 100;      //错误

int array[size];           //错误，未知的size

}

const数据成员的初始化只能在类的构造函数的初始化表中进行。要想建立在整个类中都恒定的常量，应该用类中的枚举常量来实现。如

class A

{…

enum {size1=100, size2 = 200 };

int array1[size1];

int array2[size2];

}

枚举常量不会占用对象的存储空间，他们在编译时被全部求值。但是枚举常量的隐含数据类型是整数，其最大值有限，且不能表示浮点数。

3.const修饰指针的情况，见下式：

int b = 500;
const int* a = &             [1]
int const *a = &             [2]
int* const a = &             [3]
const int* const a = &       [4]

如果你能区分出上述四种情况，那么，恭喜你，你已经迈出了可喜的一步。不知道，也没关系，我们可以参考《Effective c++》Item21上的做法，如果const位于星号的左侧，则const就是用来修饰指针所指向的变量，即指针指向为常量；如果const位于星号的右侧，const就是修饰指针本身，即指针本身是常量。因此，[1]和[2]的情况相同，都是指针所指向的内容为常量（const放在变量声明符的位置无关），这种情况下不允许对内容进行更改操作，如不能*a = 3 ；[3]为指针本身是常量，而指针所指向的内容不是常量，这种情况下不能对指针本身进行更改操作，如a++是错误的；[4]为指针本身和指向的内容均为常量。

4.const的初始化

先看一下const变量初始化的情况
1) 非指针const常量初始化的情况：A b;
const A a = b;

2) 指针const常量初始化的情况：

A* d = new A();
const A* c = d;
或者：const A* c = new A();
3）引用const常量初始化的情况：
A f;
const A& e = f;        // 这样作e只能访问声明为const的函数，而不能访问一           

般的成员函数；

      [思考1]： 以下的这种赋值方法正确吗？
      const A* c=new A();
      A* e = c;
      [思考2]： 以下的这种赋值方法正确吗？
      A* const c = new A();
      A* b = c;

5.       另外const 的一些强大的功能在于它在函数声明中的应用。在一个函数声明中，const 可以修饰函数的返回值，或某个参数；对于成员函数，还可以修饰是整个函数。有如下几种情况，以下会逐渐的说明用法：A& operator=(const A& a);
void fun0(const A* a );
void fun1( ) const; // fun1( ) 为类成员函数
const A fun2( );

1） 修饰参数的const，如 void fun0(const A* a ); void fun1(const A& a);
调用函数的时候，用相应的变量初始化const常量，则在函数体中，按照const所修饰的部分进行常量化，如形参为const A* a，则不能对传递进来的指针的内容进行改变，保护了原指针所指向的内容；如形参为const A& a，则不能对传递进来的引用对象进行改变，保护了原对象的属性。
[注意]：参数const通常用于参数为指针或引用的情况，且只能修饰输入参数;若输入参数采用“值传递”方式，由于函数将自动产生临时变量用于复制该参数，该参数本就不需要保护，所以不用const修饰。

[总结]对于非内部数据类型的输入参数，因该将“值传递”的方式改为“const引用传递”，目的是为了提高效率。例如，将void Func(A a)改为void Func(const A &a)

        对于内部数据类型的输入参数，不要将“值传递”的方式改为“const引用传递”。否则既达不到提高效率的目的，又降低了函数的可理解性。例如void Func(int x)不应该改为void Func(const int &x)

2）修饰返回值的const，如const A fun2( ); const A* fun3( );
这样声明了返回值后，const按照"修饰原则"进行修饰，起到相应的保护作用。const Rational operator*(const Rational& lhs, const Rational& rhs)
{
return Rational(lhs.numerator() * rhs.numerator(),
lhs.denominator() * rhs.denominator());
}

返回值用const修饰可以防止允许这样的操作发生:Rational a,b;
Radional c;
(a*b) = c;

一般用const修饰返回值为对象本身（非引用和指针）的情况多用于二目操作符重载函数并产生新对象的时候。
[总结]

1. 一般情况下，函数的返回值为某个对象时，如果将其声明为const时，多用于操作符的重载。通常，不建议用const修饰函数的返回值类型为某个对象或对某个对象引用的情况。原因如下：如果返回值为某个对象为const（const A test = A 实例）或某个对象的引用为const（const A& test = A实例） ，则返回值具有const属性，则返回实例只能访问类A中的公有（保护）数据成员和const成员函数，并且不允许对其进行赋值操作，这在一般情况下很少用到。

2. 如果给采用“指针传递”方式的函数返回值加const修饰，那么函数返回值（即指针）的内容不能被修改，该返回值只能被赋给加const 修饰的同类型指针。如：

const char * GetString(void);

如下语句将出现编译错误：

char *str=GetString();

正确的用法是：

const char *str=GetString();

3. 函数返回值采用“引用传递”的场合不多，这种方式一般只出现在类的赙值函数中，目的是为了实现链式表达。如：

class A

{…

A &operate = (const A &other);    //负值函数

}
A a,b,c;                //a,b,c为A的对象

…

a=b=c;              //正常

(a=b)=c;            //不正常，但是合法

若负值函数的返回值加const修饰，那么该返回值的内容不允许修改，上例中a=b=c依然正确。(a=b)=c就不正确了。
[思考3]： 这样定义赋值操作符重载函数可以吗？
const A& operator=(const A& a);

6.       类成员函数中const的使用
一般放在函数体后，形如：void fun() const;
任何不会修改数据成员的函数都因该声明为const类型。如果在编写const成员函数时，不慎修改了数据成员，或者调用了其他非const成员函数，编译器将报错，这大大提高了程序的健壮性。如：

class Stack

{

public:
        void Push(int elem);

        int Pop(void);

        int GetCount(void) const;     //const 成员函数

private:

        int m_num;

        int m_data[100];

};

int Stack::GetCount(void) const

{

    ++m_num;                //编译错误，企图修改数据成员m_num

    Pop();                      //编译错误，企图调用非const函数

    Return m_num;

}

7. 使用const的一些建议

1 要大胆的使用const，这将给你带来无尽的益处，但前提是你必须搞清楚原委；
2 要避免最一般的赋值操作错误，如将const变量赋值，具体可见思考题；
3 在参数中使用const应该使用引用或指针，而不是一般的对象实例，原因同上；
4 const在成员函数中的三种用法（参数、返回值、函数）要很好的使用；
5 不要轻易的将函数的返回值类型定为const;
6除了重载操作符外一般不要将返回值类型定为对某个对象的const引用;

[思考题答案]
1 这种方法不正确，因为声明指针的目的是为了对其指向的内容进行改变，而声明的指针e指向的是一个常量，所以不正确；
2 这种方法正确，因为声明指针所指向的内容可变；
3 这种做法不正确；
在const A::operator=(const A& a)中，参数列表中的const的用法正确，而当这样连续赋值的时侯，问题就出现了：
A a,b,c:
(a=b)=c;
因为a.operator=(b)的返回值是对a的const引用，不能再将c赋值给const

六.实现send传送结构体
1.char *或者char数组可以强制转换成const   char*,通常都不会有问题,但反过来,const   char*转换成char *就要当心一点 你可以在结构中定义char型数组,需要const   char*时直接填char数组的指针没有问题
2.是send函数要const   char*吗?在结构体指针前面加一个强制转换就行了  
send(...,(char   *)&m_stru,....)

1.使用CTime类

CString str;
//获取系统时间
CTime tm;
tm=CTime::GetCurrentTime();
str=tm.Format("现在时间是%Y年%m月%d日 %X");
MessageBox(str,NULL,MB_OK);

2: 得到系统时间日期(使用GetLocalTime)

SYSTEMTIME st;
CString strDate,strTime;
GetLocalTime(&st);
strDate.Format("%4d-%2d-%2d",st.wYear,st.wMonth,st.wDay);
strTime.Format("%2d:%2d:%2d",st.wHour,st.wMinute,st.wSecond);

3.使用GetTickCount
//获取程序运行时间
long t1=GetTickCount();//程序段开始前取得系统运行时间(ms)
Sleep(500);
long t2=GetTickCount();();//程序段结束后取得系统运行时间(ms)
str.Format("time:%dms",t2-t1);//前后之差即 程序运行时间
AfxMessageBox(str);
//获取系统运行时间
long t=GetTickCount();
CString str,str1;
str1.Format("系统已运行 %d时",t/3600000);
str=str1;
t%=3600000;
str1.Format("%d分",t/60000);
str+=str1;
t%=60000;
str1.Format("%d秒",t/1000);
str+=str1;
AfxMessageBox(str);