Блог

Я начал писать класс, который действовал бы очень похоже на std::vector , но с некоторыми математическими операциями. В основном такие вещи, как норма вектора и перегрузка важных математических операторов ( ,- и т.д.), Которые будут добавлять или вычитать элементы поэлементно.

Класс размещен ниже, я использовал boost::operators для написания всех математических операторов, и все они работают безупречно. Я столкнулся с некоторыми проблемами при реализации итератора. Я попытался написать итератор как вложенный класс и использовать boost::iterator для получения большей части / всей функциональности std::vector итератора.

Здесь я столкнулся с проблемой, код не будет компилироваться с выводом ошибок, связанных с шаблоном, примерно на 2 мили. Который я могу опубликовать, если вам интересно, но это типичные подробные ошибки шаблона boost.

Мой вопрос двоякий.

Во-первых, является ли композиция лучшим выбором дизайна? Что я мог бы сделать лучше с частным наследованием или шаблоном декоратора? Или, может быть, кто-нибудь знает о реализации этой идеи в библиотеке?

Во-вторых, что я делаю не так с итератором? Я чувствую, что мне не хватает чего-то фундаментального в моей boost::iterator реализации, и я хотел бы это исправить, а не менять свой дизайн.

Я не включил реализацию в большинство методов, поскольку они либо тривиальны, либо неважны.

 //publicly inherits important boost::operators classes
template <class T>
class Coords: boost::arithmetic<Coords<T>
            ,boost::arithmetic<Coords<T>, T
//              ,boost::indexable<Coords<T>,int,Tamp;
//              ,boost::dereferenceable<Coords<T>, T*>
//            >
    >
>
{
private:
    //private member
    std::vector<T> x_;
public:

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

    //iterator nested class, public inherits boost::iterator_facade
    class iterator: public boost::iterator_facade<iterator, Coords<T>, std::random_access_iterator_tag>{
        private:
            typename std::vector<T>::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 amp;other) const{
                return this->iter_ == other.iter_;
            }

            Tamp; dereference() const {return *iter_;};

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

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

            explicit iterator(const typename Coords<T>::iteratoramp; it):iter_(it.iter_){};

            explicit iterator(const typename std::vector<T>::iteratoramp; it):iter_(it){};

    };

    //methods from std::vector I would like to 'copy'
    typename Coords<T>::iterator begin(){return iterator(x_.begin());};
    typename Coords<T>::iterator end(){return iterator(x_.end());};
    typename Coords<T>::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 amp;rhs);

    //important operator overloads
    Coords operator =(const T amp;rhs);
    Coords operator-=(const T amp;rhs);
    Coords operator*=(const T amp;rhs);
    Coords operator/=(const T amp;rhs);
    Coords operator =(const Coords<T> amp;rhs);
    Coords operator-=(const Coords<T> amp;rhs);
    Coords operator*=(const Coords<T> amp;rhs);
    Coords operator/=(const Coords<T> amp;rhs);
};
  

Это устраняет ряд проблем с программой:

 #include <boost/operators.hpp>
#include <boost/iterator.hpp>
#include <boost/iterator/iterator_facade.hpp>
#include <vector>
//publicly inherits important boost::operators classes
template <class T>
class Coords: boost::arithmetic<Coords<T>
            ,boost::arithmetic<Coords<T>, T
//              ,boost::indexable<Coords<T>,int,Tamp;
//              ,boost::dereferenceable<Coords<T>, T*>
//            >
    >
>
{
private:
    //private member
    std::vector<T> x_;
public:

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

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

            friend class boost::iterator_core_access;

            void increment() {   iter_;}

            void decrement() { --iter_; }

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

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

            Tamp; dereference() const {return *iter_;};

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

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

            iterator(const iteratoramp; it):iter_(it.iter_){};
            iterator(iteratoramp; it):iter_(it.iter_){};

            explicit iterator(const typename std::vector<T>::iteratoramp; it):iter_(it){};

    };

    //methods from std::vector I would like to 'copy'
    iterator begin(){return iterator(x_.begin());};
    iterator end(){return iterator(x_.end());};
    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 amp;rhs);

    //important operator overloads
    Coords operator =(const T amp;rhs);
    Coords operator-=(const T amp;rhs);
    Coords operator*=(const T amp;rhs);
    Coords operator/=(const T amp;rhs);
    Coords operator =(const Coords<T> amp;rhs);
    Coords operator-=(const Coords<T> amp;rhs);
    Coords operator*=(const Coords<T> amp;rhs);
    Coords operator/=(const Coords<T> amp;rhs);
};

int main() {
  Coords<int> c(3);
  for(Coords<int>::iterator it(c.begin()); it != c.end();   it)
    *it;
}
  

• В документации Boost, кажется, говорится, что третий параметр шаблона для iterator_facade является boost:: тегом, а не std:: меткой.
• Вторым параметром шаблона для iterator_facade является тип значения, а не тип контейнера.
• Код для increment , decrement и advance всего созданного (я думаю) неопределенного поведения.
• При обращении к членам класса изнутри определения класса вам не нужно указывать имя класса. Было несколько мест, Coords<T>:: которые пришлось удалить.