如何避免在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;