编程语言

img BalonFan

C++中实现静态初始化代码段

发表于2008/9/30 20:40:00  4015人阅读

分类: 技术

C++中,我们经常会用到静态变量,但对于这些静态变量的初始化,我们只能对其进行赋初值,不能像C#或是Java中那样,有一个静态初始化段来进行一些复杂的初始化工作。

 

 

 

举例来说,我有一个类,其成员变量会在多个线程中并发访问,所以我需要一个锁来保护数据一致性。于是有了这样的代码:

 

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

前几天从同事那里学到了一个技巧,只用很少的几行代码,就可以实现这个功能。

 

 

解决上面问题的办法:

 

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

有了这个类,我们就可以在MyClass中声明一个CCriticalSection类的静态成员,这样,在初始化这个静态成员时,会调用构造函数中的代码,也就实现了我的要求:

 

 

 

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

实际上,那个静态的map也会在初始化时通过构造函数做一些初始化工作。感叹自己C++还没用精,东西其实都知道,就是在问题面前没能想到。

 

 

另外,我们还可以加上一个辅助类,进一步利用C++的构造析构函数机制来简化我们的代码,减少错误。


 

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

现在我们可以这样写:

 

 

 

 

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

而且最重要的是,这样写还使得我们程序的异常处理更健壮,在locker构造后,如果发生了异常,locker的析构函数也会被正确调用,保证加的锁被解锁,面前面的程序就不具有这样的健壮性。

阅读全文
0 0

相关文章推荐

img
取 消
img