Question

我可以这样做吗？

template<class T> struct A {

};

struct B : public A<B::X> {
    typedef string X;
};

特别是，我正在尝试编写一个Enumerator，这是一个迭代器包装器，它还计算包含迭代器值的对象的迭代次数和解除引用次数，并另外提供对计数器的访问权限以及其他一些功能。像这样：

template<class Iterator>
struct Enumerator : public iterator<input_iterator_tag, Enumerator<Iterator>::value_type>
{
    typedef size_t counter_type;

    struct value_type
    {
        counter_type i;
        const typename Iterator::value_type& a;
        value_type(const counter_type& i, const typename Iterator::value_type& a) : i(i), a(a) {}
    };

    counter_type i;

    Iterator it;

    Enumerator() : i(0), it() {}
    Enumerator(const Iterator & it) : i(0), it(it) {}

    bool operator==(const Enumerator& a) const {return this->it==a.it;}
    bool operator!=(const Enumerator& a) const {return this->it!=a.it;}

    Enumerator& operator++() {++this->i; ++this->it; return *this;}
    Enumerator operator++(int) {Enumerator tmp(*this); this->operator++(); return tmp;}

    const value_type& operator*() const {return value_type(i,*this->it);}
};

Answer 1

我可以这样做吗？

不，您不能，因为目前您使用B::X，类型B::X（或类B）并未完全声明。

另一种方法是在A类中添加typedef：

template<class T> struct A {
    typedef T t_type;
};

在您的typedef中

然后B：

struct B : public A<string> {
    typedef t_type X;
};

Live demo

Answer 2

不幸的是不，这是不可能的。因为当您拥有struct B : public A<B::X>时，类型别名B::X尚不存在。

但是，如果您知道X将是什么类型，为什么不使用该实际类型呢？像

struct B : public A<std::string>
{
    typedef std::string X;

    ...
};

或者使B成为模板化结构，并使用模板参数的默认类型：

template<typename T = std::string>
struct B : public A<T>
{
    typedef T X;

    ...
};

Answer 3

不，B此时是不完整的类型，不能在嵌套的名称说明符中使用不完整的类型。

您可以将结构的定义移动到另一个类（下面的EnumeratorBase），然后执行以下操作：

template<class Iterator>
struct Enumerator
    : private EnumeratorBase<Iterator>
    , public iterator<input_iterator_tag, EnumeratorBase<Iterator>::value_type>

{
    using typename EnumeratorBase<Iterator>::value_type;    
};

使用内部类型作为模板参数继承模板类

3 个答案: