Beispielimplementierung eines RandomAcess-Iterators



  • Hallo,

    in c++17 ist std::iterator deprecated und nun wollte einen 'einfachen' random-acess iterator implementieren, indem ich zunächst die typedefs deklariere (value_type,iterator_tag usw.) und danach die entsprechenden operatoren.

    Hier ist meine Beispielimplementierung. Wenn ich versuche, dass zu kompilieren, erhalte ich folgende Fehlermeldung:

    ""no type named 'iterator_category'"

    #include <iostream>
    #include <algorithm>
     
     
    class BstIterator {
     
        typedef int value_type;
        typedef std::ptrdiff_t difference_type;
        typedef int* pointer;
        typedef int& reference;
        typedef std::bidirectional_iterator_tag iterator_category;
     
     
        friend class DataStructure;
     
    private:
        pointer p;
     
    public:
     
        BstIterator() = default;
     
        BstIterator(const BstIterator &other) {
            this->p = other.p;
        }
     
        bool operator==(const BstIterator &iter) {
            return iter.p == p;
        }
     
        bool operator!=(const BstIterator &iter) {
            return iter.p != p;
        }
     
        value_type operator*() const {
            return *p;
        }
     
        BstIterator&operator++() {
            p++;
            return *this;
        }
     
        BstIterator operator++(int) {
            BstIterator iter;
            iter.p = p;
            p++;
            return iter;
        }
     
        BstIterator&operator--() {
            p--;
            return *this;
        }
     
        BstIterator operator--(int) {
            BstIterator iter;
            iter.p = p;
            p--;
            return iter;
        }
     
        BstIterator&operator+=(difference_type dist) {
            this->p+=dist;
            return *this;
        }
     
        BstIterator&operator-=(difference_type  dist) {
            this->p-=dist;
            return *this;
        }
     
        BstIterator operator+(difference_type dist) {
            BstIterator iter;
            iter.p=this->p+dist;
            return iter;
        }
     
        value_type operator-(BstIterator &iter) {
            BstIterator nextr;
            int dist =this->p-iter.p;
            return dist;
        }
     
        value_type operator[](difference_type  index) {
            return *(this->p+index);
        }
     
        bool operator<(BstIterator &iter) {
            return p<iter.p;
        }
     
        bool operator<=(BstIterator &iter) {
            return p<=iter.p;
        }
     
        bool operator>(BstIterator &iter) {
            return p>iter.p;
        }
     
        bool operator>=(BstIterator &iter) {
            return p>=iter.p;
        }
     
    };
     
    constexpr size_t SIZE = 20;
     
    class DataStructure {
     
    private:
        int data[SIZE];
        int size;
     
    public:
     
        DataStructure() : size(0) {};
     
        DataStructure(const DataStructure &structure);
     
        DataStructure(std::initializer_list<int> liste);
     
        BstIterator begin();
     
        BstIterator end();
     
        int operator[](std::size_t index);
     
        int length();
     
        bool isEmpty();
    };
     
    DataStructure::DataStructure(std::initializer_list<int> liste) {
        size = 0;
        for (int curr : liste) {
            data[size++] = curr;
        }
    }
     
    DataStructure::DataStructure(const DataStructure &structure) {
        for (int i = 0; i < SIZE; ++i) {
            data[i] = structure.data[i];
        }
        this->size = structure.size;
    }
     
    int DataStructure::operator[](std::size_t index) {
        return data[index];
    }
     
    int DataStructure::length() {
        return size;
    }
     
    BstIterator DataStructure::begin() {
        BstIterator iter;
        iter.p = &data[0];
        return iter;
    }
     
    BstIterator DataStructure::end() {
        BstIterator iter;
        iter.p = &data[size - 1];
        return iter;
    }
     
    int main() {
     
     
        DataStructure structure = {1, 2, 3, 4, 5, 6};
     
        if(std::find(structure.begin(),structure.end(),1)==structure.end()){
            std::cout<<"Not found"<<"\n";
            return 0;
        }
        std::cout<<"found it"<<"\n";
     
        return 0;
    }
    
    Würde mich auf eine Antwort feuen
    
    Gruss
    
    Robin


  • Die Membertypen sollten vielleicht public sein, damit iterator_traits die sehen kann.



  • Macht hier jetzt keinen großen Unterschied aber warum nutzt du typedef statt using? typedef ist eigentlich nur noch aus Kompatibilitätsgründen verfügbar.


Log in to reply