Question

我想做这样的事情：

template<class T>
class BaseSubscriber {};

template<class T>
class BasePublisher
{
    // not working : invalid use of template-name 'BaseSubscriber' without an argument list
    typedef BaseSubscriber SubscriberType;

    // compiling
    typedef BaseSubscriber<T> SubscriberTypeT;
};


template< template<class T> class Subscriber, class Data >
class ClassA:
    public Subscriber<Data> 
{
};

template< template<class T> class Publisher, class Data >
class ClassB:
    public Publisher<Data>  
{
    // Ok, but I want that the type "BaseSubscriber" depends on the template parameter Publisher
    void method1(ClassA<BaseSubscriber, Data>&);


    // I want something like that. But how to define SubscriberType ?
    void method2(ClassA<Publisher<Data>::SubscriberType, Data>&);
    // or (SubscriberType only depends on the Publisher, nor on the Data)
    void method2(ClassA<Publisher::SubscriberType, Data>&);


    // Error : template argument is invalid
    void method3(ClassA<Publisher::SubscriberTypeT, Data>&);
};

是否可以定义一些可用于SubscriberType模板参数的classA？或者有任何解决方法吗？

如果可能的话，我想保留classA原型。我不想在

中更改它

template<class TSubscriber > classA {};

我不能使用C ++ 11。非常感谢您的回答。

Answer 1

当你说：

时，你的意思有点混乱

// I want something like that. But how to define SubscriberType ?
void method2(ClassA<Publisher::SubscriberType>);

由于Publisher是一个模板，但你没有传递任何参数。

无论如何，这里有一些选择：

在C ++ 11中，您可以使用模板别名：

template<class T>
class BasePublisher
{
    template<typename U>
    using SubscriberType = BaseSubscriber<U>;
};

您还可以使用嵌套类：

template<class T>
class BaseSubscriber {};

template<class T>
class BasePublisher
{
    template<class U>
    class BaseSubscriber {};
};

或者更改ClassA以使用type成员：

template<class T>
class BasePublisher
{
    template<class U>
    struct SubscriberType {
        typedef BaseSubscriber<U> type;
    };
};

template< template<class T> class SubscriberT >
class ClassA {
    typedef typename SubscriberT::type Subscriber;
};

或者，如果您不需要别名，有时继承会起作用：

template<class T>
class BasePublisher
{
    template<class U>
    struct SubscriberType : BaseSubscriber<U> {};
};

Answer 2

C ++ 03中不允许使用模板别名，尽管它们在C ++ 11中。

你的目标是能够做到：

typename BaseSubscriber<A>::SubscriberType<B>

在C ++ 03中你应该使用嵌套类：

template< typename T > struct BasePublisher
{
   template< typename U > struct Subscriber
   {
       typedef BaseSubcriber<U> type;
   };
};

现在你可以做typename BasePublisher :: Subscriber :: type;

在C ++ 11中，语法为：

template < typename T > struct BasePublisher
{
   template< typename U > using SubscriberType = BaseSubscriber<U>;
};

目前还没有很多编译器支持这一点。虽然你不能做typename typename，但它可能需要另一个typedef。

Answer 3

如果我理解正确，您希望ClassA在BaseSubscriber的实例化中获得BaseSubscriber<my_tag>的实例化，例如ClassB和BasePublisher。这是对的吗？

如果你的答案是肯定的，那么为什么你宣布template和ClassA的{{1}}参数作为模板，你不想在{{1}中对它做任何事情}或ClassB，所以它应该是一个不是模板化类的类：

ClassA

没有模板重新绑定的typedef模板。用作模板类参数的模板

3 个答案: