为链表重载 operator+答案

【问题标题】：Overloading operator+ for linked lists为链表重载 operator+
【发布时间】：2020-08-27 07:10:55
【问题描述】：

我是一个初学者，现在我正在尝试实现包含函数 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;
};

【问题讨论】：

cout 被缓存了，试试把`
请提供minimal reproducible example。您实现的运算符是用于Node 而不是iterator？
它不起作用..
还要注意，iterator 不应该是指针类型，除非存储是连续的，比如向量
我们可以看看你的begin函数的实现吗？这将有助于确定正在发生的事情。

标签： c++ linked-list operator-overloading operator-keyword

【解决方案1】：

让我们看看你的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++ 中，您不能在两种基本类型之间重载运算符，因此无法编写一个接受 Node<T>* 和 int 的 operator+ 版本，所以这里的修复是t 就像“让你的 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>*。

希望这会有所帮助！

【讨论】：

【解决方案2】：

iterator 对于链表不能是指针，它需要是这样的：

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;
};

【讨论】：