如何最好地實現具有相互依賴類型的模板類

Question

作為一個簡化的例子，如果我有類

template <class T, class U> class ProcessEvent
{
  public:
    ProcessEvent(T* t) : var1(t) { var2 = new U; }
    Process() { var2->Process(var1); }
  private:
    T* var1;
    U* var2;
};

class Foo 
{
  /*data*/
};

class FooProcessor 
{
  void Process(Foo* foo) {/*functionality*/}
};

class Bar
{
  /*data*/
};

class BarProcessor 
{
  void Process(Bar* bar) {/*functionality*/}
};

所以ProcessEvent類可以有兩組不同的模板類型，

ProcessEvent<Foo, FooProcessor>
ProcessEvent<Bar, BarProcessor> 

但是，第二個模板類型FooProcessor和BarProcessor直接由第一個模板類型暗示，並且是用戶不關心的實現細節。 我的目標是擁有與上面相同的功能，但讓ProcessEvent只采用一個模板參數，Foo或Bar。 除了通過ProcessEvent的專業化，這可以做到嗎？

Answer 1

我將假設你為了清晰而簡化，並且真正使用智能指針或者至少正確地管理內存。

最簡單的方法是在第一個類中使用typedef：

class Foo
{
    typedef FooProcessor Processor;
    // Stuff.
};

然后在你的模板中刪除U並使用typename T::Processor代替。

Answer 2

你可以這樣做：

template<typename T>
class Spec 
{
};

template<>
class Spec<Foo>
{
   typedef FooProcessor type;
};

template<>
class Spec<Bar>
{
   typedef BarProcessor type;
};

然后在需要BarProcessor和FooProcessor時分別使用Spec<T>::type ，T = Bar或T = Foo。

Answer 3

我假設FooProcessor只能處理Foo而BarProcessor只能處理Bar，但其他類型可能有多個處理器類。 因此你可以侵入性地做到：

class FooProcessor 
{
public:
   typedef Foo value_type;
};

class BarProcessor
{
public:
   typedef Bar value_type;
};

你可以使用多態：

template< typename T >
class Processor
{
public:
   typedef T value_type;
   virtual ~Processor() {}
   virtual void process( value_type * ) = 0;
};

class FooProcessor : public Processor<Foo>
{
    // implement process
};

您可以使用像Matt Phillips這樣的適配器類，但相反，所以它將進程類作為模板參數：

template<typename T>
class Spec
{        
};

template<> class Spec<FooProcessor>
{           
     typedef Foo type;
};                

template<> class Spec<Bar>        
{           
    typedef BarProcessor type;        
};        

通過侵入式鍵入和Spec適配器鍵入ProcessEvent模板，將處理器類型作為參數，並使用value_type或type派生另一個。

使用多態性，您的ProcessEvent將把對象類型作為參數（Foo或Bar），並傳遞一個處理器，該處理器派生自處理器或處理器以處理事件。

如果要處理大量事件並且它總是使用相同的對象處理它們，后一種方法當然會因為通過v表處理而效率稍低。 它部分取決於它們處理的時間以及是否可以內聯它的功能。