C++ 如何保护迭代器，使其在指向.end（）时抛出异常

我写了这个

向量

类和一个嵌套的

迭代器

类和一个

常量迭代器

类，现在我必须保护我的

向量

，这样我的

迭代器

就不会指向

之外。end（）

比如我的

操作符+

方法，如果我尝试的话，就会抛出一个异常。 因此，在我的

迭代器

类中，我无法访问

.end（）

，因为它是一个向量方法。所以我在想，我不是指向我的

迭代器

类中的值，而是指向整个向量，但我无法使用

向量*

访问

.end（）

。 我是否在正确的解决方法上，如果是，我如何传递向量，以便以我想要的方式使用它

class Vector{
      public:
        using value_type= double;
        using size_type= size_t;
        using difference_type= ptrdiff_t;
        using reference = double&;
        using const_reference= const double&;
        using pointer = double*;
        using const_pointer= const double*;
        using iterator = double*;
        using const_iterator= const double*;
    private:
     size_t sz;
     size_t max_sz;
     double* values=nullptr;
    class const_Iterator{
            public:
                using value_type = double;
                using difference_type = ptrdiff_t;
                using reference = double&;
                using pointer = double*;
                using iterator_category = std::forward_iterator_tag;
            private:
            double* ptr;
            size_t cnt;
            public:
                const_Iterator(double* p){
                    ptr=p;
                    cnt=0;

                 }
                 const_Iterator& operator++ () {
                    ptr++;
                    cnt = 0;
                    return *this;
                }
                bool  operator==(const const_Iterator& rop)const {
                    return this->ptr == rop.ptr;
                }

                bool  operator!=(const const_Iterator& rop)const {
                    return this->ptr != rop.ptr;
                }
                const double operator* () const {
                    return *ptr;
                }
                friend Vector::difference_type operator-(const Vector::const_Iterator& lop,const Vector::const_Iterator& rop) {
                    return lop.ptr-rop.ptr;
                }
        };
            class Iterator{
            public: 
                using value_type = double;
                using difference_type = ptrdiff_t;
                using reference = double&;
                using pointer = double*;
                using iterator_category = std::forward_iterator_tag;
            private:
            double* ptr;
            size_t cnt;
            public:
                Iterator(double* p){
                    ptr=p;
                    cnt=0;

                 }
                 Iterator& operator++() {
                    ptr++;
                    cnt = 0;
                    return *this;
                }
                Iterator operator++(int){
                    Iterator a(ptr);
                    ptr++;
                    return a;
                }
                bool operator==( Iterator& rop) {
                    return this->ptr != rop.ptr;
                }

                bool operator!=(const Iterator& rop) {
                    return this->ptr != rop.ptr;
                }
                double& operator*() {
                    return *ptr;
                }
                 operator const_Iterator() const{

                 return const_Iterator(ptr);
                 }; 



                 };
const_Iterator end() const{return const_Iterator(values+sz);}    
const_Iterator  begin() const{return const_Iterator(values);}
   Iterator begin()  { return values; }
   Iterator end()  { return values + sz; }
        size_t min_sz = 5;
        Vector();
        Vector(size_t);
        Vector(const Vector&);
        Vector (initializer_list<double> ); 
        void push_back(double);
        void reserve(size_t);
        void pop_back();
        bool empty();
        void clear();
        Vector&  operator=(const Vector&);
        const double& operator[] (size_t) const;
        double& operator[] (size_t) ;

        void fit_to_shrink();
        size_t size()const {return sz;}
        ostream& print(ostream&) const;
};  

类向量{
公众：
使用值_type=double；
使用大小\类型=大小\ t；
使用差分类型=ptrdiff t；
使用reference=double&；
使用const_reference=const double&；
使用指针=双*；
使用常量指针=常量双*；
使用迭代器=双*；
使用常量迭代器=常量双*；
私人：
大小(四);；
尺寸（最大尺寸）；
双*值=空PTR；
类常量迭代器{
公众：
使用值_type=double；
使用差分类型=ptrdiff t；
使用reference=double&；
使用指针=双*；
使用迭代器\u category=std:：forward\u迭代器\u标记；
私人：
双*ptr；
尺寸；
公众：
常量迭代器（双*p）{
ptr=p；
cnt=0；
}
常量迭代器和运算符++（）{
ptr++；
cnt=0；
归还*这个；
}
布尔运算符==（常量迭代器和rop）常量{
返回此->ptr==rop.ptr；
}
布尔运算符！=（常量迭代器和rop）常量{
返回此->ptr！=rop.ptr；
}
常量双运算符*（）常量{
返回*ptr；
}
友元向量：：差分类型运算符-（常量向量：：常量迭代器和lop，常量向量：：常量迭代器和rop）{
返回lop.ptr-rop.ptr；
}
};
类迭代器{
公众：
使用值_type=double；
使用差分类型=ptrdiff t；
使用reference=double&；
使用指针=双*；
使用迭代器\u category=std:：forward\u迭代器\u标记；
私人：
双*ptr；
尺寸；
公众：
迭代器（双*p）{
ptr=p；
cnt=0；
}
迭代器和运算符++（）{
ptr++；
cnt=0；
归还*这个；
}
迭代器运算符++（int）{
迭代器a（ptr）；
ptr++；
返回a；
}
布尔运算符==（迭代器和rop）{
返回此->ptr！=rop.ptr；
}
布尔运算符！=（常量迭代器和rop）{
返回此->ptr！=rop.ptr；
}
双重运算符*（）{
返回*ptr；
}
运算符常量迭代器（）常量{
返回常量迭代器（ptr）；
}; 
};
const_Iterator end（）const{return const_Iterator（values+sz）；}
常量迭代器begin（）常量{返回常量迭代器（值）；}
迭代器begin（）{返回值；}
迭代器end（）{返回值+sz；}
尺寸_t min_sz=5；
向量（）；
向量（大小t）；
向量（常数向量&）；
向量（初始值设定项列表）；
无效推回（双）；
空位储备（大小）；
void pop_back（）；
bool empty（）；
无效清除（）；
向量和运算符=（常量向量&）；
双常数和运算符[]（大小）常数；
双人和操作员[]（尺寸）；
空配合到收缩（）；
size_t size（）常量{return sz；}
ostream&print（ostream&print）const；
};  

您的迭代器可能看起来像：

class Iterator{
public:
    // ... using type

private:
    Vector* parent;
    std::size_t index;
public:
    Iterator(Vector& v, std::size_t index) : ptr(&v), index(index) {}

     Iterator& operator++() {
       if (index == parent->size()) {
           throw std::runtime_error("++ on end iterator");
       }
        ++index;
        return *this;
    }

    Iterator operator++(int){
        Iterator old(*this);
        ++(*this);
        return old;
    }

    bool operator==(const Iterator& rhs) const {
        if (parent != rhs.parent) {
            throw std::runtime_error("You compare iterator of different containers");
        }
        return index == rhs.index;
    }

    bool operator!=(const Iterator& rop) const { return !(*this == rhs); }

    double& operator*() { return parent->at(index); } // `at` throws on invalid index

    // ...

 };

还有你的向量：

Iterator Vector::begin() { return Iterator(this, 0);}
Iterator Vector::end() { return Iterator(this, size());}    

---

我不能用向量*访问.end（）是什么意思？当然可以（

vector->end（）

）！为什么不能执行

this->end（）

从向量中获取迭代器？