【C++】template vs virtual function

泛型编程和抽象接口都能达到代码重用和接口抽象的作用，STL是泛型编程的代码，而设计模式里面遍布了各种抽象接口，对于同样的问题，两种方法都能实现。

比如，我要实现一个锁类，泛型会这样实现：

class CMutex { 　　public: 　　　　CMutex(pthread_mutexattr_t* attrs = 0) 　　　　{ 　　　　　　pthread_mutex_init(&lock_,attrs); 　　　　} 　　　　~CMutex() 　　　　{ 　　　　　　pthread_mutex_destroy(&lock_); 　　　　} 　　　　int acquire() 　　　　{ 　　　　　　return pthread_mutex_lock(&lock_); 　　　　} 　　　　int acquire(const struct timespec* _time) 　　　　{ 　　　　　　return pthread_mutex_timedlock(&lock_,_time); 　　　　} 　　　　int release() 　　　　{ 　　　　　　return pthread_mutex_unlock(&lock_); 　　　　} 　　　　pthread_mutex_t& lock() 　　　　{ 　　　　　　return lock_; 　　　　} 　　　　protected: 　　　　　　pthread_mutex_t lock_; }; class CNullMutex { 　　public: 　　　　CNullMutex (pthread_mutexattr_t* attrs = 0) : lock_ (0) {} 　　　　 ~CNullMutex () {} 　　　　int acquire() 　　　　{ 　　　　　　return 0; 　　　　} 　　　　int acquire(const struct timespec* _time) 　　　　{ 　　　　　　errno = ETIME; return -1; 　　　　} 　　　　int release() 　　　　{ 　　　　　　return 0; 　　　　} 　　　　int& lock() 　　　　{ 　　　　　　return lock_; 　　　　} 　　private: 　　　　int lock_; // A dummy lock. }; template <class LOCK> class CGuard { 　　private: 　　　　LOCK* m_lock; 　　　　int m_owner; 　　public: 　　　　CGuard(LOCK& lock):m_lock(&lock) 　　　　{ 　　　　　　acquire(); 　　　　} 　　　　~CGuard() 　　　　{ 　　　　　　release(); 　　　　} 　　　　int acquire () 　　　　{ 　　　　　　return m_owner = m_lock->acquire(); 　　　　} 　　　　int release() 　　　　{ 　　　　　　if(m_owner == -1) 　　　　　　　　return -1; 　　　　　　else { 　　　　　　　　m_owner = -1; 　　　　　　　　return m_lock->release(); 　　　　　　} 　　　　} 　　　　int locked() const 　　　　{ 　　　　　　return m_owner != -1; 　　　　} 　　　　private: 　　　　　　CGuard(); 　　　　　　CGuard (const CGuard<LOCK> &); 　　　　　　void operator= (const CGuard<LOCK> &); };

使用时，给CGuard类传递不同的LOCK就成，比如，CGuard<CMutex> guard(m_qumutex)

如果用抽象接口，我可以这样：
class CLock { 　　public: 　　　　CLock(){} 　　　　virtual ~CLock(){} 　　　　virtual int acquire() = 0; 　　　　virtual int acquire(const struct timespec* time) = 0; 　　　　virtual int release() = 0; }; class CMutex : public CLock { 　　public: 　　　　CMutex() 　　　　{ 　　　　　　pthread_mutexattr_init(&m_attr); 　　　　　　pthread_mutex_init(&m_lock, &m_attr); 　　　　} 　　　　virtual ~CMutex() 　　　　{ 　　　　　　pthread_mutex_destroy(&m_mutex); 　　　　　　pthread_mutexattr_destory(&m_attr); 　　　　} 　　　　virtual int acquire() 　　　　{ 　　　　　　return pthread_mutex_lock(&m_mutex); 　　　　} 　　　　virtual int acquire(const struct timespec* time) 　　　　{ 　　　　　　return pthread_mutex_timedlock(&m_mutex, time); 　　　　} 　　　　virtual int release() 　　　　{ 　　　　　　return pthread_mutex_unlock(&m_mutex); 　　　　} 　　　　pthread_mutex_t& lock() 　　　　{ 　　　　　　return m_mutex; 　　　　} 　　private: 　　　　pthread_mutex_t m_mutex; 　　　　pthread_mutexattr_t m_attr; }; class CNullMutex : public CLock { 　　public: 　　　　CNullMutex() : m_mutex(0){} 　　　　virtual ~CNullMutex(){} 　　　　virtual int acquire() { return 0; } 　　　　virtual int acquire(const struct timespec* time) { return 0; } 　　　　virtual int release() { return 0; } 　　　　int lock() { return m_mutex; } 　　private: 　　　　int m_mutex; }; class CGuard { 　　public: 　　　　CGuard(CLock* lock) : m_lock(lock) { acquire(); } 　　　　~CGuard() { release(); } 　　private: 　　　　CGuard(); 　　　　CGuard(const CGuard&); 　　　　void operator= (const CGuard&); 　　　　int acquire() { return m_lock->acquire(); } 　　　　int release() { return m_lock->release(); } 　　　　CLock* m_lock; };

 

用就这样CGuard guard(m_lock)，其中，m_lock时CLock* 类型，使用时根据需要new一个具体的实际lock，如前面的CMutex。

 

于是，我纠结了，那我在设计时，到底应该怎么取舍呢？能看出的区别就是，template是compile time，virtual function是runtime，compile time类型安全一点吧，性能上runtime要看编译器，可如果就这样，还是不足以作为我选择的条件啊！昨天瞄了一下一本叫《Modern C++ Design Generic Programming and Design Patterns Applied》，上面讲了点儿policy和virtual function的区别，其中有一段话是这样说的：
Note that policies are quite different from mere virtual functions. Virtual functions promise a similar effect: The implementer of a class defines higher-level functions in terms of primitive virtual functions and lets the user override the behavior of those primitives. As shown above, however, policies come with enriched type knowledge and static binding, which are essential ingredients for building designs. Aren't designs full of rules that dictate before runtime how types interact with each other and what you can and what you cannot do? Policies allow you to generate designs by combining simple choices in a typesafe manner. In addition, because the binding between a host class and its policies is done at compile time, the code is tight and efficient, comparable to its handcrafted equivalent.

也就是说，泛型编程这种compile time policy的实现是语法绑定的，它的核心是用什么样的语法去组织一个类，而不是像virtual function那样注重的是哪些确实的功能需要我们实现。

 

我想，到底在设计中使用哪种方式还是看程序员自己怎么想吧，想清楚一个类在整个设计中的位置和它的behavior是关键，另外经验也许能指导我在具体问题中应该怎么进行选择。

 

所以，纠结了两天，先到这里吧，继续我的项目，不然真写不完咯，实践出真知，我想过段时间再来看今天写的东西定会有不同的感受。