為鏈表重載 operator+

Question

我是初學者，現在我正在嘗試實現包含 function begin() 的 class 鏈表。 function 很好地返回了列表中的第一個元素，但我想做的是在下一個 position 上返回迭代器，例如像這樣：

List<int>::iterator iter2 = a.begin() + 2; // or iter2 = iter2 + 1;
cout <<iter2->data;

output 是像 21213123 這樣的垃圾。

所以在這里我想我應該使用運算符重載+，這是我的 function：

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：這里是 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;
};

Answer 1

讓我們來看看你的begin function：

typedef Node<T>* iterator;
iterator begin() {
    ...
}

這個 function 返回一個Node<T>* ，一個指向Node<T> object 的指針。 結果，當你寫

list.begin() + 2;

C++ 將其解釋為“我有一個指針，我有一個數字，所以我會將該指針向前推進適當的步數。”

然后你會問 - 好吧，等一下，為什么不調用這個重載的運算符？

template<class T>
Node<T>* operator+(const Node<T>& iter, const int& pos) {
    ...
}

看一下參數類型。 這個 function 說“如果有人試圖將一個誠實的Node<T> object 和一個int相加，這就是我希望你做的。” 問題是代碼

list.begin() + 2

不會嘗試添加誠實至善的Node<T> object 和 integer。 相反，它添加了一個指向Node<T> object 和 integer 的指針。 而且由於這些類型與您的重載運算符不匹配，它甚至不會嘗試調用重載運算符。

不幸的是，在 C++ 中，您不能在兩種基本類型之間重載運算符，因此無法編寫一個接受Node<T>*和int的operator+版本，因此這里的修復不像“只需讓您的operator+ function 接受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>* 。

希望這可以幫助！

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