//一、打開CD-ROM

mciSendString("Set cdAudio door open wait",NULL,0,NULL);

//二、關閉CD_ROM

mciSendString("Set cdAudio door closed wait",NULL,0,NULL);

//三、關閉計算機

OSVERSIONINFO OsVersionInfo; //包含操作系統版本信息的數據結構
OsVersionInfo.dwOSVersionInfoSize = sizeof(OSVERSIONINFO);
GetVersionEx(&OsVersionInfo); //獲取操作系統版本信息
if(OsVersionInfo.dwPlatformId == VER_PLATFORM_WIN32_WINDOWS)
{
//Windows98,調用ExitWindowsEx()函數重新啟動計算機
DWORD dwReserved;
ExitWindowsEx(EWX_REBOOT,dwReserved); //可以改變第一個參數，實現注銷用戶、
//關機、關閉電源等操作
// 退出前的一些處理程序
}

//四、重啟計算機

typedef int (CALLBACK *SHUTDOWNDLG)(int); //顯示關機對話框函數的指針
HINSTANCE hInst = LoadLibrary("shell32.dll"); //裝入shell32.dll
SHUTDOWNDLG ShutDownDialog; //指向shell32.dll庫中顯示關機對話框函數的指針
if(hInst != NULL)
{
//獲得函數的地址并調用之
ShutDownDialog = (SHUTDOWNDLG)GetProcAddress(hInst,(LPSTR)60);

(*ShutDownDialog)(0);
}

//五、枚舉所有字體

LOGFONT lf;
lf.lfCharSet = DEFAULT_CHARSET; // Initialize the LOGFONT structure
strcpy(lf.lfFaceName,"");
CClientDC dc (this);
// Enumerate the font families
::EnumFontFamiliesEx((HDC) dc,&lf, (FONTENUMPROC) EnumFontFamProc,(LPARAM) this,0);
//枚舉函數
int CALLBACK EnumFontFamProc(LPENUMLOGFONT lpelf,
LPNEWTEXTMETRIC lpntm,DWORD nFontType,long lparam)

{
// Create a pointer to the dialog window
CDay7Dlg* pWnd = (CDay7Dlg*) lparam;
// add the font name to the list box
pWnd ->m_ctlFontList.AddString(lpelf ->elfLogFont.lfFaceName);
// Return 1 to continue font enumeration
return 1;
}

//其中m_ctlFontList是一個列表控件變量

//六、一次只運行一個程序實例，如果已運行則退出

if( FindWindow(NULL,"程序標題")) exit(0);

//七、得到當前鼠標所在位置

CPoint pt;
GetCursorPos(&pt); //得到位置

//八、上下文菜單事件觸發事件：OnContextMenu事件

//九、顯示和隱藏程序菜單

CWnd *pWnd=AfxGetMainWnd();
if(b_m) //隱藏菜單
{
pWnd->SetMenu(NULL);
pWnd->DrawMenuBar();
b_m=false;
}
else
{
CMenu menu;
menu.LoadMenu(IDR_MAINFRAME); 顯示菜單 也可改變菜單項
pWnd->SetMenu(&menu);
pWnd->DrawMenuBar();
b_m=true;
menu.Detach();
}

//十、獲取可執行文件的圖標

HICON hIcon=::ExtractIcon(AfxGetInstanceHandle(),_T("NotePad.exe"),0);
if (hIcon &&hIcon!=(HICON)-1)
{
pDC->DrawIcon(10,10,hIcon);

}
DestroyIcon(hIcon);

//十一、窗口自動靠邊程序演示

BOOL AdjustPos(CRect* lpRect)
{//自動靠邊
int iSX=GetSystemMetrics(SM_CXFULLSCREEN);
int iSY=GetSystemMetrics(SM_CYFULLSCREEN);
RECT rWorkArea;
BOOL bResult = SystemParametersInfo(SPI_GETWORKAREA, sizeof(RECT), &rWorkAre
a, 0);
CRect rcWA;
if(!bResult)
{//如果調用不成功就利用GetSystemMetrics獲取屏幕面積
rcWA=CRect(0,0,iSX,iSY);
}
else
rcWA=rWorkArea;
int iX=lpRect->left;
int iY=lpRect->top;

if(iX < rcWA.left + DETASTEP && iX!=rcWA.left)
{//調整左
//pWnd->SetWindowPos(NULL,rcWA.left,iY,0,0,SWP_NOSIZE);
lpRect->OffsetRect(rcWA.left-iX,0);
AdjustPos(lpRect);
return TRUE;
}
if(iY < rcWA.top + DETASTEP && iY!=rcWA.top)
{//調整上
//pWnd->SetWindowPos(NULL ,iX,rcWA.top,0,0,SWP_NOSIZE);
lpRect->OffsetRect(0,rcWA.top-iY);
AdjustPos(lpRect);
return TRUE;
}
if(iX + lpRect->Width() > rcWA.right - DETASTEP && iX !=rcWA.right-lpRect->Width())
{//調整右
//pWnd->SetWindowPos(NULL ,rcWA.right-rcW.Width(),iY,0,0,SWP_NOSIZE);
lpRect->OffsetRect(rcWA.right-lpRect->right,0);
AdjustPos(lpRect);
return TRUE;
}
if(iY + lpRect->Height() > rcWA.bottom - DETASTEP && iY !=rcWA.bottom-lpRect
->Height())
{//調整下
//pWnd->SetWindowPos(NULL ,iX,rcWA.bottom-rcW.Height(),0,0,SWP_NOSIZE);
lpRect->OffsetRect(0,rcWA.bottom-lpRect->bottom);
return TRUE;
}
return FALSE;
}
//然后在ONMOVEING事件中使用所下過程調用

CRect r=*pRect;
AdjustPos(&r);
*pRect=(RECT)r;

//十二、給系統菜單添加一個菜單項給系統菜單添加一個菜單項需要進行下述三個步驟：
//首先，使用Resource Symbols對話（在View菜單中選擇Resource Symbols．．．可以顯
//示該對話）定義菜單項ID，該ID應大于0x0F而小于0xF000；
//其次，調用CWnd::GetSystemMenu獲取系統菜單的指針并調用CWnd:: Appendmenu將菜單
//項添加到菜單中。下例給系統菜單添加兩個新的

int CMainFrame:: OnCreate (LPCREATESTRUCT lpCreateStruct)
{
//…
//Make sure system menu item is in the right range.
ASSERT(IDM_MYSYSITEM<0xF000);
//Get pointer to system menu.
CMenu* pSysMenu=GetSystemMenu(FALSE);
ASSERT_VALID(pSysMenu);
//Add a separator and our menu item to system menu.
CString StrMenuItem(_T ("New menu item"));
pSysMenu->AppendMenu(MF_SEPARATOR);
pSysMenu->AppendMenu(MF_STRING, IDM_MYSYSITEM, StrMenuItem);
//…
}

//十三、運行其它程序

//1、運行EMAIL或網址

char szMailAddress[80];
strcpy(szMailAddress,"mailto:netvc@21cn.com");
ShellExecute(NULL, "open", szMailAddress, NULL, NULL, SW_SHOWNORMAL);

//2、運行可執行程序
WinExec("notepad.exe",SW_SHOW); //運行計事本

//十四、動態增加或刪除菜單

//1、 增加菜單
//添加
CMenu *mainmenu;
mainmenu=AfxGetMainWnd()->GetMenu(); //得到主菜單
(mainmenu->GetSubMenu (0))->AppendMenu (MF_SEPARATOR);//添加分隔符
(mainmenu->GetSubMenu (0))->AppendMenu(MF_STRING,ID_APP_ABOUT,
_T("Always on &Top")); //添加新的菜單項
DrawMenuBar(); //重畫菜單
//2、 刪除菜單
//刪除
CMenu *mainmenu;
mainmenu=AfxGetMainWnd()->GetMenu(); //得到主菜單

CString str ;
for(int i=(mainmenu->GetSubMenu (0))->GetMenuItemCount()-1;i>=0;i--) //取得菜單的項數。
{
(mainmenu->GetSubMenu (0))->GetMenuString(i,str,MF_BYPOSITION);
//將指定菜單項的標簽拷貝到指定的緩沖區。MF_BYPOSITION的解釋見上。
if(str=="Always on &Top") //如果是剛才我們增加的菜單項，則刪除。
{
(mainmenu->GetSubMenu (0))->DeleteMenu(i,MF_BYPOSITION);
break;
}
}

//十五、改變應用程序的圖標靜態更改：

//修改圖標資源IDR_MAINFRAME。它有兩個圖標，一個是16*16的，另一個是32*32的，注意要一起修改。

//動態更改： 向主窗口發送WM_SETICON消息.代碼如下：
HICON hIcon=AfxGetApp()->LoadIcon(IDI_ICON);
ASSERT(hIcon);
AfxGetMainWnd()->SendMessage(WM_SETICON,TRUE,(LPARAM)hIcon);

//十六、另一種改變窗口標題的方法

//使用語句 CWnd* m_pCWnd = AfxGetMainWnd( )，然后，再以如下形式調用SetWindowText()函數：
SetWindowText( *m_pCWnd,(LPCTSTR)m_WindowText);// m_WindowText可以是一個CString類的變量。

//十七、剪切板上通過增強元文件拷貝圖像數據下面代碼拷貝通過元文件拷貝圖像數據到任何應用程序，
//其可以放置在CView派生類的函數中。

CMetaFileDC * m_pMetaDC = new CMetaFileDC();
m_pMetaDC->CreateEnhanced(GetDC(),NULL,NULL,"whatever");
//draw meta file
//do what ever you want to do: bitmaps, lines, text...
//close meta file dc and prepare for clipboard;
HENHMETAFILE hMF = m_pMetaDC->CloseEnhanced();
//copy to clipboard
OpenClipboard();
EmptyClipboard();
::SetClipboardData(CF_ENHMETAFILE,hMF);
CloseClipboard();

//DeleteMetaFile(hMF);
delete m_pMetaDC;

//十八、剪切板上文本數據的傳送把文本放置到剪接板上：

CString source;
//put your text in source
if(OpenClipboard())
{
HGLOBAL clipbuffer;
char * buffer;
EmptyClipboard();
clipbuffer = GlobalAlloc(GMEM_DDESHARE, source.GetLength()+1);
buffer = (char*)GlobalLock(clipbuffer);
strcpy(buffer, LPCSTR(source));
GlobalUnlock(clipbuffer);
SetClipboardData(CF_TEXT,clipbuffer);
CloseClipboard();
}

//從剪接板上獲取文本：

char * buffer;
if(OpenClipboard())
{
buffer = (char*)GetClipboardData(CF_TEXT);
//do something with buffer here
//before it goes out of scope
}
CloseClipboard();

//十九、將捕捉屏幕圖像到剪切版中

void CShowBmpInDlgDlg::OnCutScreen()
{
ShowWindow(SW_HIDE);
RECT r_bmp={0,0,::GetSystemMetrics(SM_CXSCREEN),
::GetSystemMetrics(SM_CYSCREEN)};
HBITMAP hBitmap;
hBitmap=CopyScreenToBitmap(&r_bmp);

//hWnd為程序窗口句柄
if (OpenClipboard())
{
EmptyClipboard();
SetClipboardData(CF_BITMAP, hBitmap);
CloseClipboard();
}
ShowWindow(SW_SHOW);
}
HBITMAP CShowBmpInDlgDlg::CopyScreenToBitmap(LPRECT lpRect)
{
//lpRect 代表選定區域
{
HDC hScrDC, hMemDC;
// 屏幕和內存設備描述表
HBITMAP hBitmap, hOldBitmap;
// 位圖句柄
int nX, nY, nX2, nY2;
// 選定區域坐標
int nWidth, nHeight;
// 位圖寬度和高度
int xScrn, yScrn;
// 屏幕分辨率

// 確保選定區域不為空矩形
if (IsRectEmpty(lpRect))
return NULL;
//為屏幕創建設備描述表
hScrDC = CreateDC("DISPLAY", NULL, NULL, NULL);
//為屏幕設備描述表創建兼容的內存設備描述表
hMemDC = CreateCompatibleDC(hScrDC);
// 獲得選定區域坐標
nX = lpRect->left;
nY = lpRect->top;
nX2 = lpRect->right;
nY2 = lpRect->bottom;
// 獲得屏幕分辨率
xScrn = GetDeviceCaps(hScrDC, HORZRES);
yScrn = GetDeviceCaps(hScrDC, VERTRES);
//確保選定區域是可見的
if (nX<0)

nX = 0;
if (nY<0)
nY = 0;
if (nX2>xScrn)
nX2 = xScrn;
if (nY2>yScrn)
nY2 = yScrn;
nWidth = nX2 - nX;
nHeight = nY2 - nY;
// 創建一個與屏幕設備描述表兼容的位圖
hBitmap = CreateCompatibleBitmap
(hScrDC, nWidth, nHeight);
// 把新位圖選到內存設備描述表中
hOldBitmap =(HBITMAP)SelectObject(hMemDC, hBitmap);
// 把屏幕設備描述表拷貝到內存設備描述表中
BitBlt(hMemDC, 0, 0, nWidth, nHeight, hScrDC, nX, nY, SRCCOPY);
//得到屏幕位圖的句柄
hBitmap = (HBITMAP)SelectObject(hMemDC, hOldBitmap);

//清除
DeleteDC(hScrDC);
DeleteDC(hMemDC);
// 返回位圖句柄
return hBitmap;
}
}

//二十、如何將位圖縮放顯示在Static控件中

//在Staic控件內顯示位圖
void CShowBmpInDlgDlg::ShowBmpInStaic()
{
CBitmap hbmp;
HBITMAP hbitmap;
//將pStatic指向要顯示的地方
CStatic *pStaic;
pStaic=(CStatic*)GetDlgItem(IDC_IMAGE);
//裝載資源 MM.bmp是我的一個文件名，用你的替換
hbitmap=(HBITMAP)::LoadImage (::AfxGetInstanceHandle(),"MM.bmp",
IMAGE_BITMAP,0,0,LR_LOADFROMFILE|LR_CREATEDIBSECTION);

hbmp.Attach(hbitmap);
//獲取圖片格式
BITMAP bm;
hbmp.GetBitmap(&bm);
CDC dcMem;
dcMem.CreateCompatibleDC(GetDC());
CBitmap *poldBitmap=(CBitmap*)dcMem.SelectObject(hbmp);
CRect lRect;
pStaic->GetClientRect(&lRect);
//顯示位圖
pStaic->GetDC()->StretchBlt(lRect.left ,lRect.top ,lRect.Width(),lRect.Height(),
&dcMem,0 ,0,bm.bmWidth,bm.bmHeight,SRCCOPY);
dcMem.SelectObject(&poldBitmap);
}

編程相關 :: 評論 (0) :: 靜態鏈接網址 :: 引用 (0)

VC中利用多線程技術實現線程之間的通信

fixedstar | 26 三月, 2006 12:03

當前流行的Windows操作系統能同時運行幾個程序(獨立運行的程序又稱之為進程)，對于同一個程序，它又可以分成若干個獨立的執行流，我們稱之為線程，線程提供了多任務處理的能力。用進程和線程的觀點來研究軟件是當今普遍采用的方法，進程和線程的概念的出現，對提高軟件的并行性有著重要的意義。現在的大型應用軟件無一不是多線程多任務處理，單線程的軟件是不可想象的。因此掌握多線程多任務設計方法對每個程序員都是必需要掌握的。本實例針對多線程技術在應用中經常遇到的問題，如線程間的通信、同步等，分別進行探討，并利用多線程技術進行線程之間的通信，實現了數字的簡單排序。　　

　　一、 實現方法

　　1、理解線程

　　要講解線程，不得不說一下進程，進程是應用程序的執行實例，每個進程是由私有的虛擬地址空間、代碼、數據和其它系統資源組成。進程在運行時創建的資源隨著進程的終止而死亡。線程的基本思想很簡單，它是一個獨立的執行流，是進程內部的一個獨立的執行單元，相當于一個子程序，它對應于Visual C++中的CwinThread類對象。單獨一個執行程序運行時，缺省地包含的一個主線程，主線程以函數地址的形式出現，提供程序的啟動點，如main（）或WinMain（）函數等。當主線程終止時，進程也隨之終止。根據實際需要，應用程序可以分解成許多獨立執行的線程，每個線程并行的運行在同一進程中。

　　一個進程中的所有線程都在該進程的虛擬地址空間中，使用該進程的全局變量和系統資源。操作系統給每個線程分配不同的CPU時間片，在某一個時刻，CPU只執行一個時間片內的線程，多個時間片中的相應線程在CPU內輪流執行，由于每個時間片時間很短，所以對用戶來說，仿佛各個線程在計算機中是并行處理的。操作系統是根據線程的優先級來安排CPU的時間，優先級高的線程優先運行，優先級低的線程則繼續等待。

　　線程被分為兩種：用戶界面線程和工作線程（又稱為后臺線程）。用戶界面線程通常用來處理用戶的輸入并響應各種事件和消息，其實，應用程序的主執行線程CWinAPP對象就是一個用戶界面線程，當應用程序啟動時自動創建和啟動，同樣它的終止也意味著該程序的結束，進程終止。工作線程用來執行程序的后臺處理任務，比如計算、調度、對串口的讀寫操作等，它和用戶界面線程的區別是它不用從CWinThread類派生來創建，對它來說最重要的是如何實現工作線程任務的運行控制函數。工作線程和用戶界面線程啟動時要調用同一個函數的不同版本；最后需要讀者明白的是，一個進程中的所有線程共享它們父進程的變量，但同時每個線程可以擁有自己的變量。

　　2、線程的管理和操作

　　（一）線程的啟動

　　創建一個用戶界面線程，首先要從類CwinThread產生一個派生類，同時必須使用DECLARE_DYNCREATE和IMPLEMENT_DYNCREATE來聲明和實現這個CwinThread派生類。第二步是根據需要重載該派生類的一些成員函數如：ExitInstance（）、InitInstance（）、OnIdle（）、PreTranslateMessage（）等函數。最后調用AfxBeginThread()函數的一個版本：CWinThread* AfxBeginThread( CRuntimeClass* pThreadClass, int nPriority = THREAD_PRIORITY_NORMAL, UINT nStackSize = 0, DWORD dwCreateFlags = 0, LPSECURITY_ATTRIBUTES lpSecurityAttrs = NULL ) 啟動該用戶界面線程，其中第一個參數為指向定義的用戶界面線程類指針變量，第二個參數為線程的優先級，第三個參數為線程所對應的堆棧大小，第四個參數為線程創建時的附加標志，缺省為正常狀態，如為CREATE_SUSPENDED則線程啟動后為掛起狀態。

　　對于工作線程來說，啟動一個線程，首先需要編寫一個希望與應用程序的其余部分并行運行的函數如Fun1()，接著定義一個指向CwinThread對象的指針變量*pThread,調用AfxBeginThread(Fun1,param,priority)函數，返回值賦給pThread變量的同時一并啟動該線程來執行上面的Fun1（）函數，其中Fun1是線程要運行的函數的名字，也既是上面所說的控制函數的名字，param是準備傳送給線程函數Fun1的任意32位值，priority則是定義該線程的優先級別，它是預定義的常數，讀者可參考MSDN。

　　（二）線程的優先級

　　以下的CwinThread類的成員函數用于線程優先級的操作：

int GetThreadPriority（）；
BOOL SetThradPriority（）(int nPriority)；
　　上述的二個函數分別用來獲取和設置線程的優先級，這里的優先級，是相對于該線程所處的優先權層次而言的，處于同一優先權層次的線程，優先級高的線程先運行；處于不同優先權層次上的線程，誰的優先權層次高，誰先運行。至于優先級設置所需的常數，自己參考MSDN就可以了，要注意的是要想設置線程的優先級，這個線程在創建時必須具有THREAD_SET_INFORMATION訪問權限。對于線程的優先權層次的設置，CwinThread類沒有提供相應的函數，但是可以通過Win32 SDK函數GetPriorityClass（）和SetPriorityClass（）來實現。

　　（三）線程的懸掛和恢復

　　CWinThread類中包含了應用程序懸掛和恢復它所創建的線程的函數，其中SuspendThread（）用來懸掛線程，暫停線程的執行；ResumeThread（）用來恢復線程的執行。如果你對一個線程連續若干次執行SuspendThread（），則需要連續執行相應次的ResumeThread（）來恢復線程的運行。

　　（四）結束線程

　　終止線程有三種途徑，線程可以在自身內部調用AfxEndThread()來終止自身的運行；可以在線程的外部調用BOOL TerminateThread( HANDLE hThread, DWORD dwExitCode )來強行終止一個線程的運行，然后調用CloseHandle（）函數釋放線程所占用的堆棧；第三種方法是改變全局變量，使線程的執行函數返回，則該線程終止。下面以第三種方法為例，給出部分代碼：


//CtestView message handlers
/Set to True to end thread
Bool bend=FALSE;//定義的全局變量，用于控制線程的運行；
//The Thread Function；
UINT ThreadFunction(LPVOID pParam)//線程函數
{
　while(!bend)
　{
　　Beep(100,100);
　　Sleep(1000);
　}
　return 0;
}
/
CwinThread *pThread;
HWND hWnd;
Void CtestView::OninitialUpdate()
{
　hWnd=GetSafeHwnd();
　pThread=AfxBeginThread(ThradFunction,hWnd);//啟動線程
　pThread->m_bAutoDelete=FALSE;//線程為手動刪除
　Cview::OnInitialUpdate();
}

Void CtestView::OnDestroy()
{
　bend=TRUE;//改變變量，線程結束
　WaitForSingleObject(pThread->m_hThread,INFINITE);//等待線程結束
　delete pThread;//刪除線程
　Cview::OnDestroy();
}
　　3、線程之間的通信

　　通常情況下，一個次級線程要為主線程完成某種特定類型的任務，這就隱含著表示在主線程和次級線程之間需要建立一個通信的通道。一般情況下，有下面的幾種方法實現這種通信任務：使用全局變量（上一節的例子其實使用的就是這種方法）、使用事件對象、使用消息。這里我們主要介紹后兩種方法。

　　（一） 利用用戶定義的消息通信

　　在Windows程序設計中，應用程序的每一個線程都擁有自己的消息隊列，甚至工作線程也不例外，這樣一來，就使得線程之間利用消息來傳遞信息就變的非常簡單。首先用戶要定義一個用戶消息，如下所示：#define WM_USERMSG WMUSER+100；在需要的時候，在一個線程中調用：：PostMessage((HWND)param,WM_USERMSG,0,0)或CwinThread::PostThradMessage（）來向另外一個線程發送這個消息，上述函數的四個參數分別是消息將要發送到的目的窗口的句柄、要發送的消息標志符、消息的參數WPARAM和LPARAM。下面的代碼是對上節代碼的修改，修改后的結果是在線程結束時顯示一個對話框，提示線程結束：

UINT ThreadFunction(LPVOID pParam)
{
　while(!bend)
　{
　　Beep(100,100);
　　Sleep(1000);
　}
　：：PostMessage(hWnd,WM_USERMSG,0,0)；
　return 0;
}
WM_USERMSG消息的響應函數為OnThreadended(WPARAM wParam,
LPARAM lParam)
LONG CTestView::OnThreadended(WPARAM wParam,LPARAM lParam)
{
　AfxMessageBox("Thread ended.");
　Retrun 0;
}
　　上面的例子是工作者線程向用戶界面線程發送消息，對于工作者線程，如果它的設計模式也是消息驅動的，那么調用者可以向它發送初始化、退出、執行某種特定的處理等消息，讓它在后臺完成。在控制函數中可以直接使用：：GetMessage()這個SDK函數進行消息分檢和處理，自己實現一個消息循環。GetMessage()函數在判斷該線程的消息隊列為空時，線程將系統分配給它的時間片讓給其它線程，不無效的占用CPU的時間，如果消息隊列不為空，就獲取這個消息，判斷這個消息的內容并進行相應的處理。

　　（二）用事件對象實現通信

　　在線程之間傳遞信號進行通信比較復雜的方法是使用事件對象，用MFC的Cevent類的對象來表示。事件對象處于兩種狀態之一：有信號和無信號，線程可以監視處于有信號狀態的事件，以便在適當的時候執行對事件的操作。上述例子代碼修改如下：


Cevent threadStart ,threadEnd;
UINT ThreadFunction(LPVOID pParam)
{
　：：WaitForSingleObject(threadStart.m_hObject,INFINITE);
　AfxMessageBox("Thread start.");
　while(!bend)
　{
　　Beep(100,100);
　　Sleep(1000);
　　Int result=::WaitforSingleObject(threadEnd.m_hObject,0);
　　//等待threadEnd事件有信號，無信號時線程在這里懸停
　　If(result==Wait_OBJECT_0)
　　　Bend=TRUE;
　}
　：：PostMessage(hWnd,WM_USERMSG,0,0)；
　return 0;
}
/
Void CtestView::OninitialUpdate()
{
　hWnd=GetSafeHwnd();
　threadStart.SetEvent();//threadStart事件有信號
　pThread=AfxBeginThread(ThreadFunction,hWnd);//啟動線程
　pThread->m_bAutoDelete=FALSE;
　Cview::OnInitialUpdate();
}

Void CtestView::OnDestroy()
{
　threadEnd.SetEvent();
　WaitForSingleObject(pThread->m_hThread,INFINITE);
　delete pThread;
　Cview::OnDestroy();
}
　　運行這個程序，當關閉程序時，才顯示提示框，顯示"Thread ended"。
　　4、線程之間的同步

　　前面我們講過，各個線程可以訪問進程中的公共變量，所以使用多線程的過程中需要注意的問題是如何防止兩個或兩個以上的線程同時訪問同一個數據，以免破壞數據的完整性。保證各個線程可以在一起適當的協調工作稱為線程之間的同步。前面一節介紹的事件對象實際上就是一種同步形式。Visual C++中使用同步類來解決操作系統的并行性而引起的數據不安全的問題，MFC支持的七個多線程的同步類可以分成兩大類：同步對象（CsyncObject、Csemaphore、Cmutex、CcriticalSection和Cevent）和同步訪問對象（CmultiLock和CsingleLock）。本節主要介紹臨界區（critical section）、互斥（mutexe）、信號量（semaphore），這些同步對象使各個線程協調工作，程序運行起來更安全。

　　（一） 臨界區

　　臨界區是保證在某一個時間只有一個線程可以訪問數據的方法。使用它的過程中，需要給各個線程提供一個共享的臨界區對象，無論哪個線程占有臨界區對象，都可以訪問受到保護的數據，這時候其它的線程需要等待，直到該線程釋放臨界區對象為止，臨界區被釋放后，另外的線程可以強占這個臨界區，以便訪問共享的數據。臨界區對應著一個CcriticalSection對象，當線程需要訪問保護數據時，調用臨界區對象的Lock()成員函數；當對保護數據的操作完成之后，調用臨界區對象的Unlock()成員函數釋放對臨界區對象的擁有權，以使另一個線程可以奪取臨界區對象并訪問受保護的數據。同時啟動兩個線程，它們對應的函數分別為WriteThread()和ReadThread()，用以對公共數組組array[]操作，下面的代碼說明了如何使用臨界區對象：

#include "afxmt.h"
int array[10],destarray[10];
CCriticalSection Section;
UINT WriteThread(LPVOID param)
{
　Section.Lock();
　for(int x=0;x<10;x++)
　　array[x]=x;
　Section.Unlock();
}
UINT ReadThread(LPVOID param)
{
　Section.Lock();
　For(int x=0;x<10;x++)
　　Destarray[x]=array[x];
　　Section.Unlock();
}
　　上述代碼運行的結果應該是Destarray數組中的元素分別為1-9，而不是雜亂無章的數，如果不使用同步，則不是這個結果，有興趣的讀者可以實驗一下。

　　（二）互斥

　　互斥與臨界區很相似，但是使用時相對復雜一些，它不僅可以在同一應用程序的線程間實現同步，還可以在不同的進程間實現同步，從而實現資源的安全共享。互斥與Cmutex類的對象相對應，使用互斥對象時，必須創建一個CSingleLock或CMultiLock對象，用于實際的訪問控制，因為這里的例子只處理單個互斥，所以我們可以使用CSingleLock對象，該對象的Lock()函數用于占有互斥，Unlock()用于釋放互斥。實現代碼如下：

#include "afxmt.h"
int array[10],destarray[10];
CMutex Section;

UINT WriteThread(LPVOID param)
{
　CsingleLock singlelock;
　singlelock (&Section);
　singlelock.Lock();
　for(int x=0;x<10;x++)
　　array[x]=x;
　singlelock.Unlock();
}

UINT ReadThread(LPVOID param)
{
　CsingleLock singlelock;
　singlelock (&Section);
　singlelock.Lock();
　For(int x=0;x<10;x++)
　　Destarray[x]=array[x];
　　singlelock.Unlock();
}
　　（三）信號量

　　信號量的用法和互斥的用法很相似，不同的是它可以同一時刻允許多個線程訪問同一個資源，創建一個信號量需要用Csemaphore類聲明一個對象，一旦創建了一個信號量對象，就可以用它來對資源的訪問技術。要實現計數處理，先創建一個CsingleLock或CmltiLock對象，然后用該對象的Lock()函數減少這個信號量的計數值，Unlock()反之。下面的代碼分別啟動三個線程，執行時同時顯示二個消息框，然后10秒后第三個消息框才得以顯示。

/
Csemaphore *semaphore;
Semaphore=new Csemaphore(2,2);
HWND hWnd=GetSafeHwnd();
AfxBeginThread(threadProc1,hWnd);
AfxBeginThread(threadProc2,hWnd);
AfxBeginThread(threadProc3,hWnd);
UINT ThreadProc1(LPVOID param)
{
　CsingleLock singelLock(semaphore);
　singleLock.Lock();
　Sleep(10000);
　::MessageBox((HWND)param,"Thread1 had access","Thread1",MB_OK);
　return 0;
}
UINT ThreadProc2(LPVOID param)
{
　CSingleLock singelLock(semaphore);
　singleLock.Lock();
　Sleep(10000);
　::MessageBox((HWND)param,"Thread2 had access","Thread2",MB_OK);
　return 0;
}

UINT ThreadProc3(LPVOID param)
{
　CsingleLock singelLock(semaphore);
　singleLock.Lock();
　Sleep(10000);
　::MessageBox((HWND)param,"Thread3 had access","Thread3",MB_OK);
　return 0;
}
　　二、 編程步驟

　　1、 啟動Visual C++6.0，生成一個32位的控制臺程序，將該程序命名為"sequence"

　　2、 輸入要排續的數字，聲明四個子線程；

　　3、 輸入代碼，編譯運行程序。

三、 程序代碼

//
// sequence.cpp : Defines the entry point for the console application.
/*
主要用到的WINAPI線程控制函數，有關詳細說明請查看MSDN；
線程建立函數：
HANDLE CreateThread(
　LPSECURITY_ATTRIBUTES lpThreadAttributes, // 安全屬性結構指針，可為NULL；
　DWORD dwStackSize, // 線程棧大小，若為0表示使用默認值；
　LPTHREAD_START_ROUTINE lpStartAddress, // 指向線程函數的指針；
　LPVOID lpParameter, // 傳遞給線程函數的參數，可以保存一個指針值；
　DWORD dwCreationFlags, // 線程建立是的初始標記，運行或掛起；
　LPDWORD lpThreadId // 指向接收線程號的DWORD變量；
);

對臨界資源控制的多線程控制的信號函數：

HANDLE CreateEvent(
　LPSECURITY_ATTRIBUTES lpEventAttributes, // 安全屬性結構指針，可為NULL；
　BOOL bManualReset, // 手動清除信號標記，TRUE在WaitForSingleObject后必須手動//調用RetEvent清除信號。若為　FALSE則在WaitForSingleObject
　//后，系統自動清除事件信號；
　BOOL bInitialState, // 初始狀態，TRUE有信號，FALSE無信號；
　LPCTSTR lpName // 信號量的名稱，字符數不可多于MAX_PATH；
　//如果遇到同名的其他信號量函數就會失敗，如果遇
　//到同類信號同名也要注意變化；
);

HANDLE CreateMutex(
　LPSECURITY_ATTRIBUTES lpMutexAttributes, // 安全屬性結構指針，可為NULL
　BOOL bInitialOwner, // 當前建立互斥量是否占有該互斥量TRUE表示占有，
　//這樣其他線程就不能獲得此互斥量也就無法進入由
　//該互斥量控制的臨界區。FALSE表示不占有該互斥量
　LPCTSTR lpName // 信號量的名稱，字符數不可多于MAX_PATH如果
　//遇到同名的其他信號量函數就會失敗，
　//如果遇到同類信號同名也要注意變化；
);

//初始化臨界區信號，使用前必須先初始化
VOID InitializeCriticalSection(
　LPCRITICAL_SECTION lpCriticalSection // 臨界區變量指針
);

//阻塞函數
//如果等待的信號量不可用，那么線程就會掛起，直到信號可用
//線程才會被喚醒，該函數會自動修改信號，如Event，線程被喚醒之后
//Event信號會變得無信號，Mutex、Semaphore等也會變。
DWORD WaitForSingleObject(
　HANDLE hHandle, // 等待對象的句柄
　DWORD dwMilliseconds // 等待毫秒數，INFINITE表示無限等待
);
//如果要等待多個信號可以使用WaitForMutipleObject函數
*/

#include "stdafx.h"
#include "stdlib.h"
#include "memory.h"
HANDLE evtTerminate; //事件信號,標記是否所有子線程都執行完
/*
下面使用了三種控制方法，你可以注釋其中兩種，使用其中一種。
注意修改時要連帶修改臨界區PrintResult里的相應控制語句
*/
HANDLE evtPrint; //事件信號,標記事件是否已發生
//CRITICAL_SECTION csPrint; //臨界區
//HANDLE mtxPrint; //互斥信號,如有信號表明已經有線程進入臨界區并擁有此信號
static long ThreadCompleted = 0;
/*用來標記四個子線程中已完成線程的個數,當一個子線程完成時就對ThreadCompleted進行加一操作, 要使用InterlockedIncrement(long* lpAddend)和InterlockedDecrement(long* lpAddend)進行加減操作*/

//下面的結構是用于傳送排序的數據給各個排序子線程
struct MySafeArray
{
　long* data;
　int iLength;
};

//打印每一個線程的排序結果
void PrintResult(long* Array, int iLength, const char* HeadStr = "sort");

//排序函數
unsigned long __stdcall BubbleSort(void* theArray); //冒泡排序
unsigned long __stdcall SelectSort(void* theArray); //選擇排序
unsigned long __stdcall HeapSort(void* theArray); //堆排序
unsigned long __stdcall InsertSort(void* theArray); //插入排序
/*以上四個函數的聲明必須適合作為一個線程函數的必要條件才可以使用CreateThread
建立一個線程。
（1）調用方法必須是__stdcall，即函數參數壓棧順序由右到左，而且由函數本身負責
棧的恢復, C和C++默認是__cdecl, 所以要顯式聲明是__stdcall
（2）返回值必須是unsigned long
（3）參數必須是一個32位值，如一個指針值或long類型
(4) 如果函數是類成員函數，必須聲明為static函數，在CreateThread時函數指針有特殊的寫法。如下(函數是類CThreadTest的成員函數中)：
static unsigned long _stdcall MyThreadFun(void* pParam);
handleRet = CreateThread(NULL, 0, &CThreadTestDlg::MyThreadFun, NULL, 0, &ThreadID);
之所以要聲明為static是由于，該函數必須要獨立于對象實例來使用，即使沒有聲明實例也可以使用。*/

int QuickSort(long* Array, int iLow, int iHigh); //快速排序

int main(int argc, char* argv[])
{
　long data[] = {123,34,546,754,34,74,3,56};
　int iDataLen = 8;
　//為了對各個子線程分別對原始數據進行排序和保存排序結果
　//分別分配內存對data數組的數據進行復制
　long *data1, *data2, *data3, *data4, *data5;
　MySafeArray StructData1, StructData2, StructData3, StructData4;
　data1 = new long[iDataLen];
　memcpy(data1, data, iDataLen << 2); //把data中的數據復制到data1中
　//內存復制 memcpy(目標內存指針, 源內存指針, 復制字節數), 因為long的長度
　//為4字節,所以復制的字節數為iDataLen << 2, 即等于iDataLen*4
　StructData1.data = data1;
　StructData1.iLength = iDataLen;
　data2 = new long[iDataLen];
　memcpy(data2, data, iDataLen << 2);
　StructData2.data = data2;
　StructData2.iLength = iDataLen;
　data3 = new long[iDataLen];
　memcpy(data3, data, iDataLen << 2);
　StructData3.data = data3;
　StructData3.iLength = iDataLen;
　data4 = new long[iDataLen];
　memcpy(data4, data, iDataLen << 2);
　StructData4.data = data4;
　StructData4.iLength = iDataLen;
　data5 = new long[iDataLen];
　memcpy(data5, data, iDataLen << 2);
　unsigned long TID1, TID2, TID3, TID4;
　//對信號量進行初始化
　evtTerminate = CreateEvent(NULL, FALSE, FALSE, "Terminate");
　evtPrint = CreateEvent(NULL, FALSE, TRUE, "PrintResult");
　//分別建立各個子線程
　CreateThread(NULL, 0, &BubbleSort, &StructData1, NULL, &TID1);
　CreateThread(NULL, 0, &SelectSort, &StructData2, NULL, &TID2);
　CreateThread(NULL, 0, &HeapSort, &StructData3, NULL, &TID3);
　CreateThread(NULL, 0, &InsertSort, &StructData4, NULL, &TID4);
　//在主線程中執行行快速排序，其他排序在子線程中執行
　QuickSort(data5, 0, iDataLen - 1);
　PrintResult(data5, iDataLen, "Quick Sort");
　WaitForSingleObject(evtTerminate, INFINITE); //等待所有的子線程結束
　//所有的子線程結束后，主線程才可以結束
　delete[] data1;
　delete[] data2;
　delete[] data3;
　delete[] data4;
　CloseHandle(evtPrint);
　return 0;
}

/*
冒泡排序思想(升序，降序同理，后面的算法一樣都是升序):從頭到尾對數據進行兩兩比較進行交換,小的放前大的放后。這樣一次下來，最大的元素就會被交換的最后，然后下一次
循環就不用對最后一個元素進行比較交換了，所以呢每一次比較交換的次數都比上一次循環的次數少一，這樣N次之后數據就變得升序排列了*/
unsigned long __stdcall BubbleSort(void* theArray)
{
　long* Array = ((MySafeArray*)theArray)->data;
　int iLength = ((MySafeArray*)theArray)->iLength;
　int i, j=0;
　long swap;
　for (i = iLength-1; i >0; i--)
　{
　　for(j = 0; j < i; j++)
　　{
　　　if(Array[j] >Array[j+1]) //前比后大，交換
　　　{
　　　　swap = Array[j];
　　　　Array[j] = Array[j+1];
　　　　Array[j+1] = swap;
　　　}
　　}
　}
　PrintResult(Array, iLength, "Bubble Sort"); //向控制臺打印排序結果
　InterlockedIncrement(&ThreadCompleted); //返回前使線程完成數標記加1
　if(ThreadCompleted == 4) SetEvent(evtTerminate); //檢查是否其他線程都已執行完
　//若都執行完則設置程序結束信號量
　return 0;
}

/*選擇排序思想:每一次都從無序的數據中找出最小的元素，然后和前面已經有序的元素序列的后一個元素進行交換，這樣整個源序列就會分成兩部分，前面一部分是已經排好序的有序序列，后面一部分是無序的，用于選出最小的元素。循環N次之后，前面的有序序列加長到跟源序列一樣長，后面的無序部分長度變為0，排序就完成了。*/
unsigned long __stdcall SelectSort(void* theArray)
{
　long* Array = ((MySafeArray*)theArray)->data;
　int iLength = ((MySafeArray*)theArray)->iLength;
　long lMin, lSwap;
　int i, j, iMinPos;
　for(i=0; i < iLength-1; i++)
　{
　　lMin = Array[i];
　　iMinPos = i;
　　for(j=i + 1; j <= iLength-1; j++) //從無序的元素中找出最小的元素
　　{
　　　if(Array[j] < lMin)
　　　{
　　　　iMinPos = j;
　　　　lMin = Array[j];
　　　}
　　}
　　//把選出的元素交換拼接到有序序列的最后
　　lSwap = Array[i];
　　Array[i] = Array[iMinPos];
　　Array[iMinPos] = lSwap;
　}
　PrintResult(Array, iLength, "Select Sort"); //向控制臺打印排序結果
　InterlockedIncrement(&ThreadCompleted); //返回前使線程完成數標記加1
　if(ThreadCompleted == 4) SetEvent(evtTerminate);//檢查是否其他線程都已執行完
　//若都執行完則設置程序結束信號量
　return 0;
}

