很早前就想寫點總結將編程中遇到的各種錯誤刨根挖底地羅列出來。但是因為這些錯誤（VC中開調試器遇到的各種錯誤對話框）都是隨機性的，真正想總結的時候又不想不起來有哪些錯誤。恰好最近運氣比較背，各種錯誤都被我遇遍了，于是恰好有機會做個總結。
這里所說的VC下的錯誤對話框時指在VC中開調試器運行程序時，IDE彈出的對話框。
1.不是錯誤的錯誤：斷言 .
將斷言視為錯誤其實有點可笑，但是因為有些同學甚至不知道這個，所以我稍微提一下。斷言對話框大致上類似于：
斷言對話框是由assert引起的，在對話框上通常會給出表達式，例如assert( 0 ); 彈出對話框時就會將0這個表達式顯示出來（Expression:0)。關于assert的具體信息建議自己google。這里稍微提一下一個技巧：有時候為了讓assert提供更多的信息，我們可以這樣寫一個assert:
assert( expression && "Function : invalid argument!" );
因為字符串被用在布爾表達式中時，始終為true，不會妨礙對expression的判斷，當斷言發生時(expression為false) 時，斷言對話框上就會顯示這個字符串，從而方便我們調試。
要解決這個問題，首先要確定斷言發生的位置，如果是你自己設置的斷言被引發，就很好解決，如果是系統內部的函數產生的，那么一般是因為你傳入的函數參數無效引起。
2.內存相關：最簡單的非法訪問：
C、C++程序中經常誤用無效的指針，從而大致各種各樣的非法內存訪問（寫/讀）。最簡單的情況類似于：
這樣的情況由類似以下代碼引起：
char *p = 0;
*p = 'a';
當你看到類似于“寫入位置XXXX時發生訪問沖突“時，那么你大致可以斷定，你的程序在某個地方訪問到非法內存。開調試器對調用堆棧進行跟蹤即可找出錯誤。
3.內存相關：不小心的棧上數組越界：
當你寫下類似以下的代碼時：
char str[3];
strcpy( str, "abc" );
就將看到如下的對話框：
對話框大致的意思就是說str周圍的棧被破壞了，因為str本身就被放在棧上，所以strcpy(str,"abc")多寫入的'\0'就寫到非法的棧區域。看到這樣的對話框可以根據調用堆棧定位到錯誤發生的函數，然后檢查此函數內部定義的數組訪問，即可解決問題。
4.內存相關：不小心的堆上數組越界：
并不是每次數組越界都會得到上面所描述的錯誤，當數組是在堆上分配時，情況就變得隱秘得多：
char *str = new char [2];
strcpy( str, "ab" ); //執行到這里時并不見得會崩潰
delete [] str;//但是到這里時就肯定會崩潰
以上代碼導致的錯誤對話框還要詭異些：
似乎不同的DAMAGE對應的錯誤號（這里是47）都不一樣，因為這里的錯誤發生在delete，而delete跟new很可能在不同的地方，所以這個錯誤調試起來不是那么容易，很多時候只能靠經驗。
當看到類似的對話框時，根據調用堆棧跟到delete時，你就可以大致懷疑堆上數組越界。
5.調用相關：函數調用約定帶來的錯誤：
這是所有我這里描述的錯誤中最詭異的一種，先看下對話框大致的樣子：
對話框大致的意思就是說（沒開調試器時對話框樣式可能不一樣），通過函數指針調用某個函數時，函數指針的類型（函數原型）可能與函數指針指向的函數的類型不一樣。這里的類型不一致主要是調用約定(call conversation）不一樣。如果函數類型（參數個數，返回值）不一樣，一般不會出錯。
調用約定是指調用一個函數時，函數參數的壓入順序、誰來清理棧的內容等。例如默認的C、C++調用約定__cdecl，對于函數的參數是從右往左壓入。而__stdcall（WIN API的調用約定）則是從左向右壓。我這里所說的函數類型不一樣，就是指一個函數是使用__cdecl，還是__stdcall。例如以下代碼：
#include <iostream>
void __stdcall show( const char *str )
{
}
void __stdcall show2()
{
}
int main()
{
typedef void (*Func)( const char *);
void *p = show;
Func my_func = (Func) p;
my_func( "kevin" );
return 0;
}
因為Func默認地被處理為__cdecl，而show是__stdcall的，所以當通過函數指針my_func時，就導致了以上對話框的出現。但是當p指向show2時，又不會出錯，這是因為show2沒有參數，不同的調用約定不影響這個規則。
6.異常相關：默認終止程序
當我們使用C++庫時，因為庫本身可能會拋出C++異常，如果你不捕獲這個異常，那么C++默認就會調用abort（或者exit）函數終止程序。例如：
void test()
{
throw std::exception( "some exceptions" );
}
當你調用test函數時，如果不catch這個異常，開調試器就會得到類似的錯誤對話框：
而如果不開調試器，則會得到：
當你看到類似于“This application has requested the Runtime to terminate it…”之類的字眼時，那就表明程序調用了abort（或exit）函數，導致程序異常終止。其實這個錯誤只要開調試器，一般可以準確定位錯誤的發生點。
7.VC運行時檢查-未初始化變量
VC的調試器會對代碼進行運行時檢查，這可能會導致VC彈出對你看上去正確的代碼。這也許不是一個錯誤。例如：
int test_var;
if( test_var == -1 )
{
test_var = 0;
}
test_var沒有初始化就進行if判斷，當運行以上代碼開調試器時，就會得到如下對話框：
8.破壞的堆
VC對于在堆上分配的內存都做了記錄，我想這主要用于free釋放內存時做歸還處理。
char *p = (char*) malloc( 100 );
p += 10;
free( p );
當執行以上代碼時，因為p的值已經改變，提交到free的指針值變化，VC就會給出以下錯誤提示：
本文轉自：http://www.shnenglu.com/kevinlynx/archive/2008/04/24/47998.html
posted @
2012-09-14 14:18 王海光 閱讀(575) |
評論 (0) |
編輯 收藏有一天有個同事在通過vld調試一個內存泄漏問題，折騰了很久然后找到我。我瞥了一眼他的代碼，發現問題和我曾經遇到的一模一樣：
1 class Base {
2 public:
3 ~Base();
4 };
5
6 class Derived : public Base {
7 privated:
8 std::vector<int> m_data; };
9
10 Base *obj = new Derived();
11 delete obj;
當然，實際代碼比這個復雜得多(這也是導致從發現問題到找到問題耗費大量時間的原因)。vld在報內存泄漏時，當然報的位置是new的地方。這個同事檢查了這個對象的整個生命周期，確定他正確地釋放了這個對象。
問題的關鍵就在于：Base類的析構函數不是virtual的。因為不是virtual，所以在對一個Base類型的指針進行delete時，就不會調用到派生類Derived的析構函數。而派生類里的析構函數會用于析構其內部的子對象，也就是這里的m_data。這樣，就造成了內存泄漏。
這其實是一個很低級的失誤。但毫不客氣地說C++中有很多這種少個關鍵字或者代碼位置不對就會造成另一個結果的例子。事實上，針對這些悲劇也有很多書提出一些準則來讓大家去無腦遵守。例如針對這個例子，我就記得曾有書說，只要你覺得你的類會被繼承，那么最好給析構函數加上virtual。
posted @
2012-09-14 13:54 王海光 閱讀(423) |
評論 (0) |
編輯 收藏
摘要: win7下得到操作系統版本錯誤（ GetVersionEx）
有一段得到操作系統版本的代碼，用的是 GetVersionEx 方法，在當前機器的硬盤上運行，得到的操作系統版本是win7。奇怪的是，在U盤上運行，得到的操作系統版本是XP。
直接說原因： 不知道什么時候，系統在注冊表中設置了U盤exe的XP兼容項（在兼容性助手彈出時，選擇重新啟動或者重新安裝時，系統會在H...
閱讀全文
posted @
2012-09-14 11:23 王海光 閱讀(4953) |
評論 (0) |
編輯 收藏
摘要: CListCtrl使用技巧
以下未經說明，listctrl默認view 風格為report
1. CListCtrl 風格
LVS_ICON: 為每個item顯示大圖標 LVS_SMALLICON: 為每個item顯示小圖標 &nbs...
閱讀全文
posted @
2012-09-13 14:31 王海光 閱讀(2318) |
評論 (0) |
編輯 收藏
響應WM_CTLCOLOR消息
WM_CTLCOLOR消息的響應函數.此函數的原型:
afx_msg HBRUSH OnCtlColor(CDC *pDC,CWnd *pWnd,UINT nCtlColor);
參數nCtlColor用于指定控件的類型,可以是:
.CTLCOLOR_BTN 按鈕控件
.CTLCOLOR_DLG 對話框
.CTLCOLOR_EDIT 編輯框
.CTLCOLOR_LISTBOX 列表控件
.CTLCOLOR_MSGBOX 消息控件
.CTLCOLOR_SCROLLBAR 滾動條控件
.CTLCOLOR_STATIC 靜態控件
MSDN中信息:
The framework calls this member function when a child control is about to be drawn.
1 afx_msg HBRUSH OnCtlColor(
2 CDC* pDC,
3 CWnd* pWnd,
4 UINT nCtlColor
5 );
Parameters
Return Value
OnCtlColor must return a handle to the brush that is to be used for painting the control background.
Example
1 // This OnCtlColor handler will change the color of a static control
2 // with the ID of IDC_MYSTATIC. The code assumes that the CPenWidthsDlg
3 // class has an initialized and created CBrush member named m_brush.
4 // The control will be painted with red text and a background
5 // color of m_brush.
6 HBRUSH CPenWidthsDlg::OnCtlColor(CDC* pDC, CWnd* pWnd, UINT nCtlColor)
7 {
8 // Call the base class implementation first! Otherwise, it may
9 // undo what we're trying to accomplish here.
10 HBRUSH hbr = CDialog::OnCtlColor(pDC, pWnd, nCtlColor);
11
12 // Are we painting the IDC_MYSTATIC control? We can use
13 // CWnd::GetDlgCtrlID() to perform the most efficient test.
14 if (pWnd->GetDlgCtrlID() == IDC_MYSTATIC)
15 {
16 // Set the text color to red
17 pDC->SetTextColor(RGB(255, 0, 0));
18
19 // Set the background mode for text to transparent
20 // so background will show thru.
21 pDC->SetBkMode(TRANSPARENT);
22
23 // Return handle to our CBrush object
24 hbr = m_brush;
25 }
26
27 return hbr;
28 }
Requirements
posted @
2012-09-12 16:34 王海光 閱讀(1006) |
評論 (0) |
編輯 收藏 復雜的東西寫多了，如今寫點簡單的好了。由于功能上的需要，
Vczh Library++3.0被我搞得很離譜。為了開發維護的遍歷、減少粗心犯下的錯誤以及增強單元測試、回歸測試和測試工具，因此記錄下一些開發上的小技巧，以便拋磚引玉，造福他人。歡迎高手來噴，菜鳥膜拜。
之前的文章講了指針和內存的一些問題，今天說一下單元測試的問題。如果在團隊里面沒有對單元測試的框架有要求的話，其實我們可以使用一個最簡單的方法來搭建在IDE里面運行的單元測試框架，整個框架只需十幾行代碼。我們先來考慮一下功能最少的單元測試框架需要完成什么樣的內容。首先我們要運行一個一個的測試用例，其次在一個測試用例里面我們要檢查一些條件是否成立。舉個例子，我們寫一個函數將兩個字符串連接起來，一般來說要進行下面的測試：
1 #include "MyUnitTestFramework.h"//等一下我們會展示一下如何用最少的代碼完成這個頭文件的內容
2 #include "
"
3
4 TEST_CASE(StringConcat)
5 {
6 TEST_ASSERT(concat("a", "b")=="ab");
7 TEST_ASSERT(concat("a", "")=="a");
8 TEST_ASSERT(concat("", "b")=="b");
9 TEST_ASSERT(concat("", "")=="");
10 .
11 }
12
13 int wmain()
14 {
15 return 0;
16 } 如果我們的單元測試框架可以這么寫，那顯然做起什么事情來都會方便很多，而且不需要向一些其他的測試框架一樣注冊一大堆東西，或者是寫一大堆配置函數。當然這次我們只做功能最少的測試框架，這個框架除了運行測試以外，不會有其他功能，譬如選擇哪些測試可以運行啦，還是在出錯的時候log一些什么啦之類。之所以要在IDE里面運行，是因為我們如果做到TEST_ASSERT中出現false的話，立刻在該行崩潰，那么IDE就會幫你定位到出錯的TEST_ASSERT中去，然后給你顯示所有的上下文信息，譬如說callstack啦什么的。友好的工具不用簡直對不起自己啊，干嗎非得把單元測試做得那么復雜捏，凡是單元測試，總是要全部運行通過才能提交代碼的。
那么我們來看看上面的單元測試的代碼。首先寫了TEST_CASE的那個地方，大括號里面的代碼會自動運行。其次TEST_ASSERT會在表達式是false的時候崩潰。先從簡單的入手吧。如何制造崩潰呢？最簡單的辦法就是拋異常：
1 #define TEST_ASSERT(e) do(if(!(e))throw "今晚沒飯吃。";}while(0)
這里面有兩個要注意的地方。首先e要加上小括號，不然取反操作符就有可能做出錯誤的行為。譬如說當e是a+b==c的時候，加了小括號就變成if(!(a+b==c))...，沒有加小括號就變成if(!a+b==c)...，意思就完全變了。第二個主意的地方是我使用do{...}while(0)把語句包圍起來了。這樣做的好處是可以在任何時候TEST_ASSERT(e)都像一個語句。譬如我們可能這么寫：
1 if(a)
2 TEST_ASSERT(x1);
3 else if(b)
4 {
5 TEST_ASSERT(x2);
6 TEST_ASSERT(x3);
7 }
如果沒有do{...}while(0)包圍起來，這個else就會被綁定到宏里面的那個if，你的代碼就被偷偷改掉了。
那么現在剩下TEST_CASE(x){y}了。什么東西可以在main函數外面自動運行呢？這個我想熟悉C++的人都會知道，就是全局變量的構造函數啦。所以TEST_CASE(x){y}那個大括號里面的y只能在全局變量的構造函數里面調用。但是我們知道寫一個類的時候，構造函數的大括號寫完了，后面還有類的大括號，全局變量的名稱，和最終的一個分號。為了把這些去掉，那么顯然{y}應該屬于一個普通的函數。那么全局變量如何能夠使用這個函數呢？方法很簡單，把函數前置聲明一下就行了：
1 #define TEST_CASE(NAME) \
2 extern void TESTCASE_##NAME(); \
3 namespace vl_unittest_executors \
4 { \
5 class TESTCASE_RUNNER_##NAME \
6 { \
7 public: \
8 TESTCASE_RUNNER_##NAME() \
9 { \
10 TESTCASE_##NAME(); \
11 } \
12 } TESTCASE_RUNNER_##NAME##_INSTANCE; \
13 } \
14 void TESTCASE_##NAME()
那我們來看看TEST_CASE(x){y}究竟會被翻譯成什么代碼：
1 extern void TESTCASE_x();
2 namespace vl_unittest_executors
3 {
4 class TESTCASE_RUNNER_x
5 {
6 public:
7 TESTCASE_RUNNER_x()
8 {
9 TESTCASE_x();
10 }
11 } TESTCASE_RUNNER_x_INSTANCE;
12 }
13 void TESTCASE_x(){y}
到了這里是不是很清楚了捏，首先在main函數運行之前TESTCASE_RUNNER_x_INSTANCE變量會初始化，然后調用TESTCASE_RUNNER_x的構造函數，最后運行函數TESTCASE_x，該函數的內容顯然就是{y}了。這里還能學到宏是如何連接兩個名字成為一個名字，和如何寫多行的宏的。
于是MyUnittestFramework.h就包含這兩個宏，其他啥都沒有，是不是很方便呢？打開Visual C++，建立一個工程，引用這個頭文件，然后寫你的單元測試，最后F5就運行了，多方便啊，啊哈哈哈。
這里需要注意一點，那些單元測試的順序是不受到保證的，特別是你使用了多個cpp文件的情況下。于是你在使用這個測試框架的同時，會被迫保證執行一次單元測試不會對你的全局狀態帶來什么副作用，以便兩個測試用例交換順序執行的時候仍然能穩定地產生相同的結果。這對你寫單元測試有幫助，而且為了讓你的代碼能夠被這么測試，你的代碼也會寫的有條理，不會依賴全局狀態，真是一舉兩得也。而且說不定單元測試用例比你的全局變量的初始化還先執行呢，因此為了使用這個測試框架，你將會不得不把你的全局變量隱藏在一個cpp里面，而暴露出隨時可以被調用的一組函數出來。這樣也可以讓你的代碼在使用全局狀態的時候更加安全。
今天就講到這里了。下一篇要寫什么我還沒想好，到時候再說吧。
本文轉自：
http://www.shnenglu.com/vczh/archive/2010/06/27/118829.html
posted @
2012-09-12 14:54 王海光 閱讀(824) |
評論 (0) |
編輯 收藏
摘要: C++實用技巧（一） 復雜的東西寫多了，如今寫點簡單的好了。由于功能上的需要，Vczh Library++3.0被我搞得很離譜。為了開發維護的遍歷、減少粗心犯下的錯誤以及增強單元測試、回歸測試和測試工具，因此記錄下一些開發上的小技巧，以便拋磚引玉，造福他人。歡迎高手來噴，菜鳥膜拜。 C++實謂各種語言中的軟肋，功能強大，陷阱...
閱讀全文
posted @
2012-09-12 14:51 王海光 閱讀(501) |
評論 (0) |
編輯 收藏
在高效C++編程中看到一個不錯的內存池實現方案，這里共享下，大家看看有什么不足。
代碼很簡單，如下：
template<typename T>
class CMemoryPool
{
public:
enum { EXPANSION_SIZE = 32};
CMemoryPool(unsigned int nItemCount = EXPANSION_SIZE)
{
ExpandFreeList(nItemCount);
}
~CMemoryPool()
{
//free all memory in the list
CMemoryPool<T>* pNext = NULL;
for(pNext = m_pFreeList; pNext != NULL; pNext = m_pFreeList)
{
m_pFreeList = m_pFreeList->m_pFreeList;
delete [](char*)pNext;
}
}
void* Alloc(unsigned int /*size*/)
{
if(m_pFreeList == NULL)
{
ExpandFreeList();
}
//get free memory from head
CMemoryPool<T>* pHead = m_pFreeList;
m_pFreeList = m_pFreeList->m_pFreeList;
return pHead;
}
void Free(void* p)
{
//push the free memory back to list
CMemoryPool<T>* pHead = static_cast<CMemoryPool<T>*>(p);
pHead->m_pFreeList = m_pFreeList;
m_pFreeList = pHead;
}
protected:
//allocate memory and push to the list
void ExpandFreeList(unsigned nItemCount = EXPANSION_SIZE)
{
unsigned int nSize = sizeof(T) > sizeof(CMemoryPool<T>*) ? sizeof(T) : sizeof(CMemoryPool<T>*);
CMemoryPool<T>* pLastItem = static_cast<CMemoryPool<T>*>(static_cast<void*>(new char[nSize]));
m_pFreeList = pLastItem;
for(int i=0; i<nItemCount-1; ++i)
{
pLastItem->m_pFreeList = static_cast<CMemoryPool<T>*>(static_cast<void*>(new char[nSize]));
pLastItem = pLastItem->m_pFreeList;
}
pLastItem->m_pFreeList = NULL;
}
private:
CMemoryPool<T>* m_pFreeList;
};
它的實現思想就是每次從List的頭上取內存， 如果取不到則重新分配一定數量； 用完后把內存放回List頭部，這樣的話效率很高，因為每次List上可以取到的話，肯定是空閑的內存。
當然上面的代碼只是針對單線程的，要支持多線程的話也很簡單，外面加一層就可以了，
代碼如下：
class CCriticalSection
{
public:
CCriticalSection()
{
InitializeCriticalSection(&m_cs);
}
~CCriticalSection()
{
DeleteCriticalSection(&m_cs);
}
void Lock()
{
EnterCriticalSection(&m_cs);
}
void Unlock()
{
LeaveCriticalSection(&m_cs);
}
protected:
CRITICAL_SECTION m_cs;
};
template<typename POOLTYPE, typename LOCKTYPE>
class CMTMemoryPool
{
public:
void* Alloc(unsigned int size)
{
void* p = NULL;
m_lock.Lock();
p = m_pool.Alloc(size);
m_lock.Unlock();
return p;
}
void Free(void* p)
{
m_lock.Lock();
m_pool.Free(p);
m_lock.Unlock();
}
private:
POOLTYPE m_pool;
LOCKTYPE m_lock;
};
這是我的測試代碼：
#include <iostream>
#include <windows.h>
using namespace std;
#include "MemoryPool.h"
#include "MTMemoryPool.h"
class CTest
{
public:
int m_n;
int m_n1;
void* operator new(size_t size)
{
void* p = s_pool->Alloc(size);
return p;
}
void operator delete(void* p, size_t size)
{
s_pool->Free(p);
}
static void NewPool()
{
//s_pool = new CMemoryPool<CTest>;
s_pool = new CMTMemoryPool<CMemoryPool<CTest>, CCriticalSection>;
}
static void DeletePool()
{
delete s_pool;
s_pool = NULL;
}
//static CMemoryPool<CTest>* s_pool;
static CMTMemoryPool<CMemoryPool<CTest>, CCriticalSection>* s_pool;
};
//CMemoryPool<CTest>* CTest::s_pool = NULL;
CMTMemoryPool<CMemoryPool<CTest>, CCriticalSection>* CTest::s_pool = NULL;
void testFun()
{
int i;
const int nLoop = 10;
const int nCount = 10000;
for(int j = 0; j<nLoop; ++j)
{
typedef CTest* LPTest;
LPTest arData[nCount];
for(i=0;i <nCount; ++i)
{
arData[i] = new CTest;
}
for(i=0;i <nCount; ++i)
{
delete arData[i];
}
}
}
int main(int argc, char* argv[])
{
{
unsigned int dwStartTickCount = GetTickCount();
CTest::NewPool();
testFun();
CTest::DeletePool();
cout << "total cost" << GetTickCount() - dwStartTickCount << endl;
}
system("pause");
return 0;
}
在我機器上測試結果比系統默認的CRT實現高效N倍。
本文轉自：
http://www.shnenglu.com/weiym/archive/2012/05/05/173785.aspx
posted @
2012-09-11 11:30 王海光 閱讀(547) |
評論 (0) |
編輯 收藏
Callback的本質是設置一個函數指針進去，然后在需要需要觸發某個事件時調用該方法, 比如Windows的窗口消息處理函數就是這種類型。比如下面的示例代碼，我們在Download完成時需要觸發一個通知外面的事件：
typedef void (__stdcall *DownloadCallback)(const char* pURL, bool bOK);void DownloadFile(const char* pURL, DownloadCallback callback){ cout << "downloading: " << pURL << "" << endl; callback(pURL, true);}void __stdcall OnDownloadFinished(const char* pURL, bool bOK){ cout << "OnDownloadFinished, URL:" << pURL << " status:" << bOK << endl;} 2、Sink方式
Sink的本質是你按照對方要求實現一個C++接口，然后把你實現的接口設置給對方，對方需要觸發事件時調用該接口， COM中連接點就是居于這種方式。上面下載文件的需求，如果用Sink實現，代碼如下:
class IDownloadSink{public: virtual void OnDownloadFinished(const char* pURL, bool bOK) = 0;};class CMyDownloader{public: CMyDownloader(IDownloadSink* pSink) :m_pSink(pSink) { } void DownloadFile(const char* pURL) { cout << "downloading: " << pURL << "" << endl; if(m_pSink != NULL) { m_pSink->OnDownloadFinished(pURL, true); } }private: IDownloadSink* m_pSink;};class CMyFile: public IDownloadSink{public: void download() { CMyDownloader downloader(this); downloader.DownloadFile("www.baidu.com"); } virtual void OnDownloadFinished(const char* pURL, bool bOK) { cout << "OnDownloadFinished, URL:" << pURL << " status:" << bOK << endl; }}; 3、Delegate方式
Delegate的本質是設置成員函數指針給對方，然后讓對方在需要觸發事件時調用。C#中用Delegate的方式實現Event，讓C++程序員很是羨慕，C++中因為語言本身的關系，要實現Delegate還是很麻煩的。上面的例子我們用Delegate的方式實現如下:
class CDownloadDelegateBase{public: virtual void Fire(const char* pURL, bool bOK) = 0;};template<typename O, typename T>class CDownloadDelegate: public CDownloadDelegateBase{ typedef void (T::*Fun)(const char*, bool);public: CDownloadDelegate(O* pObj = NULL, Fun pFun = NULL) :m_pFun(pFun), m_pObj(pObj) { } virtual void Fire(const char* pURL, bool bOK) { if(m_pFun != NULL && m_pObj != NULL) { (m_pObj->*m_pFun)(pURL, bOK); } }private: Fun m_pFun; O* m_pObj;};template<typename O, typename T>CDownloadDelegate<O,T>* MakeDelegate(O* pObject, void (T::*pFun)(const char* pURL, bool)){ return new CDownloadDelegate<O, T>(pObject, pFun);}class CDownloadEvent{public: ~CDownloadEvent() { vector<CDownloadDelegateBase*>::iterator itr = m_arDelegates.begin(); while (itr != m_arDelegates.end()) { delete *itr; ++itr; } m_arDelegates.clear(); } void operator += (CDownloadDelegateBase* p) { m_arDelegates.push_back(p); } void operator -= (CDownloadDelegateBase* p) { ITR itr = remove(m_arDelegates.begin(), m_arDelegates.end(), p); ITR itrTemp = itr; while (itrTemp != m_arDelegates.end()) { delete *itr; ++itr; } m_arDelegates.erase(itr, m_arDelegates.end()); } void operator()(const char* pURL, bool bOK) { ITR itrTemp = m_arDelegates.begin(); while (itrTemp != m_arDelegates.end()) { (*itrTemp)->Fire(pURL, bOK); ++itrTemp; } }private: vector<CDownloadDelegateBase*> m_arDelegates; typedef vector<CDownloadDelegateBase*>::iterator ITR;};class CMyDownloaderEx{public: void DownloadFile(const char* pURL) { cout << "downloading: " << pURL << "" << endl; downloadEvent(pURL, true); } CDownloadEvent downloadEvent;};class CMyFileEx{public: void download() { CMyDownloaderEx downloader; downloader.downloadEvent += MakeDelegate(this, &CMyFileEx::OnDownloadFinished); downloader.DownloadFile("www.baidu.com"); } virtual void OnDownloadFinished(const char* pURL, bool bOK) { cout << "OnDownloadFinished, URL:" << pURL << " status:" << bOK << endl; }}; 可以看到Delegate的方式代碼量比上面其他2種方式大多了，并且我們上面是固定參數數量和類型的實現方式，如果要實現可變參數，要更加麻煩的多。可變參數的方式可以參考這2種實現:Yet Another C#-style Delegate Class in Standard C++
Member Function Pointers and the Fastest Possible C++ Delegates我們可以用下面的代碼測試我們上面的實現：
int _tmain(int argc, _TCHAR* argv[])
{
DownloadFile("www.baidu.com", OnDownloadFinished);
CMyFile f1;
f1.download();
CMyFileEx ff;
ff.download();
system("pause");
return 0;
}
最后簡單比較下上面3種實現回調的方法:第一種Callback的方法是面向過程的，使用簡單而且靈活，正如C語言本身。第二種Sink的方法是面向對象的，在C++里使用較多， 可以在一個Sink里封裝一組回調接口，適用于一系列比較固定的回調事件。第三種Delegate的方法也是面向對象的，和Sink封裝一組接口不同，Delegate的封裝是以函數為單位，粒度比Sink更小更靈活。 你更傾向于用哪種方式來實現回調? 本文轉自：http://www.shnenglu.com/weiym/archive/2012/08/28/188515.html
posted @
2012-09-11 10:43 王海光 閱讀(451) |
評論 (0) |
編輯 收藏
memmove(void *dest,void*src,int count)
memcpy(void *dest,void *src,int count)
memccpy(void*dest,void*src,int ch,int count)
表頭文件: #include <string.h>
定義函數: void *memcpy(void *dest, const void *src, size_t n)
函數說明: memcpy()用來拷貝src所指的內存內容前n個字節到dest所指的內存地址上。與strcpy()不同的是,memcpy()會完整的復制n個字節,不會因為遇到字符串結束'\0'而結束
返回值: 返回指向dest的指針
表頭文件: #include <string.h>
定義函數: void *memccpy(void *dest, const void *src, int c, size_t n);
函數說明: memccpy()用來拷貝src所指的內存內容前n個字節到dest所指的地址上。與memcpy()不同的是,memccpy()如果在src中遇到某個特定值(int c)立即停止復制。
返回值: 返回指向dest中值為c的下一個字節指針。返回值為0表示在src所指內存前n個字節中沒有值為c的字節。
表頭文件: #include <string.h>
定義函數: void *memmove(void *dest, const void *src, size_t n);
函數說明:memmove()是從一個緩沖區移動到另一個緩沖區中。
返回值: 返回指向dest指針。
當dest <= src-count 或dest >= src+count時，以上三個函數均不會產生覆蓋問題，即源數據不會被更改。
若不在以上范圍內，則源數據會被更改。如:char a[]={'a','b'};char b[]={'c','d','e','f','g','h'};memmove(a,b,sizeof(b));或是直接char *p=b+2;memmove(p,b,sizeof(b));輸出數據會發現b中數據輸出已被更改。發現即使a數組指向的空間不夠存儲數據，也能夠移動成功。原因|dest - src |<count如果在使用這些函數時，分配給足夠的空間，然后再使用就不會出現覆蓋問題。也就是說如果外部分配給的空間不足以存儲要拷貝的數據時，就有可能出現源數據被覆蓋更改的問題。#include <stdio.h>#include <stdlib.h>#include <string.h>void main(void){ int i=0; char a[9]={'a','b','c','d','e','f','g','h','\0'}; char p[2]={'q','w'};//或char *p=a+2; memmove(p,a,sizeof(a)); puts(a); printf("_____________________________________________\n"); puts(p); printf("_____________________________________________\n"); for(i =0;i<10;i++) printf("%c %d \n",*(a+i),a+i); printf("_____________________________________________\n"); for(i =0;i<8;i++) printf("%c %d \n",*(p+i),p+i); }觀察輸出結果。把memmove(p,a,sizeof(a));改為memcpy(p,a,sizeof(a));或memccpy(p,a,'e',sizeof(a));再觀察輸出結果。可以看出在目的存儲空間不足時，便會出現源數據被覆蓋改變的問題。如果目的存儲空間分配足夠的空間，則便不會出現覆蓋問題。本文轉自：http://www.shnenglu.com/kang/archive/2009/04/05/78984.html
posted @
2012-09-11 10:28 王海光 閱讀(552) |
評論 (0) |
編輯 收藏