c++ - 为链表重载 operator+
问题描述
我是一个初学者,现在我正在尝试实现包含函数 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;
}
那么任何人都可以帮助我吗?非常感谢
PS:这里是类节点
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+
接受 aNode<T>*
和 an的版本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>*
在迭代器中的内容。
希望这可以帮助!
推荐阅读
- r - Head() 函数未在 R markdown 中显示输出
- python - 组合两个相互依赖的数据集的最佳方法是什么?
- python - 错误:(-215:断言失败)!函数'cv :: CascadeClassifier ::detectMultiScale'中的empty()
- javascript - 如何忽略 Mustache 模板中的车把表达式?
- java - 如何使用 C++ dlopen 宏从 C++ 代码而不是从 JAVA 加载库
- php - 查看未找到 Laravel
- sql - 如何以最后的NULL值对列进行升序排序?
- python - 使用 SCons 动态重新创建包含文件
- powershell - 如何添加值包含 $ 符号的变量?
- sql - 在 SQL 查询中更新 MariaDB 的 Convert() 操作