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的析构函数也会被正确调用，保证加的锁被解锁，面前面的程序就不具有这样的健壮性。