Перегрузка оператора ++ для увеличения итератора

Question

В настоящее время я создаю квадратный список, и одним из требований является перегрузка оператора pre- и postfix ++.

Я пытался перегрузить оператор ++ в моем файле .hpp, чтобыувеличить итератор.Но при вызове оператора ++ он не вызывает перегруженный код, а просто использует значение по умолчанию.

iterator& operator ++ () {  // pre-increment 
        std::list<int>::iterator i = list_Values.begin(); 
        advance(i,1); 
        return &*i; 
    } 

    iterator operator ++ (int) { // post-increment 
        std::list<int>::iterator i = list_Values.begin(); 
        advance(i,1); 
        return &*i; 
    } 

Я пытаюсь вызвать оператор ++ следующим образом:

int* test = sqrList.begin();
  ++test;

  test++;

Answer 1

int* test = sqrList.begin();
++test;
test++;

Вы увеличиваете int*, и, поскольку нет класса int* для расширения, вы не можете иметь фактически созданных операторов для этого типа.

Вместо этого создайте операторы для правильного типа. Вы, вероятно, хотите создать свой собственный тип Iterator.

Answer 2

Вы должны объявить оператор внутри класса.

class Iterator
{
public:
    Iterator& operator ++ ()
    {
       return *this;
    }
    Iterator operator ++ (int)
    {
       return *this;
    }
};

Кроме того, почему вы используете return &*i;?

Обратите внимание, что эти операторы должны быть объявлены внутри класса Iterator, а не внутри контейнера.

Answer 3

Новичкам иногда трудно понять проблему вне контекста.Поэтому я решил предоставить более или менее полный пример определения пользовательского итератора и перегрузки его операторов.Обратите внимание, что при перегрузке оператора постинкрементного возврата мы возвращаем итератор по значению, а не по ссылке.Конечно, это не реальный пример, в котором мы не будем использовать необработанные указатели.

#include<iostream>
#include<assert.h>

struct node
{
    int data;
    node* next;
    node() :data(0), next(nullptr) {}
    node(int d) :data(d), next(nullptr) {}
};

//forward declaration
class MyList;

class MyListIterator
{
private:
    node* _ptr;
    friend class MyList;
    explicit MyListIterator(node* n) : _ptr(n) {}
public:
    int& operator*() const {
        return _ptr->data;
    }
    //overload pre increment operator
    MyListIterator& operator++() {
        _ptr = _ptr->next;
        return *this;
    }
    // overload post increment operator
    MyListIterator operator++(int) {
        MyListIterator ret = *this;
        ++* (this);
        return ret;
    }

    bool operator==(const MyListIterator& iter) const {
        return this->_ptr == iter._ptr;
    }

    bool operator!=(const MyListIterator& iter) const {
        return this->_ptr != iter._ptr;
    }
};

class MyList
{
private:
    node* _head;
    node* _tail;
    size_t _size;
public:
    MyList() : _head(nullptr), _tail(nullptr), _size(0) {};

    void push_back(int d) {
        node* newTail = new node(d);
        if (_tail != nullptr) {
            _tail->next = newTail;
        }
        else {
            _head = newTail;
        }
        _tail = newTail;
        _size++;
    }

    int& operator[](size_t i) {
        if (i >= _size)
            throw std::out_of_range("MyList");
        node * p = _head;
        for (size_t j = 0; j < i; j++) {
            p = p->next;
        }
        return p->data;
    }

void remove(int d) {
    if (_head == nullptr)
        return;
    node * p = _head;
    node * prev = p;
    while ((p != nullptr) && (p->data != d)) {
        prev = p;
        p = p->next;
    }
    if (p != nullptr) {
        if (p == _head)
            _head = p->next;
        else
            prev->next = p->next;
        delete p;
        _size--;
    }
}

    size_t size() const {
        return _size;
    }

    ~MyList() {
        node* next = nullptr;
        for (node* p = _head; p != nullptr; p = next) {
            next = p->next;
            delete p;
        }
    }
    using iterator = MyListIterator;
    iterator begin() { return iterator(_head); }
    iterator end() { return iterator(_tail->next); }
};

int main()
{

    MyList mylist;
    mylist.push_back(1);
    mylist.push_back(2);
    mylist.push_back(3);
    int count = 1;
    //pre increment
    for (MyListIterator it = mylist.begin(); it != mylist.end(); ++it)
        assert(*it == count++);
    count = 1;
    //post increment
    for (MyListIterator it = mylist.begin(); it != mylist.end(); it++)
        assert(*it == count++);
    for (size_t i = 0; i < 3; i++)
        assert(mylist[i] == i + 1);

    mylist.remove(2);
    assert(mylist[0] == 1);
    assert(mylist[1] == 3);
    assert(mylist.size() ==2);

    mylist.remove(1);
    mylist.remove(3);
    assert(mylist.size() == 0);

}