Beispielimplementierung eines RandomAcess-Iterators

[CheckersGuy]

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

[Bashar]

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

[DNKpp]

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.