-1

我写了一个类，我想为它实现一个迭代器（如下代码所示）。我需要重载各种运算符，我遇到了下面提到的错误：

class BaseClass
{
    virtual ~BaseClass() {}
};

template<class T>
class AbstractBaseOrgan: public BaseClass
{
public:
    typedef T value;
    template<class TT>
    class AbstractBaseIterator:
        public std::iterator<std::random_access_iterator_tag,
        typename std::iterator_traits<TT>::value_type>
    {
    protected:
        TT _M_current;
        const TT&
        base() const
        { return this->_M_current; }
    };
protected:
    value te;
};


template<typename Iter>
inline bool
operator<(const typename AbstractBaseOrgan<typename 
    std::iterator_traits<Iter>::value_type>::template 
    AbstractBaseIterator<Iter>& lhs,
    const typename AbstractBaseOrgan<typename 
    std::iterator_traits<Iter>::value_type>::template 
    AbstractBaseIterator<Iter>& rhs)
{ return lhs.base() < rhs.base(); }

int main()
{
    AbstractBaseOrgan<int>::AbstractBaseIterator<int*> temp;
    AbstractBaseOrgan<int>::AbstractBaseIterator<int*> temp2;
    int ttemp;
    if(operator< (temp,temp2))
        ttemp = 0;
    return 0;
}

编译它会给我以下错误：

error: no matching function for call to ‘operator<(AbstractBaseOrgan<int>::AbstractBaseIterator<int*>&, AbstractBaseOrgan<int>::AbstractBaseIterator<int*>&)’

知道是什么原因造成的吗？

4

1 回答 1

1

4 在大多数情况下，用于构成 P 的类型、模板和非类型值参与模板参数推导。也就是说，它们可用于确定模板参数的值，并且如此确定的值必须与其他地方确定的值一致。然而，在某些情况下，该值不参与类型推导，而是使用在其他地方推导或明确指定的模板参数的值。如果模板参数仅在非推导上下文中使用且未明确指定，则模板参数推导失败。

非推导上下文是： — 使用限定 ID 指定的类型的嵌套名称说明符。

您可以通过几种方式避免这种情况。第一种方式 - 为类 AbstractIteratorBase 或其成员创建 operator < 朋友。

template<class TT>
class AbstractBaseIterator:
    public std::iterator<std::random_access_iterator_tag,
    typename std::iterator_traits<TT>::value_type>
{
    public:
        template<typename Iter>
        friend bool operator < (const AbstractBaseIterator<Iter>& lhs, const AbstractBaseIterator<Iter>& rhs)
        {
            return lhs.base() < rhs.base();
        }
protected:
    TT _M_current;
    const TT&
    base() const
    { return this->_M_current; }
};

第二个变体是在模板类中定义 AbstractBaseIterator 类。然后typedef AbstractBaseIterator<T> iterator;在 AbstractBaseOrgan 中。如果你可以使用 C++11，你可以使用类似的东西。

class BaseClass
{
    virtual ~BaseClass() {}
};

template<class TT>
class AbstractBaseIterator:
public std::iterator<std::random_access_iterator_tag,
typename std::iterator_traits<TT>::value_type>
{
protected:
    TT _M_current;
    const TT&
    base() const
    { return this->_M_current; }
};

template<typename Iter>
bool operator < (const AbstractBaseIterator<Iter>& lhs, const AbstractBaseIterator<Iter>& rhs)
{
   return lhs.base() < rhs.base();
}

template<class T>
class AbstractBaseOrgan: public BaseClass
{
public:
    typedef T value;
    template<typename TT>
    using iterator = AbstractBaseIterator<TT>;
protected:
    value te;
};

int main()
{
    AbstractBaseOrgan<int>::iterator<int*> temp;
    AbstractBaseOrgan<int>::iterator<int*> temp2;
    int ttemp;
    if(operator< (temp,temp2))
        ttemp = 0;
    return 0;
}
于 2012-07-30T15:52:14.757 回答