| 我开始写一个类，其行为类似于“ 0”，但有一些数学运算。主要是矢量范数和重载重要数学运算符（+，-等）之类的东西，它们将按元素进行加，减。 该类发布在下面，我用ѭ1编写了所有数学运算符，它们均能完美工作。在实现迭代器时，我遇到了一些问题。我试图将迭代器编写为嵌套类，并使用
boost::iterator
获得most0ѭ迭代器的大部分/全部功能。 这是我遇到麻烦的地方，代码将无法使用约2英里的模板相关错误输出进行编译。如果您有兴趣，可以发给我，但是它是典型的冗长的Boost模板错误。 我的问题有两个方面。 首先，构图是最佳的设计选择吗？使用私有继承或装饰器模式可能会做得更好吗？或者，也许有人知道在图书馆中实现此想法的情况？ 其次，迭代器在做什么？我觉得好像在我的
boost::iterator
实现中缺少一些基本的东西，并且想要修复它而不是更改我的设计。 我没有在大多数方法中包括实现，因为它们要么无关紧要，要么不重要。 
//publicly inherits important boost::operators classes
template 
class Coords: boost::arithmetic
            ,boost::arithmetic, T
//              ,boost::indexable,int,T&
//              ,boost::dereferenceable, T*>
//            >
    >
>
{
private:
    //private member
    std::vector x_;
public:

    //public constructors
    Coords(int n, T x): x_(n,x){};
    Coords(int n): x_(n){};
    Coords(std::vector &x);
    Coords(const Coords &rhs);

    //iterator nested class, public inherits boost::iterator_facade
    class iterator: public boost::iterator_facade, std::random_access_iterator_tag>{
        private:
            typename std::vector::iterator iter_;

            friend class boost::iterator_core_access;

            void increment() { iter_ = iter_++;};

            void decrement() { iter_ = iter_--;};

            void advance(int n){ iter_ = iter_+=n;};

            void equal(iterator const &other) const{
                return this->iter_ == other.iter_;
            }

            T& dereference() const {return *iter_;};

            int distance_to(iterator const &other) const{
                return this->iter_ - other.iter_;
            }

        public:
            iterator():iter_(0){};

            explicit iterator(const typename Coords::iterator& it):iter_(it.iter_){};

            explicit iterator(const typename std::vector::iterator& it):iter_(it){};

    };

    //methods from std::vector I would like to \'copy\'
    typename Coords::iterator begin(){return iterator(x_.begin());};
    typename Coords::iterator end(){return iterator(x_.end());};
    typename Coords::iterator operator[](std::size_t n);
    std::size_t size(){return x.size()};

    //mathematical methods
    T norm() const;
    T square() const;
    T sum() const;
    T dotProd(const Coords &rhs);

    //important operator overloads
    Coords operator+=(const T &rhs);
    Coords operator-=(const T &rhs);
    Coords operator*=(const T &rhs);
    Coords operator/=(const T &rhs);
    Coords operator+=(const Coords &rhs);
    Coords operator-=(const Coords &rhs);
    Coords operator*=(const Coords &rhs);
    Coords operator/=(const Coords &rhs);
};