如何避免在c + +中的「模板模板模板」模板

Question

我試圖實現一個「模板模板模板」 - 模板類滿足我的需求（我是使用模板元編程相當新的）。不幸的是，我發現以下主題已經太晚了： Template Template Parameters

不過，我需要實現類似下面列出的內容。

根據編譯器，最後一個typedef不起作用。我不確定，但我認爲這是由於3倍模板限制的限制。在這個簡單的例子中是否有可能繞過3xtemplate定義？

template < typename TValueType > 
class ITTranslator 
{ 
public: 
    ITTranslator() = 0; 
    virtual ~ITTranslator() = 0; 
    virtual void doSomething() = 0; 
} 

template < typename TValueType > 
class TConcreteTranslator1 : public ITTranslator<TValueType> 
{ 
public: 
    TConcreteTranslator1(){} 
    ~TConcreteTranslator1(){} 
    void doSomething() {} 
} 

template < typename TValueType > 
class TConcreteTranslator2 : public ITTranslator<TValueType> 
{ 
public: 
    TConcreteTranslator2(){} 
    ~TConcreteTranslator2(){} 
    void doSomething() {} 
} 

template < 
    typename TValueType, 
    template < typename TValueType > class TTranslatorValueType 
    > 
class ITClassifier 
{ 
public: 
    ITClassifier() = 0; 
    virtual ~ITClassifier() = 0; 
} 

template < 
    typename TValueType, 
    template < typename TValueType > class TTranslatorValueType 
    > 
class TConcreteClassifier1 : public ITClassifier<TValueType,TTranslatorValueType > 
{ 
public: 
    TConcreteClassifier1() {} 
    ~TConcreteClassifier1() {} 
    void dodo(){} 
} 


template < 
    typename TValueType, 
    template <typename TValueType> class TTranslatorValueType, 
    template <template<typename TValueType> class TTranslatorValueType> class TClassifierValueType 
> 
class ITAlgorithm 
{ 
public: 
    ITAlgorithm()=0; 
    virtual ~TAlgorithm()=0; 
    virtual run() = 0; 
} 


template < 
    typename TValueType, 
    template <typename TValueType> class TTranslatorValueType, 
    template <template<typename TValueType> class TTranslatorValueType> class TClassifierValueType 
> 
class TConcreteAlgorithm1 : public ITAlgorithm<TValueType,TTranslatorValueType,TTranslatorValueType> 
{ 
public: 
    TConcreteAlgorithm1(){} 
    ~TConcreteAlgorithm1(){} 
    run() 
    { 
     TClassifierValueType< TTranslatorValueType>* l_classifier_pt = new TClassifierValueType< TTranslatorValueType>(); 
     // add this object to a internal list... 
    } 
} 



int main() 
{ 
    typedef TConcreteTranslator1<cvbase::uint32_t> translator_t; 
    typedef TConcreteClassifier1< cvbase::uint32_t, TConcreteTranslator1> classifier_t; 
    typedef TConcreteAlgorithm1 < cvbase::uint32_t, TConcreteTranslator1, TConcreteClassifier1> algorithm_t; // not possible 
    return 0; 
} 

非常感謝，我非常感謝任何幫助！

編輯： 我已經延長我的清單（我敢肯定它不會編譯:)）顯示的動機，爲什麼我用我的奇怪概念:)

Answer 1

實在是沒有必要通過模板的模板參數在這裏 。通常你可以只取一個正常的模板參數，並提供 一個合理的默認：

template<typename ValueType> 
struct translator {}; 

template<typename ValueType, typename Translator = translator<ValueType>> 
struct Classifier {}; 

template<typename ValueType, 
     typename Translator = translator<ValueType>, 
     typename Classifier = classifier<ValueType, Translator> 
     > 
struct Algorithm {}; 

這樣做是對分配意識到容器相同的方式。

請儘量避免可怕的匈牙利符號前綴。

注意：從您對構造函數和析構函數的使用看來，您對 沒有掌握基本的C++。在理解更簡單的概念之前，您可能希望從模板中遠離 。

Answer 2

在這種情況下，你並不真的需要有模板參數，基本上唯一的變量類型是TValueType正確嗎？ 其他類型可以使用TValueType在類體上解析。

事情是這樣的：

template < 
    typename TValueType 
> 
class TAlgorithm 
{ 
public: 
    // TTranslator <TValueType> whatever 
    // TTranslatorValueType <TValueType> whatever 
    TAlgorithm(){} 
    ~TAlgorithm(){} 
} 

Answer 3

是的，可以避免模板模板參數（任何級別）。

模板基本上是一個類型級別的函數。你餵它一種類型，並獲得另一種類型。

模板模板參數本身是一個類型級函數，接受這種參數的模板是一個高階類型級函數。

可以使用成員模板實現更高階的類型級函數，而無需使用模板模板參數。我不確定你是否需要它用於你的設計，但這裏有一個快速和骯髒的例子：

// regular type, a.k.a. zeroth-order type-level function, 
// a.k.a. "type of kind *" 
struct N 
{ 
    int a; 
}; 

// a first-order type-level function, a.k.a. "type of kind *->*" 
// it is wrapped in a regular type 
struct B 
{ 
    template <class A> struct Impl 
    { 
     void foo(A a) 
     { 
      int aa = a.a; 
     } 
    }; 
}; 

// a second-order type-level function 
// that accepts a (wrapped) first-order type function 
// and also a regular type. the kind of it would be (*->*)->*->* 
// it applies its first argument to its second argument 
struct Z 
{ 
    template <class X, class Y> struct Impl 
    { 
     typename X::template Impl<Y> ya; 
     void bar() 
     { 
      ya.foo(Y()); 
     } 
    }; 
}; 

// now this is something: a third-order type-level function 
// that accepts a (wrapped) second-order type-level function 
// and a (wrapped) first-order type-level function 
// and a zeroth-order type-level function 
// it applies its first argument to its second and third arguments 
// it is also wrapped in a regular type for consistency 
// try to figure out its kind 
struct T 
{ 
    template <class P, class Q, class R> struct Impl 
    { 
     typename P::template Impl<Q, R> yb; 
     void baz() 
     { 
      yb.bar(); 
     } 
    }; 
}; 

T::Impl<Z, B, N> tt;