C++中實現靜態初始化程式碼片段

C++中，我們經常會用到靜態變數，但對於這些靜態變數的初始化，我們只能對其進行賦初值，不能像C#或是Java中那樣，有一個靜態初始化段來進行一些複雜的初始化工作。

 

 

 

舉例來說，我有一個類，其成員變數會在多個線程中並發訪問，所以我需要一個鎖來保護資料一致性。於是有了這樣的代碼：

 

1. class MyClass 
2. { 
3. public: 
4.     void Foo() 
5.     { 
6.         ::EnterCriticalSection(&ms_lock); 
7.         // operates m_mapValues 
8.         ::LeaveCriticalSection(&ms_lock); 
9.     } 
11. protected: 
12.     static std::map<int, std::string> m_mapValues; 
13.     static CRITICAL_SECTION ms_lock; 
14. }; 
16. std::map<int, std::string> MyClass::m_mapValues;
17. CRITICAL_SECTION MyClass::ms_lock;
18. // We can't call InitializeCriticalSection here 

前幾天從同事那裡學到了一個技巧，只用很少的幾行代碼，就可以實現這個功能。

 

 

解決上面問題的辦法：

 

1. class CCriticalSection 
2. { 
3. public: 
4.     CCriticalSection()  { ::InitializeCriticalSection(&m_criticalSection); } 
5.     ~CCriticalSection() { ::DeleteCriticalSection(&m_criticalSection); } 
6.     void Lock()   { ::EnterCriticalSection(&m_criticalSection); } 
7.     void Unlock() { ::LeaveCriticalSection(&m_criticalSection); } 
9. protected: 
10.         CRITICAL_SECTION m_criticalSection; 
11. }; 

有了這個類，我們就可以在MyClass中聲明一個CCriticalSection類的靜態成員，這樣，在初始化這個靜態成員時，會調用建構函式中的代碼，也就實現了我的要求：

 

 

 

1. class MyClass 
2. { 
3. public: 
4.     void Foo() 
5.     { 
6.         ::EnterCriticalSection(&m_lockObject); 
7.         // operates m_mapValues  
8.         ::LeaveCriticalSection(&m_lockObject); 
9.     }
11. protected: 
12.     std::map<int, std::string> m_mapValues; 
13.     static CCriticalSection m_lockObject; 
14. }; 
16. std::map<int, std::string> MyClass::m_mapValues;
17. CCriticalSection MyClass::m_lockObject;    // InitializeCriticalSection will be called here  

實際上，那個靜態map也會在初始化時通過建構函式做一些初始化工作。感歎自己C++還沒用精，東西其實都知道，就是在問題面前沒能想到。

 

 

另外，我們還可以加上一個輔助類，進一步利用C++的構造解構函式機制來簡化我們的代碼，減少錯誤。

 

1. template <class LockObject> 
2. class ScopedLocker 
3. { 
4. public: 
5.     ScopedLocker(LockObject& lockObject) : m_lockObject(lockObject) { m_lockObject.Lock(); } 
6.     ~ScopedLocker() { m_lockObject.Unlock(); } 
8. protected: 
9.     LockObject& m_lockObject; 
10. }; 

現在我們可以這樣寫：

 

 

 

 

1. class MyClass 
2. { 
3. public: 
4.     void Foo() 
5.     { 
6.         ScopedLocker locker(m_lockObject);  // ::EnterCriticalSection calls here
7.         // operates m_mapValues 
8.     }   // ::LeaveCriticalSection calls here
10. protected: 
11.     std::map<int, std::string> m_mapValues; 
12.     static CCriticalSection m_lockObject; 
13. }; 
15. std::map<int, std::string> MyClass::m_mapValues;
16. CCriticalSection MyClass::m_lockObject;    // InitializeCriticalSection will be called here 

而且最重要的是，這樣寫還使得我們程式的異常處理更健壯，在locker構造後，如果發生了異常，locker的解構函式也會被正確調用，保證加的鎖被解鎖，面前面的程式就不具有這樣的健壯性。