reverse_iterator_template

Ich will ein reverse_iterator_template bauen (z.B. int foo[42]; -> reverse_iterator_template<int>(foo[41]);), aber der Code geht nicht: ich bin mir bei den Rückgabetypen nicht sicher, was da hin soll. Im Prinzip soll ein reverse_iterator_template<int> sich wie ein int* verhalten (bloß bei ++ -- machen...)

template<typename T> class reverse_iterator_template {
        T* p;
    public:
        inline reverse_iterator_template() {}
        inline reverse_iterator_template(T* d) : p(d) {}
        inline reverse_iterator_template& operator++ () {return --p;}
        inline reverse_iterator_template& operator-- () {return ++p;}
        inline reverse_iterator_template operator++ (int) {reverse_iterator_template t(*this); --p; return t;}
        inline reverse_iterator_template operator-- (int) {reverse_iterator_template t(*this); ++p; return t;}
        inline operator* () {return *p;}
    };

ich hab jetzt das:

template<typename T> class iterator_template {
        T* p;
    public:
        inline iterator_template() {}
        inline iterator_template(T* d) : p(d) {}
        inline iterator_template operator++ () {++p return *this;}
        inline iterator_template operator-- () {--p; return *this;}
        inline iterator_template operator++ (int) {iterator_template t(*this); ++p; return t;}
        inline iterator_template operator-- (int) {iterator_template t(*this); --p; return t;}
        friend inline bool operator== (iterator_template a, iterator_template b) { return a.p == b.p; }
        friend inline bool operator!= (iterator_template a, iterator_template b) { return a.p != b.p; }
        friend inline bool operator< (iterator_template a, iterator_template b) { return a.p < b.p; }
        friend inline bool operator> (iterator_template a, iterator_template b) { return a.p > b.p; }
        friend inline bool operator<= (iterator_template a, iterator_template b) { return a.p <= b.p; }
        friend inline bool operator>= (iterator_template a, iterator_template b) { return a.p >= b.p; }
        inline T operator* () {return *p;}
    };

    template<typename T> class reverse_iterator_template : public iterator_template {
        T* p;
    public:
        /*inline reverse_iterator_template() {}
        inline reverse_iterator_template(T* d) : p(d) {}*/
        inline reverse_iterator_template operator++ () {--p; return *this;}
        inline reverse_iterator_template operator-- () {++p return *this;}
        inline reverse_iterator_template operator++ (int) {reverse_iterator_template t(*this); --p; return t;}
        inline reverse_iterator_template operator-- (int) {reverse_iterator_template t(*this); ++p; return t;}
        //inline T operator* () {return *p;}
    };

nimmer noch nix

soory muss so heißen

inline T& operator* () {return *p;}

jetzt gehts! sieht aber nicht sehr sauber aus, oder?

template<typename T> class iterator_template {
    private:
        T* p;
    public:
        inline iterator_template() {}
        inline iterator_template(T* d) : p(d) {}
        inline iterator_template operator++ () {++p; return *this;}
        inline iterator_template operator-- () {--p; return *this;}
        inline iterator_template operator++ (int) {iterator_template t(*this); ++p; return t;}
        inline iterator_template operator-- (int) {iterator_template t(*this); --p; return t;}
        friend inline bool operator== (iterator_template a, iterator_template b) { return a.p == b.p; }
        friend inline bool operator!= (iterator_template a, iterator_template b) { return a.p != b.p; }
        friend inline bool operator< (iterator_template a, iterator_template b) { return a.p < b.p; }
        friend inline bool operator> (iterator_template a, iterator_template b) { return a.p > b.p; }
        friend inline bool operator<= (iterator_template a, iterator_template b) { return a.p <= b.p; }
        friend inline bool operator>= (iterator_template a, iterator_template b) { return a.p >= b.p; }
        inline T& operator* () {return *p;}
    };

    template<typename T> class reverse_iterator_template {
    private:
        T* p;
    public:
        inline reverse_iterator_template() {}
        inline reverse_iterator_template(T* d) : p(d) {}
        inline reverse_iterator_template operator++ () {--p; return *this;}
        inline reverse_iterator_template operator-- () {++p return *this;}
        inline reverse_iterator_template operator++ (int) {reverse_iterator_template t(*this); --p; return t;}
        inline reverse_iterator_template operator-- (int) {reverse_iterator_template t(*this); ++p; return t;}
        friend inline bool operator== (reverse_iterator_template a, reverse_iterator_template b) { return a.p == b.p; }
        friend inline bool operator!= (reverse_iterator_template a, reverse_iterator_template b) { return a.p != b.p; }
        friend inline bool operator< (reverse_iterator_template a, reverse_iterator_template b) { return a.p < b.p; }
        friend inline bool operator> (reverse_iterator_template a, reverse_iterator_template b) { return a.p > b.p; }
        friend inline bool operator<= (reverse_iterator_template a, reverse_iterator_template b) { return a.p <= b.p; }
        friend inline bool operator>= (reverse_iterator_template a, reverse_iterator_template b) { return a.p >= b.p; }
        inline T& operator* () {return *p;}
    };

HumeSikkins

Hallo,
dir ist aber bekannt, dass es bereits einen std::reverse_iterator-Template gibt, oder?

Original erstellt von HumeSikkins:
Hallo,
dir ist aber bekannt, dass es bereits einen std::reverse_iterator-Template gibt, oder?

WAS? NEIN! In welchem Header? Naja, hab wenigstens was daraus gelernt

HumeSikkins

In welchem Header?