/*堆排序思想：堆：數據元素從1到N排列成一棵二叉樹，而且這棵樹的每一個子樹的根都是該樹中的元素的最小或最大的元素這樣如果一個無序數據集合是一個堆那么，根元素就是最小或最大的元素堆排序就是不斷對剩下的數據建堆，把最小或最大的元素析透出來。下面的算法，就是從最后一個元素開始，依據一個節點比父節點數值大的原則對所有元素進行調整，這樣調整一次就形成一個堆，第一個元素就是最小的元素。然后再對剩下的無序數據再進行建堆，注意這時后面的無序數據元素的序數都要改變，如第一次建堆后，第二個元素就會變成堆的第一個元素。*/
unsigned long __stdcall HeapSort(void* theArray)
{
　long* Array = ((MySafeArray*)theArray)->data;
　int iLength = ((MySafeArray*)theArray)->iLength;
　int i, j, p;
　long swap;
　for(i=0; i　{
　　for(j = iLength - 1; j>i; j--) //從最后倒數上去比較字節點和父節點
　　{
　　　p = (j - i - 1)/2 + i; //計算父節點數組下標
　　　//注意到樹節點序數跟數組下標不是等同的，因為建堆的元素個數逐個遞減
　　　if(Array[j] < Array[p]) //如果父節點數值大則交換父節點和字節點
　　　{
　　　　swap = Array[j];
　　　　Array[j] = Array[p];
　　　　Array[p] = swap;
　　　}
　　}
　}
　PrintResult(Array, iLength, "Heap Sort"); //向控制臺打印排序結果
　InterlockedIncrement(&ThreadCompleted); //返回前使線程完成數標記加1
　if(ThreadCompleted == 4) SetEvent(evtTerminate); //檢查是否其他線程都已執行完
　//若都執行完則設置程序結束信號量
　return 0;
}

/*插入排序思想：把源數據序列看成兩半，前面一半是有序的，后面一半是無序的，把無序的數據從頭到尾逐個逐個的插入到前面的有序數據中，使得有序的數據的個數不斷增大，同時無序的數據個數就越來越少，最后所有元素都會變得有序。*/
unsigned long __stdcall InsertSort(void* theArray)
{
　long* Array = ((MySafeArray*)theArray)->data;
　int iLength = ((MySafeArray*)theArray)->iLength;
　int i=1, j=0;
　long temp;
　for(i=1; i　{
　　temp = Array[i]; //取出序列后面無序數據的第一個元素值
　　for(j=i; j>0; j--) //和前面的有序數據逐個進行比較找出合適的插入位置
　　{
　　　if(Array[j - 1] >temp) //如果該元素比插入值大則后移
　　　　Array[j] = Array[j - 1];
　　　else //如果該元素比插入值小，那么該位置的后一位就是插入元素的位置
　　　　break;
　　}
　　Array[j] = temp;
　}
　PrintResult(Array, iLength, "Insert Sort"); //向控制臺打印排序結果
　InterlockedIncrement(&ThreadCompleted); //返回前使線程完成數標記加1
　if(ThreadCompleted == 4) SetEvent(evtTerminate); //檢查是否其他線程都已執行完
　　//若都執行完則設置程序結束信號量
　return 0;
}

/*快速排序思想：快速排序是分治思想的一種應用，它先選取一個支點，然后把小于支點的元素交換到支點的前邊，把大于支點的元素交換到支點的右邊。然后再對支點左邊部分和右
邊部分進行同樣的處理，這樣若干次之后，數據就會變得有序。下面的實現使用了遞歸
建立兩個游標：iLow，iHigh；iLow指向序列的第一個元素，iHigh指向最后一個先選第一個元素作為支點，并把它的值存貯在一個輔助變量里。那么第一個位置就變為空并可以放置其他的元素。 這樣從iHigh指向的元素開始向前移動游標，iHigh查找比支點小的元素，如果找到，則把它放置到空置了的位置（現在是第一個位置），然后iHigh游標停止移動，這時iHigh指向的位置被空置，然后移動iLow游標尋找比支點大的元素放置到iHigh指向的空置的位置，如此往復直到iLow與iHigh相等。最后使用遞歸對左右兩部分進行同樣處理*/

int QuickSort(long* Array, int iLow, int iHigh)
{
　if(iLow >= iHigh) return 1; //遞歸結束條件
　long pivot = Array[iLow];
　int iLowSaved = iLow, iHighSaved = iHigh; //保未改變的iLow，iHigh值保存起來
　while (iLow < iHigh)
　{
　　while (Array[iHigh] >= pivot && iHigh >iLow) //尋找比支點大的元素
　　　iHigh -- ;
　　Array[iLow] = Array[iHigh]; //把找到的元素放置到空置的位置
　　while (Array[iLow] < pivot && iLow < iHigh) //尋找比支點小的元素
　　　iLow ++ ;
　　Array[iHigh] = Array[iLow]; //把找到的元素放置到空置的位置
　}
　Array[iLow] = pivot; //把支點值放置到支點位置，這時支點位置是空置的
　//對左右部分分別進行遞歸處理
　QuickSort(Array, iLowSaved, iHigh-1);
　QuickSort(Array, iLow+1, iHighSaved);
　return 0;
}

//每一個線程都要使用這個函數進行輸出，而且只有一個顯示器，產生多個線程
//競爭對控制臺的使用權。
void PrintResult(long* Array, int iLength, const char* HeadStr)
{
　WaitForSingleObject(evtPrint, INFINITE); //等待事件有信號
　//EnterCriticalSection(&csPrint); //標記有線程進入臨界區
　//WaitForSingleObject(mtxPrint, INFINITE); //等待互斥量空置（沒有線程擁有它）
　int i;
　printf("%s: ", HeadStr);
　for (i=0; i　{
　　printf("%d,", Array[i]);
　　Sleep(100); //延時（可以去掉）
/*只是使得多線程對臨界區訪問的問題比較容易看得到
如果你把臨界控制的語句注釋掉，輸出就會變得很凌亂，各個排序的結果會
分插間隔著輸出，如果不延時就不容易看到這種不對臨界區控制的結果
*/
　}
　printf("%dn", Array[i]);
　SetEvent(evtPrint); //把事件信號量恢復，變為有信號
}
　　四、 小結

　　對復雜的應用程序來說，線程的應用給應用程序提供了高效、快速、安全的數據處理能力。本實例講述了線程處理中經常遇到的問題，希望對讀者朋友有一定的幫助，起到拋磚引玉的作用。

編程相關 :: 評論 (0) :: 靜態鏈接網址 :: 引用 (0)

VC常見數據類型轉換詳解

fixedstar | 26 三月, 2006 11:10

剛接觸VC編程的朋友往往對許多數據類型的轉換感到迷惑不解，本文將介紹一些常用數據類型的使用。

?

我們先定義一些常見類型變量借以說明

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);


二、從其它包含字符串的變量中獲取指向該字符串的指針


CString變量
str = "2008北京奧運";
buf = (LPSTR)(LPCTSTR)str;
BSTR類型的_variant_t變量
v1 = (_bstr_t)"程序員";
buf = _com_util::ConvertBSTRToString((_bstr_t)v1);

三、字符串轉換為其它數據類型
strcpy(temp,"123");

短整型(int)
i = atoi(temp);
長整型(long)
l = atol(temp);
浮點(double)
d = atof(temp);

四、其它數據類型轉換到CString
使用CString的成員函數Format來轉換,例如:


整數(int)
str.Format("%d",i);
浮點數(float)
str.Format("%f",i);
字符串指針(char *)等已經被CString構造函數支持的數據類型可以直接賦值
str = username;

五、BSTR、_bstr_t與CComBSTR


CComBSTR、_bstr_t是對BSTR的封裝,BSTR是指向字符串的32位指針。
char *轉換到BSTR可以這樣: BSTR b=_com_util::ConvertStringToBSTR("數據");///使用前需要加上頭文件comutil.h
反之可以使用char *p=_com_util::ConvertBSTRToString(b);


六、VARIANT 、_variant_t 與 COleVariant


VARIANT的結構可以參考頭文件VC98IncludeOAIDL.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與常用數據的對應關系:

unsigned char 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
IUnknown FAR* punkVal; VT_UNKNOWN
IDispatch FAR* pdispVal; VT_DISPATCH
SAFEARRAY FAR* parray; VT_ARRAY|*
unsigned char 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; VT_BYREF


_variant_t是VARIANT的封裝類，其賦值可以使用強制類型轉換，其構造函數會自動處理這些數據類型。
例如：
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;


七、其它

對消息的處理中我們經常需要將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位

編程相關 :: 評論 (0) :: 靜態鏈接網址 :: 引用 (0)

Source Insight：Linux源代碼閱讀的利器

fixedstar | 26 三月, 2006 11:04

閱讀源代碼是鉆研技術的最佳手段，而Linux提供了一個龐大的源代碼庫，但是，由于缺乏良好的源代碼閱讀工具，使得閱讀Linux源代碼尤其是內核源代碼十分困難，在本文中，筆者向大家推薦一個優秀的源代碼閱讀工具，并介紹了它的使用方法。

作為一個開放源代碼的操作系統，Linux附帶的源代碼庫使得廣大愛好者有了一個廣泛學習、深入鉆研的機會，特別是Linux內核的組織極為復雜，同時，又不能像windows平臺的程序一樣，可以使用集成開發環境通過察看變量和函數，甚至設置斷點、單步運行、調試等手段來弄清楚整個程序的組織結構，使得Linux內核源代碼的閱讀變得尤為困難。

當然Linux下的vim和emacs編輯程序并不是沒有提供變量、函數搜索，彩色顯示程序語句等功能。它們的功能是非常強大的。比如，vim和emacs就各自內嵌了一個標記程序，分別叫做ctag和etag，通過配置這兩個程序，也可以實現功能強大的函數變量搜索功能，但是由于其配置復雜，linux附帶的有關資料也不是很詳細，而且，即使建立好標記庫，要實現代碼彩色顯示功能，仍然需要進一步的配置（在另一片文章，我將會講述如何配置這些功能），同時，對于大多數愛好者來說，可能還不能熟練使用vim和emacs那些功能比較強大的命令和快捷鍵。

為了方便的學習Linux源程序，我們不妨回到我們熟悉的window環境下，也算是“師以長夷以制夷”吧。但是在Window平臺上，使用一些常見的集成開發環境，效果也不是很理想，比如難以將所有的文件加進去，查找速度緩慢，對于非Windows平臺的函數不能彩色顯示。于是筆者通過在互聯網上搜索，終于找到了一個強大的源代碼編輯器，它的卓越性能使得學習Linux內核源代碼的難度大大降低，這便是Source Insight3.0，它是一個Windows平臺下的共享軟件，可以從http://www.sourceinsight.com/上邊下載30天試用版本。也可以在http://www.pptel.net/index.php?option=com_remository&Itemid=67&func=fileinfo&parent=folder&filecatid=3由于Source Insight是一個Windows平臺的應用軟件，所以首先要通過相應手段把Linux系統上的程序源代碼弄到Windows平臺下，這一點可以通過在linux平臺上將/usr/src目錄下的文件拷貝到Windows平臺的分區上，或者從網上光盤直接拷貝文件到Windows平臺的分區來實現。

下面主要講解如何使用Source Insight，考慮到閱讀源程序的愛好者都有相當的軟件使用水平，本文對于一些瑣碎、人所共知的細節略過不提，僅介紹一些主要內容，以便大家能夠很快熟練使用本軟件，減少摸索的過程。

安裝Source Insight并啟動程序，可以進入圖1界面。在工具條上有幾個值得注意的地方，如圖所示，圖中內凹左邊的是工程按鈕，用于顯示工程窗口的情況；右邊的那個按鈕按下去將會顯示一個窗口，里邊提供光標所在的函數體內對其他函數的調用圖，通過點擊該窗體里那些函數就可以進入該函數所在的地方。

圖1 Source Insight界面圖

?

由于Source Insight實質上是一個支持多種開發語言（java,c ,c++等等）的編輯器，只不過由于其查找、定位、彩色顯示等功能的強大，而被我們當成源代碼閱讀工具使用。所以，為了有效的閱讀源程序，首先必須選擇功能菜單上的 “Project”選項的子菜單“New Project”新建一個項目，項目名稱可以自由選定，當然也可以選擇刪除（Remove）一個項目。當刪除一個項目的時候，并不刪除原有的源代碼文件,只是將該軟件生成的那些工程輔助文件刪除。設定之后，將會彈出一個對話框如圖2，接受默認選擇，如果，硬盤空間足夠，可以將第一個復選框選上，該選項將會需要與源代碼大致同等的空間來建立一個本地數據庫以加快查找的速度。

?

圖2 工程設置

?

點擊“OK”按鈕，接受選擇后，將會有一個新的對話框彈出，在這個對話框里，可以選擇將要閱讀的文件加入工程，一種方式是通過在File Name中輸入要閱讀源代碼文件的名稱，點擊“Add”按鈕將其加入，也可以通過其中“Add All”和“Add Tree”兩個按鈕可以將選中目錄的所有文件加入到工程中，其中“Add All”選項會提示加入頂層文件和遞歸加入所有文件兩種方式，而“Add Tree”相當于“Add All”選項的遞歸加入所有文件，可以根據需要使用，就我來說，更喜歡“Add Tree”一些。由于該程序采用了部分打開文件的方式，沒有用到的文件不會打開，所以，加入數千個文件也不用擔心加入的文件超出程序的所能容忍的最大值，我就是采用“Add Tree”的方式將Linux2.4內核的四千五百九十一個文件加入的。

?

圖3 添加文件

?

加入文件后，點擊一個文件，可以出現使用界面，如圖4所示，其中，右邊的那個窗口（Linux Project，即工程窗口）缺省按照字母順序列出當前工程中所有的文件。

?

圖4 工作窗口

?

點擊一個文件就可以打開該文件，顯示如圖5所示，進入到右邊的那個窗口分別可以以文件列表的方式，列出所有的文件，每個窗體下邊有一排按鈕，左邊的窗口（21142.c）從左至右分別為：按字母順序排列所有標記、按照文件中行數順序排列標記、按照類型排列標記、瀏覽本地文件標記、標記窗口屬性。右邊的窗口（Linux Project）從左至右分別為：按字母順序文件列表、顯示文件夾、按照文件類型歸類文件、全部文件的所有標記列表、按照標記類型歸類標記、跳轉到定義處、顯示標記信息、瀏覽工程標記、查找函數調用、工程屬性，其中全部文件的所有標記列表選項可能要一段時間抽取標記，同步到數據庫去，如果開始選擇了建立標記數據庫，將會在今后節省同步時間，最有用的莫過于瀏覽標記信息和查找函數調用，前者可以通過“Jump”按鈕在不同的地方查找同樣的標志，還可以通過“Reference”按鈕結合后者進行全局的標記查找。

?

?

Reference功能是Source Insight的特色之一，它可以在速度極快的在整個工程中找到所有的標記，并且在該行程序的前邊加上紅色箭頭的小按鈕鏈接上。圖6是一個Reference搜索后的結果，它可以有兩種模式，一種集中顯示結果，圖6顯示的就是這種模式，在這種模式下，可以通過前邊的紅色箭頭小按鈕進入另外一種模式，該標記的具體的所在處，也可以通過標記的具體所在處點擊紅色箭頭小按鈕進入警種模式，還可以通過工具條上的兩個紅色小箭頭直接在第二種模式下前后移動，察看相應信息。它的這個強大的功能使得閱讀Linux源程序有如神助。但是要注意的是，當進行了第二次“Reference”時，它會提示你將結果集附加在第一個結果集的后邊還是取代第一個結果集。如果選擇前者，不能對結果集根據前后兩次搜索結果進行分類，然后在其子類里進行移動，只能在整個結果集里移動；如果，選擇后者，結果集將會被替換為第二次搜索的結果，略微有些不方便。

?

圖6 Reference的搜索結果

?

當然，Source Insight 還提供了一些其他常見的便利。比如:右鍵菜單幾乎包含了程序的所有功能，可以在編輯窗口為程序加上行號，還可以統計整個工程的程序行數,當然還有功能強大卻用不上自動完成功能，似乎連它的30天試用期也是別有用心——可以迫使你盡可能快速的閱讀源程序，其他一些技巧大家可以在使用過程中慢慢摸索。怎么樣？愛好讀源代碼的朋友，不妨馬上去下載一個，去開始我們的Linux內核探險之旅吧

編程相關 :: 評論 (0) :: 靜態鏈接網址 :: 引用 (0)

開始→運行→命令 集錦

fixedstar | 05 十二月, 2005 23:27

winver---------檢查Windows版本 wmimgmt.msc----打開windows管理體系結構(WMI) wupdmgr--------windows更新程序 wscript--------windows腳本宿主設置 write----------寫字板 winmsd---------系統信息 wiaacmgr-------掃描儀和照相機向導 winchat--------XP自帶局域網聊天 mem.exe--------顯示內存使用情況 Msconfig.exe---系統配置實用程序 mplayer2-------簡易widnows media player mspaint--------畫圖板 mstsc----------遠程桌面連接 mplayer2-------媒體播放機 magnify--------放大鏡實用程序 mmc------------打開控制臺 mobsync--------同步命令 dxdiag---------檢查DirectX信息 drwtsn32------ 系統醫生 devmgmt.msc--- 設備管理器 dfrg.msc-------磁盤碎片整理程序 diskmgmt.msc---磁盤管理實用程序 dcomcnfg-------打開系統組件服務 ddeshare-------打開DDE共享設置 dvdplay--------DVD播放器 net stop messenger-----停止信使服務 net start messenger----開始信使服務 notepad--------打開記事本 nslookup-------網絡管理的工具向導 ntbackup-------系統備份和還原 narrator-------屏幕“講述人” ntmsmgr.msc----移動存儲管理器 ntmsoprq.msc---移動存儲管理員操作請求 netstat -an----(TC)命令檢查接口 syncapp--------創建一個公文包 sysedit--------系統配置編輯器 sigverif-------文件簽名驗證程序 sndrec32-------錄音機 shrpubw--------創建共享文件夾 secpol.msc-----本地安全策略 syskey---------系統加密，一旦加密就不能解開，保護windows xp系統的雙重密碼 services.msc---本地服務設置 Sndvol32-------音量控制程序 sfc.exe--------系統文件檢查器 sfc /scannow---windows文件保護 tsshutdn-------60秒倒計時關機命令 tourstart------xp簡介（安裝完成后出現的漫游xp程序） taskmgr--------任務管理器 eventvwr-------事件查看器 eudcedit-------造字程序 explorer-------打開資源管理器 packager-------對象包裝程序 perfmon.msc----計算機性能監測程序 progman--------程序管理器 regedit.exe----注冊表 rsop.msc-------組策略結果集 regedt32-------注冊表編輯器 rononce -p ----15秒關機 regsvr32 /u *.dll----停止dll文件運行 regsvr32 /u zipfldr.dll------取消ZIP支持 cmd.exe--------CMD命令提示符 chkdsk.exe-----Chkdsk磁盤檢查 certmgr.msc----證書管理實用程序 calc-----------啟動計算器 charmap--------啟動字符映射表 cliconfg-------SQL SERVER 客戶端網絡實用程序 Clipbrd--------剪貼板查看器 conf-----------啟動netmeeting compmgmt.msc---計算機管理 cleanmgr-------垃圾整理 ciadv.msc------索引服務程序 osk------------打開屏幕鍵盤 odbcad32-------ODBC數據源管理器 oobe/msoobe /a----檢查XP是否激活 lusrmgr.msc----本機用戶和組 logoff---------注銷命令 iexpress-------木馬捆綁工具，系統自帶 Nslookup-------IP地址偵測器 fsmgmt.msc-----共享文件夾管理器 utilman--------輔助工具管理器 gpedit.msc-----組策

一般分類 :: 評論 (0) :: 靜態鏈接網址 :: 引用 (0)

學習C++要注意的，絕對經典！

fixedstar | 01 一月, 2000 00:00

1.把C++當成一門新的語言學習（和C沒啥關系！真的。）；


2.看《Thinking In C++》，不要看《C++變成死相》；


3.看《The C++ Programming Language》和《Inside The C++ Object Model》,不要因為他們很難而我們自己是初學者所以就不看；


4.不要被VC、BCB、BC、MC、TC等詞匯所迷惑——他們都是集成開發環境，而我們要學的是一門語言；

5.不要放過任何一個看上去很簡單的小編程問題——他們往往并不那么簡單，或者可以引伸出很多知識點；

6.會用Visual C++，并不說明你會C++；

7.學class并不難，template、STL、generic programming也不過如此——難的是長期堅持實踐和不遺余力的博覽群書；

8.如果不是天才的話，想學編程就不要想玩游戲——你以為你做到了，其實你的C++水平并沒有和你通關的能力一起變高——其實可以時刻記住：學C++是為了編游戲的；

9.看Visual C++的書，是學不了C++語言的；

10.浮躁的人容易說：XX語言不行了，應該學YY；——是你自己不行了吧！？

11.浮躁的人容易問：我到底該學什么；——別問，學就對了；

12.浮躁的人容易問：XX有錢途嗎；——建議你去搶銀行；

13.浮躁的人容易說：我要中文版！我英文不行！——不行？學呀！

14.浮躁的人容易問：XX和YY哪個好；——告訴你吧，都好——只要你學就行；

15.浮躁的人分兩種：a)只觀望而不學的人；b)只學而不堅持的人；

16.把時髦的技術掛在嘴邊，還不如把過時的技術記在心里；

17.C++不僅僅是支持面向對象的程序設計語言；
18.學習編程最好的方法之一就是閱讀源代碼；

19.在任何時刻都不要認為自己手中的書已經足夠了；

20.請閱讀《The Standard C++ Bible》(中文版：標準C++寶典)，掌握C++標準；

21.看得懂的書，請仔細看；看不懂的書，請硬著頭皮看；

22.別指望看第一遍書就能記住和掌握什么——請看第二遍、第三遍；

23.請看《Effective C++》和《More Effective C++》以及《Exceptional C++》；

24.不要停留在集成開發環境的搖籃上，要學會控制集成開發環境，還要學會用命令行方式處理程序；

25.和別人一起討論有意義的C++知識點，而不是爭吵XX行不行或者YY與ZZ哪個好；

26.請看《程序設計實踐》，并嚴格的按照其要求去做；

27.不要因為C和C++中有一些語法和關鍵字看上去相同，就認為它們的意義和作用完全一樣；



28.C++絕不是所謂的C的“擴充”——如果C++一開始就起名叫Z語言，你一定不會把C和Z語言聯系得那么緊密；



29.請不要認為學過XX語言再改學C++會有什么問題——你只不過又在學一門全新的語言而已；



