C++ 重载++；运算符以递增迭代器

我目前正在创建一个方形列表，其中一个要求是重载pre-and-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; 
    } 

---

必须在类内声明运算符

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

还有，为什么要使用

return&*i

请注意，这些运算符需要在迭代器类中声明，而不是在容器中声明。
必须在类中声明运算符

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

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

还有，为什么要使用
return&*i

请注意，这些运算符需要在
迭代器
类中声明，而不是在容器中声明

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

您正在递增一个
int*
，并且由于没有要扩展的
int*
类，因此您不可能实际为该类型创建运算符

而是为正确的类型创建运算符。您可能想创建自己的迭代器类型

您正在递增一个
int*
，并且由于没有要扩展的
int*
类，因此您不可能实际为该类型创建运算符

而是为正确的类型创建运算符。您可能想创建自己的迭代器类型。
对于新手来说，有时很难断章取义地理解问题。因此，我决定提供一个定义自定义迭代器并重载其运算符的或多或少完整的示例。
注意，当重载后增量运算符时，我们按值返回迭代器，而不是按引用返回迭代器。
当然，这不是一个真实的例子，我们不会使用原始指针

#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);

}

#包括
#包括
结构节点
{
int数据；
节点*下一步；
node（）：数据（0），下一个（nullptr）{}
节点（intd）：数据（d），下一个（nullptr）{
};
//远期申报
类MyList；
类标识符
{
私人：
节点*\u ptr；
朋友级MyList；
显式MyListIterator（节点*n）：\u ptr（n）{}
公众：
整型运算符*（）常量（&O）{
返回_ptr->数据；
}
//重载预增量运算符
MyListIterator和运算符++（）{
_ptr=_ptr->next；
归还*这个；
}
//重载后增量运算符
MyListIterator运算符++（int）{
MyListIterator ret=*此；
++*（本条）；
返回ret；
}
布尔运算符==（常量MyListIterator和iter）常量{
返回此->\u ptr==iter.\u ptr；
}
布尔运算符！=（常量MyListIterator和iter）常量{
返回此->\u ptr！=iter.\u ptr；
}
};
类MyList
{
私人：
节点*头；
节点*_尾；
大小(t)大小;；
公众：
MyList（）：_head（nullptr），_tail（nullptr），_size（0）{}；
无效推回（int d）{
节点*newTail=新节点（d）；
如果（_tail！=nullptr）{
_tail->next=newTail；
}
否则{
_头=新尾；
}
_尾=新尾；
_大小++；
}
整数和运算符[]（大小\u t i）{
如果（i>=\u大小）
抛出标准：：超出范围（“MyList”）；
节点*p=_头；
对于（尺寸j=0；jnext；
}
返回p->数据；
}
无效删除（int d）{
如果（_head==nullptr）
回来
节点*p=_头；
节点*prev=p；
而（（p！=nullptr）和&（p->data！=d））{
prev=p；
p=p->next；
}
如果（p！=nullptr）{
如果（p==\U头）
_head=p->next；
其他的
上一个->下一个=p->下一个；
删除p；
_大小--；
}
}
大小\u t大小（）常量{
返回大小；
}
~MyList（）{
node*next=nullptr；
对于（节点*p=_head；p！=nullptr；p=next）{
next=p->next；
删除p；
}
}
使用迭代器=MyListIterator；
迭代器begin（）{返回迭代器（_head）；}
迭代器end（）{返回迭代器（_tail->next）；}
};
int main（）
{
糜棱岩糜棱岩；
我的列表。推回（1）；
我的列表。推回（2）；
我的列表。推回（3）；
整数计数=1；
//增量前
对于（MyListIterator it=mylist.begin（）；it！=mylist.end（）；++it）
断言（*it==count++）；
计数=1；
//增量后
对于（MyListIterator it=mylist.begin（）；it！=mylist.end（）；it++）
断言（*it==count++）；
对于（大小i=0；i<3；i++）
断言（mylist[i]==i+1）；
mylist.remove（2）；
断言（mylist[0]==1）；
断言（mylist[1]==3）；
断言（mylist.size（）==2）；
mylist.remove（1）；
mylist.remove（3）；
断言（mylist.size（）==0）；
}
对于新手来说，有时很难断章取义地理解问题。因此，我决定提供一个定义自定义迭代器并重载其运算符的或多或少完整的示例。
注意，当重载后增量运算符时，我们按值返回迭代器，而不是按引用返回迭代器。
当然，这不是一个真实的例子，我们不会使用原始指针

#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);

}

#包括
#包括
结构节点
{
int数据；
节点*下一步；
node（）：数据（0），下一个（nullptr）{}
节点（intd）：数据（d），下一个（nullptr）{
};
//远期申报
类MyList；
类标识符
{
私人：
节点*\u ptr；
朋友级MyList；
显式MyListIterator（节点*n）：\u ptr（n）{}
公众：
整型运算符*（）常量（&O）{
返回_ptr->数据；
}
//重载预增量运算符
MyListIterator和运算符++（）{
_ptr=_ptr->next；
归还*这个；
}
//重载后增量运算符
MyListIterator运算符++（int）{
MyListIterator ret=*此；
++*（本条）；
返回ret；
}
布尔运算符==（常量MyListIterator和iter）常量{
返回此->\u ptr==iter.\u ptr；
}
布尔运算符！=（常量MyListIterator和iter）常量{
返回此->\u ptr！=iter.\u ptr；
}
};
类MyList
{
私人：
节点*头；
节点*_尾；
大小(t)大小;；
公众：
MyList（）：