使用模板和虚拟函数的技术

不久前,我了解了奇怪的重复模板模式( http://en.wikipedia.org/wiki/Curiously_recurring_template_pattern ,这让我想起了一种用于实现事件队列缓存的技术。

基本思想是利用基类指针来存储同构指针类型的容器。但是,由于派生类是一个模板类,它存储一个类型为T的项,所以我们真正存储的是一个异类类型列表。

我很好奇是否有人看过这项技术,这可能很有趣,如果有人把它命名了呢?有人愿意批评它吗?有没有更好的方法来达到我的目的?

谢谢。

#include <iostream>
#include <algorithm>
#include <functional>
#include <list>
#include <string>

class Base
{
   public:
      Base(){}
      virtual ~Base(){}

      virtual void operator()() = 0;
};


template<typename C, typename T>
class Derived : public Base
{
   public:

      Derived(C* c, T item) : consumer_(c), item_(item) {}

      virtual void operator()()
      {
         consumer_->consume(item_);
      }

      C* consumer_;
      T item_;
};

class Consumer
{
      bool postpone_;
      std::list<Base*> cache_;


   public:
      Consumer() : postpone_(true)
      {
      }

      void pause()
      {
         postpone_ = true;
      }

      void resume()
      {
         postpone_ = false;

         const std::list<Base*>::iterator end = cache_.end();
         for ( std::list<Base*>::iterator iter = cache_.begin();
               iter != end;
               ++iter )
         {
            Base* bPtr = *iter;
            bPtr->operator()();
            delete bPtr;
         }
         cache_.clear();
      }

      void consume(int i) 
      {
         if ( postpone_ )
         {
            std::cerr << "Postpone int.\n";
            cache_.push_back(new Derived<Consumer, int>(this, i));
         }
         else
         {
            std::cerr << "Got int.\n";
         }
      }

      void consume(double d)
      {
         if ( postpone_ )
         {
            std::cerr << "Postpone double.\n";
            cache_.push_back(new Derived<Consumer, double>(this, d));
         }
         else
         {
            std::cerr << "Got double.\n";
         }
      }
      void consume(char c)
      {
         if ( postpone_ )
         {
            std::cerr << "Postpone char.\n";
            cache_.push_back(new Derived<Consumer, char>(this, c));
         }
         else
         {
            std::cerr << "Got char.\n";
         }
      }
};
static Consumer consumer;



void destroy(Base* object)
{
   delete object;
}


int main()
{
   // Consumer is registered with something that sends events out to lots
   // of different consumer types (think observer pattern). Also in the non-toy
   // version consumer isn't being passed PODs, but various Event types.
   consumer.consume(0);
   consumer.consume(0.1f);
   consumer.consume('x');

   consumer.resume();
}

输出为:

Postpone int.
Postpone double.
Postpone char.
Got int.
Got double.
Got char.