Überladen von mehrdimensionalen operatoren

hallo.
Es geht darum, dass ich nicht nur den [] operator überladen will, sondern dass mein array mehrdimensional sein soll, sprich [][]
Ich hab dazu schon in der Suche gefunden(als sie noch funktioniert hat), dass ich den Rückgabewert auf eine Klasse setzen soll, in der ich den [] operator erneut überlade. Dann hab ich aber das Problem, dass den Wert nicht linear ausgeben kann.
Also, als _nicht mehrdimensionales_ array. Und prüfen kann ich ja auch nicht danach ob da jetzt noch ein [] dahintergehängt wurde oder?

Ich hoffe meine Beschreibung war verständlich.

danke schonmal im voraus

mfg Mogli

Shade Of Mine

geht so nicht, es gibt keinen operator[][]

der operator[] kann aber ein proxy objekt zurückliefern, dass wiederum den op[] anbietet und somit entsteht die illusion eines op[][] weil
arr[1][2] möglich ist.

Hmmm. Möglicherweise könnte man eine wilde Konstruktion zusammenschustern, in der das zurückgegebene Proxy-Objekt einen Konversionsoperator liefert, der eine Referenz auf das Element des Hauptarrays liefert, aber...ich würde davon abraten. Im Zweifel ist es einfacher, [] für lineare Adressierung zu benutzen und statt [][] den operator() mit zwei std::size_ts zu überladen.

ness

Du hast also ein eindimensionales array, und willst mehrere dimensionen simulieren?
So in etwa:

template<class T>
class m_array
{
private:
    std::vector<T> array;    //keine Disskussionen BITTE
public:
    T& get_at(std::size_t index){return array[index];};

    template<class T,std::size_t d>
    class proxy    //mag ich nicht, könnte Fehler enthalten
    {
    private:
        std::vector<T>& array
        std::size_t offset;
    public:
        proxy(std::vector<T>& a,std::size_t o)
            :array(a),offset(o)
        proxy<T,d-1>& operator[](std::size_t i){return proxy<T,d-1>(array,o*i);};    //+?
    };

    template<class T>
    class proxy<T,0>;

    template<class T>
    class proxy<T,1>
    {
    private:
        std::vector<T>& array
        std::size_t offset;
    public:
        proxy(std::vector<T>& a,std::size_t o)
            :array(a),offset(o)
        T& operator[](std::size_t i){return array[o*i];};    //+?
    };

    template<std::size_t d>
    proxy<T,d-1>& get_at_x(std::size_t i){return proxy<T,d-1>(array,i);};
};

Keine Garantie für Fehlerfreiheit, aber so in etwa.