30.讀完了《Inside The C++ Object Model》以后再來認定自己是不是已經學會了C++；



31.學習編程的秘訣是：編程，編程，再編程；



32.請留意下列書籍：《C++面向對象高效編程（C++ Effective Object-Oriented Software Construction）》《面向對象軟件構造(Object-Oriented Software Construction)》《設計模式（Design Patterns）》《The Art of Computer Programming》；



33.記住：面向對象技術不只是C++專有的；



34.請把書上的程序例子親手輸入到電腦上實踐，即使配套光盤中有源代碼；



35.把在書中看到的有意義的例子擴充；



36.請重視C++中的異常處理技術，并將其切實的運用到自己的程序中；



37.經常回顧自己以前寫過的程序，并嘗試重寫，把自己學到的新知識運用進去；



38.不要漏掉書中任何一個練習題——請全部做完并記錄下解題思路；



39.C++語言和C++的集成開發環境要同時學習和掌握；



40.既然決定了學C++,就請堅持學下去，因為學習程序設計語言的目的是掌握程序設計技術，而程序設計技術是跨語言的；



41.就讓C++語言的各種平臺和開發環境去激烈的競爭吧，我們要以學習C++語言本身為主；



42.當你寫C++程序寫到一半卻發現自己用的方法很拙劣時，請不要馬上停手；請盡快將余下的部分粗略的完成以保證這個設計的完整性，然后分析自己的錯誤并重新設計和編寫（參見43）；



43.別心急，設計C++的class確實不容易；自己程序中的class和自己的class設計水平是在不斷的編程實踐中完善和發展的；



44.決不要因為程序“很小”就不遵循某些你不熟練的規則——好習慣是培養出來的，而不是一次記住的；



45.每學到一個C++難點的時候，嘗試著對別人講解這個知識點并讓他理解——你能講清楚才說明你真的理解了；



46.記錄下在和別人交流時發現的自己忽視或不理解的知識點；



47.請不斷的對自己寫的程序提出更高的要求,哪怕你的程序版本號會變成Version 100.XX；



48.保存好你寫過的所有的程序——那是你最好的積累之一；



49.請不要做浮躁的人；



50.請熱愛C++!

總結

以上是生活随笔為你收集整理的20个VC开发小技巧的全部內容，希望文章能夠幫你解決所遇到的問題。

如果覺得生活随笔網站內容還不錯，歡迎將生活随笔推薦給好友。