为链表重载 operator+
Overloading operator+ for linked lists
我是初学者,现在我正在尝试实现包含函数 begin() 的 class 链表。
函数 return 是列表中的第一个元素,但我想做的是 return 下一个位置的迭代器,例如这样的事情:
List<int>::iterator iter2 = a.begin() + 2; // or iter2 = iter2 + 1;
cout <<iter2->data;
输出是垃圾,如 21213123..
所以在这里我想我应该使用运算符重载+,这是我的函数:
template<class T>
Node<T>* operator+(const Node<T>& iter, const int& pos)
{
cout << "in"; for testing, but seems that doesnt even entry here
return NULL;
}
所以有人可以帮助我吗?非常感谢
P.S:这里是class节点
template<class T>
class Node {
public:
T data;
Node* next;
Node() :data(0), next(NULL) {}
Node(T val, Node<T>* pointer = NULL) :data(val), next(pointer) {}
};
并列出 class
template<class T>
class List {
public:
typedef Node<T>* iterator;
typedef const Node<T>* const_iterator;
//constructors
List() { item = NULL; counter = 0; }
explicit List(int val) :counter(1) { item = new Node<T>(val); }
~List() { // to be made
}
//public functions
int size() { return counter; }
iterator begin() {
return item;
}
iterator end()
{
iterator last = item;
while (last->next != NULL)
{
last = last->next;
}
return last;
}
void push_front(const int& val) {
iterator newNode = new Node<T>(val, item);
item = newNode;
counter++;
}
void append(const int& val)
{
iterator newnode = new Node<T>(val);
newnode->next = NULL;
iterator last = item;
if (item == NULL)
{
item = newnode;
return;
}
while (last->next != NULL)
last = last->next;
last->next = newnode;
counter++;
}
int operator[](const int&);
private:
iterator item;
int counter;
};
让我们看看您的 begin
函数:
typedef Node<T>* iterator;
iterator begin() {
...
}
这个函数returns一个Node<T>*
,一个指向Node<T>
对象的指针。结果,当你写
list.begin() + 2;
C++ 将其解释为 "I've got a pointer, and I've got a number, so I'll step that pointer forward the appropriate number of steps."
然后您会问 - 好吧,等一下,为什么这个重载的运算符没有被调用?
template<class T>
Node<T>* operator+(const Node<T>& iter, const int& pos) {
...
}
看看参数类型。这个函数说 "if someone tries adding together an honest-to-goodness Node<T>
object and an int
, here's what I'd like you to do." 问题是代码
list.begin() + 2
不会尝试添加一个诚实至善的 Node<T>
对象和一个整数。相反,它将 指针 添加到 Node<T>
对象和一个整数。由于这些类型与您的重载运算符不匹配,它甚至不会尝试调用重载运算符。
不幸的是,在 C++ 中,您不能重载两个原始类型之间的运算符,因此无法编写接受 Node<T>*
和 [=19= 的 operator+
版本],所以这里的修复不像“让你的 operator+
函数接受 Node<T>*
.
那么简单
相反,我建议让您的 iterator
键入实际的 class
或 struct
而不是原始指针。您的迭代器可能会通过跟踪指向某个 Node<T>
某处的指针来工作,但从根本上说,迭代器实际上不仅仅是该指针本身。例如,您可以尝试这样的操作:
template <class T>
class List {
public:
class iterator {
public:
// some other things, and
iterator operator+ (int step) const;
private:
// some other things, and
Node<T>* current;
};
// some other things, and
iterator begin();
};
现在,您可以在 List<T>::iterator
类型上重载 operator+
。 operator+
的实现可以更新迭代器中存储的 Node<T>*
。
希望对您有所帮助!
iterator
for a linked list 不能是指针,它需要
是这样的:
struct iterator
{
typedef int difference_type;
typedef T* pointer;
typedef T& reference;
typedef iterator_category std::bidirectional_iterator_tag
iterator();
iterator& operator++();
iterator& operator--();
iterator operator++(int);
iterator operator--(int);
T& operator*();
T* operator->();
bool operator==(iterator rhs) const;
bool operator!=(iterator rhs) const;
private:
iterator(Node*);
Node* node;
};
我是初学者,现在我正在尝试实现包含函数 begin() 的 class 链表。 函数 return 是列表中的第一个元素,但我想做的是 return 下一个位置的迭代器,例如这样的事情:
List<int>::iterator iter2 = a.begin() + 2; // or iter2 = iter2 + 1;
cout <<iter2->data;
输出是垃圾,如 21213123..
所以在这里我想我应该使用运算符重载+,这是我的函数:
template<class T>
Node<T>* operator+(const Node<T>& iter, const int& pos)
{
cout << "in"; for testing, but seems that doesnt even entry here
return NULL;
}
所以有人可以帮助我吗?非常感谢
P.S:这里是class节点
template<class T>
class Node {
public:
T data;
Node* next;
Node() :data(0), next(NULL) {}
Node(T val, Node<T>* pointer = NULL) :data(val), next(pointer) {}
};
并列出 class
template<class T>
class List {
public:
typedef Node<T>* iterator;
typedef const Node<T>* const_iterator;
//constructors
List() { item = NULL; counter = 0; }
explicit List(int val) :counter(1) { item = new Node<T>(val); }
~List() { // to be made
}
//public functions
int size() { return counter; }
iterator begin() {
return item;
}
iterator end()
{
iterator last = item;
while (last->next != NULL)
{
last = last->next;
}
return last;
}
void push_front(const int& val) {
iterator newNode = new Node<T>(val, item);
item = newNode;
counter++;
}
void append(const int& val)
{
iterator newnode = new Node<T>(val);
newnode->next = NULL;
iterator last = item;
if (item == NULL)
{
item = newnode;
return;
}
while (last->next != NULL)
last = last->next;
last->next = newnode;
counter++;
}
int operator[](const int&);
private:
iterator item;
int counter;
};
让我们看看您的 begin
函数:
typedef Node<T>* iterator;
iterator begin() {
...
}
这个函数returns一个Node<T>*
,一个指向Node<T>
对象的指针。结果,当你写
list.begin() + 2;
C++ 将其解释为 "I've got a pointer, and I've got a number, so I'll step that pointer forward the appropriate number of steps."
然后您会问 - 好吧,等一下,为什么这个重载的运算符没有被调用?
template<class T>
Node<T>* operator+(const Node<T>& iter, const int& pos) {
...
}
看看参数类型。这个函数说 "if someone tries adding together an honest-to-goodness Node<T>
object and an int
, here's what I'd like you to do." 问题是代码
list.begin() + 2
不会尝试添加一个诚实至善的 Node<T>
对象和一个整数。相反,它将 指针 添加到 Node<T>
对象和一个整数。由于这些类型与您的重载运算符不匹配,它甚至不会尝试调用重载运算符。
不幸的是,在 C++ 中,您不能重载两个原始类型之间的运算符,因此无法编写接受 Node<T>*
和 [=19= 的 operator+
版本],所以这里的修复不像“让你的 operator+
函数接受 Node<T>*
.
相反,我建议让您的 iterator
键入实际的 class
或 struct
而不是原始指针。您的迭代器可能会通过跟踪指向某个 Node<T>
某处的指针来工作,但从根本上说,迭代器实际上不仅仅是该指针本身。例如,您可以尝试这样的操作:
template <class T>
class List {
public:
class iterator {
public:
// some other things, and
iterator operator+ (int step) const;
private:
// some other things, and
Node<T>* current;
};
// some other things, and
iterator begin();
};
现在,您可以在 List<T>::iterator
类型上重载 operator+
。 operator+
的实现可以更新迭代器中存储的 Node<T>*
。
希望对您有所帮助!
iterator
for a linked list 不能是指针,它需要
是这样的:
struct iterator
{
typedef int difference_type;
typedef T* pointer;
typedef T& reference;
typedef iterator_category std::bidirectional_iterator_tag
iterator();
iterator& operator++();
iterator& operator--();
iterator operator++(int);
iterator operator--(int);
T& operator*();
T* operator->();
bool operator==(iterator rhs) const;
bool operator!=(iterator rhs) const;
private:
iterator(Node*);
Node* node;
};