Const_Iterator Implementierung?!

[Netstischer]

Hallo,

wir sind gerade dabei für den folgenden Quelltext einen const_Iterator zu implementieren, der nur einen Lesezugriff erlaubt. Hat jemand eine Idee wie man dies sinnvoll umsetzen kann? Ist unser Ansatz der const_Iterator Klasse so richtig?

/*-------------------------------------------------------Spezialisierung für Char mit Bitfeldern-------------------------------------------------------
Für die Spezialisierung mit Char wird im Konstruktor ein char- Array mit 32 Feldern angelegt.
Da ein char- Feld aus einem Byte besteht, wird es in 8 Bit unterteilt.
In jedem Bit wird ein Character gespeichert, so benötigt man statt 256 Byte nur 32 Byte, um den kompletten ASCII- Satz zu speichern.
Um das richtige Bit zu ermitteln, an dem ein Char gespeichert werden muss, wird der ASCII- Wert des Char durch 8 geteilt, dadurch erhält man
das Byte, in dem das Char gespeichert werden soll, durch Anwendung des Modulu- Operators auf den ASCII- Wert,
erhält man die Information, welches Bit beschrieben werden muss.
-----------------------------------------------------------------------------------------------------------------------------------------------------*/
#ifndef Char_h
#define Char_h

using namespace std;

template<class OrderClass>
class Set<char, OrderClass>{
public:
    Set(){
        array = new char[32];
        for(int i = 0; i < 32; ++i)
            array[i] = 0;
    }

    class Iterator{
    public:
        Iterator(char* inArray) : p_array(inArray){}

        OrderClass order;

        char& operator* (){
            return content;
        }

        bool operator == (const typename Set<char, OrderClass>::Iterator& x){
            return(!order(content, x.content) && !order(x.content, content));
        }

        Iterator& operator ++ (){
            int j = (content % 8)+1;
            for(int i = content / 8; i < 32; ++i){
                for(; j < 8; ++j){
                    if(p_array[i] & (1 << j)){
                        this->content = (unsigned char)((i * 8) + j);
                        return *this;
                    }
                }
                j = 0;
            }
        }    
        char* p_array;
        char content;
    };

    class const_Iterator{
    public:
        const_Iterator(char* inArray) : p_array(inArray){}

        OrderClass order;

        char operator* (){          //const setzen? warum?
            return content;
        }

        bool operator == (const typename Set<char, OrderClass>::Iterator& x){
            return(!order(content, x.content) && !order(x.content, content));
        }

        const const_Iterator operator ++ (){
            int j = (content % 8)+1;
            for(int i = content / 8; i < 32; ++i){
                for(; j < 8; ++j){
                    if(p_array[i] & (1 << j)){
                        this->content = (unsigned char)((i * 8) + j);
                        return *this;
                    }
                }
                j = 0;
            }
        }    
        char* p_array;
        char content;
    };

    Iterator search(char c){
        Iterator toSend(array);    
        (array[c / 8] & (1 << (c % 8))) ? toSend.content = c : toSend.content = *end();
        return toSend;
    }

    void insert(char c){
        array[c / 8] = array[c / 8] | (1 << (c % 8));
    }

    void erase(Iterator c){
        array[c.content / 8] = array[c.content / 8] & ~(1 << (c.content % 8));
    }    

    Iterator begin(){
        Iterator toSend(array);
        for(int i = 0; i < 32; ++i)
            for(int j = 0; j < 8; ++j)
                if(array[i] & (1 << j)){
                    toSend.content = (unsigned char)((i * 8) + j);
                    return toSend;
                }    
    }

    Iterator end(){
        Iterator toSend(array);
        for(int i = 31; i > -1; --i)
            for(int j = 7; j > -1; --j)
                if(array[i] & (1 << j)){
                    toSend.content = (unsigned char)((i * 8) + j);
                    return toSend;
                }
    }

    void print(){
        for(int i = 0; i < 32; ++i)
            for(int j = 0; j < 8; ++j)
                if(array[i] & (1 << j))
                    cout << (unsigned char)((i * 8) + j) << endl;
    }    

private:
    char* array;
};

#endif

[otze]

nicht der iterator muss konstant sein, sondern der zurückgegebene wert bei den *()/-> operatoren

btw: mieserabler programmierstil!
könnt ihr die klassen nicht ausserhalb implementieren? das würde den code um einiges übersichtlicher machen.

und die member variablen sollten möglichst das erste in einer Klasse sein,das erhöht auch wieder die übersicht.

achja, ihr habt ausserdem ein memory leak(falls ich den destruktor nich übersehen hab),das mit new erstellte array wird nicht wieder gelöscht.