对于std :: reverse_iterator c ++,operator!=不明确
Posted
tags:
篇首语:本文由小常识网(cha138.com)小编为大家整理,主要介绍了对于std :: reverse_iterator c ++,operator!=不明确相关的知识,希望对你有一定的参考价值。
我正在研究一个实现自己的迭代器的容器,我正在使用它与std :: reverse_iterator <>来获得反向迭代功能。我可以将反向迭代器分配给rend或rbegin,但是当我尝试访问它的任何功能(例如!=或==)时,我得到:
1 IntelliSense: more than one operator "!=" matches these operands:
function template "bool std::operator!=(const std::reverse_iterator<_RanIt1> &_Left, const std::reverse_iterator<_RanIt2> &_Right)"
function template "bool avl::operator!=(const tree &left, const tree &right)"
operand types are: std::reverse_iterator<avl::avl_iterator<avl::avltree<char, int, std::less<char>, std::allocator<std::pair<const char, int>>>>> != std::reverse_iterator<avl::avl_iterator<avl::avltree<char, int, std::less<char>, std::allocator<std::pair<const char, int>>>>>
我的迭代器运算符重载:
bool operator == ( const avl_iterator& rhs ) const { return ( _node == rhs._node); }
bool operator != ( const avl_iterator& rhs ) const { return ( _node != rhs._node); }
和我的反向迭代器的实现
typedef typename avl_iterator< tree > iterator;
typedef typename const_avl_iterator< tree > const_iterator;
typedef typename std::reverse_iterator<iterator> reverse_iterator;
typedef typename std::reverse_iterator<const_iterator> const_reverse_iterator;
和迭代器typedef:
typedef typename tree::node node;
typedef typename tree::node_ptr node_ptr;
typedef typename tree::value_type* pointer;// for std reverse iterator
typedef typename tree::value_type& reference;
typedef typename tree::const_node_ptr const_node_ptr;
typedef typename tree::utilities utilities;
typedef typename tree::value_type value_type;
typedef std::bidirectional_iterator_tag iterator_category;
typedef std::ptrdiff_t difference_type;
我是如何使用运营商的
avltree<char,int> myTree;
myTree.insert(std::pair<char,int>('a',1));
myTree.insert(std::pair<char,int>('b',2));
myTree.insert(std::pair<char,int>('c',3));
avltree<char,int>::reverse_iterator rit = myTree.rbegin();
for(; rit != myTree.rend(); ++rit) //fails on this line
{
}
和iterator类(const_iterator是相同的东西,但有一个const value_type)
template <class tree>
class avl_iterator {
public:
typedef typename tree::node node;
typedef typename tree::node_ptr node_ptr;
typedef typename tree::value_type* pointer;// for std reverse iterator
typedef typename tree::value_type& reference;
typedef typename tree::const_node_ptr const_node_ptr;
typedef typename tree::utilities utilities;
typedef typename tree::value_type value_type;
typedef std::bidirectional_iterator_tag iterator_category;
typedef std::ptrdiff_t difference_type;
private:
friend class const_avl_iterator<tree>;
node_ptr _node;
public:
avl_iterator() : _node() { }
avl_iterator( const node_ptr node ) : _node ( node ) { }
avl_iterator( const avl_iterator& iterator ) {
(*this) = iterator;
}
~avl_iterator() { _node = NULL; }
avl_iterator& operator=(const avl_iterator& rhs) {
_node = rhs._node;
return (*this);
}
avl_iterator& operator=(const const_avl_iterator<tree>& rhs) {
_node = rhs._node;
return (*this);
}
bool operator == ( const avl_iterator& rhs ) const { return ( _node == rhs._node); }
bool operator != ( const avl_iterator& rhs ) const { return ( _node != rhs._node); }
avl_iterator& operator++()
{
_node = utilities::next_node( _node );
return (*this);
}
avl_iterator operator ++( int ) {
avl_iterator temp(*this);
++(*this);
return(temp);
}
avl_iterator& operator -- () {
_node = utilities::prev_node( _node );
return (*this);
}
avl_iterator operator -- ( int ) {
avl_iterator temp(*this);
--(*this);
return(temp);
}
value_type& operator * () const {
assert( ! utilities::is_header( _node ) );
return _node->_value;
}
value_type* operator -> () const {
assert( ! utilities::is_header( _node ) );
return &_node->_value;
}
};
和树类:
template <
class Key,
class Type,
class Traits = std::less<Key>,
class Allocator = std::allocator<std::pair<Key const, Type>>
>
class avltree {
private:
typedef avltree< Key, Type, Traits, Allocator> tree;
public:
typedef std::pair<const Key, Type> value_type;
typedef Allocator allocator_type;
typedef typename allocator_type::size_type size_type;
typedef typename allocator_type::reference reference;
typedef Key key_type;
typedef Type mapped_type;
typedef Traits key_compare;
typedef typename avl_node< tree > node;
typedef typename node::node_ptr node_ptr;
typedef typename node::const_node_ptr const_node_ptr;
typedef typename avl_utilities< tree > utilities;
typedef typename avl_iterator< tree > iterator;
typedef typename const_avl_iterator< tree > const_iterator;
typedef typename std::reverse_iterator<iterator> reverse_iterator;
typedef typename std::reverse_iterator<const_iterator> const_reverse_iterator;
private:
node_ptr _header;
std::size_t _size;
key_compare _comparer;
allocator_type _alloc;
public:
//c'tors and d'tors
//*******************************************************
//Iterators
//*******************************************************
iterator begin() { return iterator( node::get_left( _header ) ); }
const_iterator begin() const { return const_iterator( node::get_left( _header ) ); }
const_iterator cbegin() const { return const_iterator( node::get_left( _header ) ); }
iterator end() { return iterator( _header ); }
const_iterator end() const { return const_iterator( _header ); }
const_iterator cend() const { return const_iterator( _header ); }
reverse_iterator rbegin() { return reverse_iterator( _header ); }
const_reverse_iterator rbegin() const { return const_reverse_iterator( _header ); }
const_reverse_iterator crbegin() const { return const_reverse_iterator( _header ); }
reverse_iterator rend() { return reverse_iterator( node::get_left( _header ) ); }
const_reverse_iterator rend() const { return const_reverse_iterator( node::get_left( _header ) ); }
const_reverse_iterator crend() const { return const_reverse_iterator( node::get_left( _header ) ); }
bool operator==(const tree& right)
{
if(_size != right.size())
{
return false;
}
const_iterator lhs = cbegin();
const_iterator rhs = right.cbegin();
while(lhs != cend() && rhs != right.cend() )
{
if(lhs->first != rhs->first || lhs->second != rhs->second)
{
return false;
}
++lhs;
++rhs;
}
return true;
}
bool operator!=(const tree& right)
{
return (!(*this == right));
}
bool operator<(const tree& right)
{
const_iterator lhs = cbegin();
const_iterator rhs = right.cbegin();
while(lhs != cend() && rhs != right.cend() )
{
if(lhs->first != rhs->first || lhs->second != rhs->second)
{
if(lhs->first < rhs->first || lhs->second < rhs->second)
{
return true;
}
}
++lhs;
++rhs;
}
return false;
}
bool operator>(const tree& right)
{
return ( right < *this );
}
bool operator<=(const tree& right)
{
return ( !(right < *this) );
}
bool operator>=(const tree& right)
{
return ( !(*this < right) );
}
};
//*******************************************************
//Relation Operators
//*******************************************************
template<class tree>
bool operator==(const tree& left,const tree& right)
{
if(left.size() != right.size())
{
return false;
}
tree::const_iterator lhs = left.cbegin();
tree::const_iterator rhs = right.cbegin();
while(lhs != left.cend() && rhs != right.cend() )
{
if(lhs->first != rhs->first || lhs->second != rhs->second)
{
return false;
}
++lhs;
++rhs;
}
return true;
}
template<class tree>
bool operator!=(const tree& left,const tree& right)
{
return (!(left == right));
}
template<class tree>
bool operator<(const tree& left,const tree& right)
{
tree::const_iterator lhs = left.cbegin();
tree::const_iterator rhs = right.cbegin();
while(lhs != left.cend() && rhs != right.cend() )
{
if(lhs->first != rhs->first || lhs->second != rhs->second)
{
if(lhs->first < rhs->first || lhs->second < rhs->second)
{
return true;
}
}
++lhs;
++rhs;
}
return false;
}
template<class tree>
bool operator>(const tree& left,const tree& right)
{
return ( right < left );
}
template<class tree>
bool operator<=(const tree& left,const tree& right)
{
return ( !(right < left) );
}
template<class tree>
bool operator>=(const tree& left,const tree& right)
{
return ( !(left < right) );
}
}//end namespace avl
在这一行:
rit != myTree.rend()
您正在比较两个类型的对象:
avltree<char,int>::reverse_iterator
这又是别名:
std::reverse_iterator<avl_iterator<char, int>::iterator>
C ++标准库在std::
命名空间中定义了一个模板化的operator !=
,它与比较反向迭代器完全匹配(参见C ++ 11标准的第24.5节):
template <class Iterator1, class Iterator2>
bool operator!=(
const reverse_iterator<Iterator1>& x,
const reverse_iterator<Iterator2>& y)
但是,你也有这个:
template<class tree> bool operator!=(const tree& left,const tree& right)
由于模板不受约束(即使模板参数名为tree
,这并不意味着模板只接受树),这也是完全匹配,但反向迭代器的模板化operator !=
仍然更加专业化。
因此,呼叫不应该含糊不清。我认为这是一个编译器错误。
要解决这个问题,请确保树的不等运算符只接受树,这无论如何都是一个好主意(你真的不希望你的运算符毕竟比较任何东西):
template<class T> bool operator!=(const avltree<T>& left,const avltree<T>& right)
您的operator !=
会尝试比较任何时间,包括reverse_iterator
s,您可以尝试使用
template<class T> bool operator!= (const avltree<T>& left,const avltree<T>& right) {
return (!(left == right));
}
看起来像一个破碎的编译器。
template<typename Iter>
bool std::operator!=(const std::reverse_iterator<Iter>&,
const std::reverse_iterator<Iter>&);
是“更专业”
template<class tree>
bool avl::operator!=(const tree&, const tree&);
所以表达式rit != myTree.rend()
不应该含糊不清。
仍然,声明可以将!=
应用于任何两个相同类型的对象的东西是一个危险的想法。
您尝试将const_reverse_iterator与reverse_iterator进行比较,对rend()的调用将始终使用非const重载(如果可用)。解决这个问题应该是显而易见的。如果我没记错的话,一些早期的std :: set实现存在同样的问题。
无论如何,有一个很好的方法可以解决这个问题,而恕我直言更优雅:
for(container::iterator it=c.begin(), end=c.end(); it!=end; ++it)
...
换句话说,始终使用在for-loop的头中声明的一对迭代器。使用C ++ 11的“自动”,这变得更短。虽然使用任何中途 - 现代编译器对end()的单次调用并不快,但我个人觉得它更清晰一点。
以上是关于对于std :: reverse_iterator c ++,operator!=不明确的主要内容,如果未能解决你的问题,请参考以下文章
C++ rbegin 修改reverse_iterator的地址