我是一个初学者,现在我正在尝试实现包含函数 begin() 的类链表。
该函数很好地返回列表中的第一个元素,但我想做的是在下一个位置返回迭代器,例如:
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:这是类节点
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) {}
};
并列出类
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() {
...
}
此函数返回
Node<T>*
, 指向 Node<T>
的指针目的。结果,当你写list.begin() + 2;
C++ 将其解释为“我有一个指针,并且我有一个数字,所以我会将该指针向前推进适当的步数。”
然后你会问 - 好吧,等一下,为什么不调用这个重载的运算符?
template<class T>
Node<T>* operator+(const Node<T>& iter, const int& pos) {
...
}
看一下参数类型。该函数表示“如果有人尝试将诚实的
Node<T>
对象和 int
相加,这就是我希望你做的事情。”问题是代码list.begin() + 2
不尝试添加诚实至善
Node<T>
对象和一个整数。相反,它添加了一个指向 Node<T>
的指针。对象和一个整数。而且由于这些类型与您的重载运算符不匹配,它甚至不会尝试调用重载运算符。不幸的是,在 C++ 中,您不能在两种基本类型之间重载运算符,因此无法编写
operator+
的版本。接受 Node<T>*
和 int
,所以这里的修复并不像“让你的 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();
};
现在,你可以重载
operator+
在 List<T>::iterator
类型。 operator+
的实现然后可以更新存储的Node<T>*
迭代器内部。希望这可以帮助!
关于c++ - 为链表重载 operator+,我们在Stack Overflow上找到一个类似的问题: https://stackoverflow.com/questions/61734872/