Question

我试图实现一个“模板模板模板” - 模板类来满足我的需求（我在使用模板元编程时很新）。不幸的是，我发现以下主题太晚了： Template Template Parameters

然而，我需要实现下面列出的内容。

根据编译器，最后一个typedef不起作用。我不确定，但我认为这是由于3x模板限制的限制。在这个简单的例子中是否有可能绕过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

是的，可以避免模板模板参数（任何级别）。

模板基本上是一个类型级函数。你给它一个类型，然后再回到另一种类型。

模板模板参数本身就是一个类型级函数，接受这种参数的模板是一个高阶类型级函数。

可以使用成员模板实现更高阶的类型级函数，而无需使用模板模板参数。我不确定你的设计需要它，但这是一个快速而肮脏的例子：

// 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;

Answer 3

在这种情况下你真的不需要模板参数，基本上唯一的变量类型是TValueType吗？可以使用TValueType在类主体上解析其他类型。

这样的事情：

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

如何避免使用c ++中的“模板模板模板”模板

3 个答案: