Operator[][] Überlast

Kann man überladen [] Bediener zweimal? Zuzulassen, etwa so: function[3][3](wie in einem zweidimensionalen Array).

Wenn es möglich ist, würde ich gerne einen Beispielcode sehen.

Sie können überladen operator[] um ein Objekt zurückzugeben, das Sie verwenden können operator[] nochmal um ein Ergebnis zu bekommen.

class ArrayOfArrays {
public:
    ArrayOfArrays() {
        _arrayofarrays = new int*[10];
        for(int i = 0; i < 10; ++i)
            _arrayofarrays[i] = new int[10];
    }

    class Proxy {
    public:
        Proxy(int* _array) : _array(_array) { }

        int operator[](int index) {
            return _array[index];
        }
    private:
        int* _array;
    };

    Proxy operator[](int index) {
        return Proxy(_arrayofarrays[index]);
    }

private:
    int** _arrayofarrays;
};

Dann können Sie es wie folgt verwenden:

ArrayOfArrays aoa;
aoa[3][5];

Dies ist nur ein einfaches Beispiel, Sie würden gerne eine Reihe von Begrenzungsprüfungen und so etwas hinzufügen, aber Sie verstehen die Idee.

Insbesondere für ein zweidimensionales Array könnten Sie mit einem einzigen Operator davonkommen[] -Überladung, die einen Zeiger auf das erste Element jeder Zeile zurückgibt.

Dann können Sie den integrierten Indizierungsoperator verwenden, um auf jedes Element innerhalb der Zeile zuzugreifen.

Ein Ausdruck x[y][z] benötigt das x[y] wertet zu einem Objekt aus d das unterstützt d[z].

Dies bedeutet, dass x[y] sollte ein Objekt mit einem sein operator[] das wertet zu einem “Proxy-Objekt” aus Auch unterstützt ein operator[].

Nur so können sie verkettet werden.

Alternativ überladen operator() um mehrere Argumente zu nehmen, so dass Sie aufrufen könnten myObject(x,y).

Es ist möglich, wenn Sie zuerst eine Art Proxy-Klasse zurückgeben [] Anruf. Es gibt jedoch eine andere Option: Sie können operator() überladen, der eine beliebige Anzahl von Argumenten akzeptieren kann (function(3,3)).

Ein Ansatz ist die Verwendung std::pair<int,int>:

class Array2D
{
    int** m_p2dArray;
public:
    int operator[](const std::pair<int,int>& Index)
    {
       return m_p2dArray[Index.first][Index.second];
    }
};

int main()
{
    Array2D theArray;
    pair<int, int> theIndex(2,3);
    int nValue;
    nValue = theArray[theIndex];
}

Natürlich darfst du typedef der pair<int,int>

Sie können ein Proxy-Objekt verwenden, etwa so:

#include <iostream>

struct Object
{
    struct Proxy
    {
        Object *mObj;
        int mI;

        Proxy(Object *obj, int i)
        : mObj(obj), mI(i)
        {
        }

        int operator[](int j)
        {
            return mI * j;
        }
    };

    Proxy operator[](int i)
    {
        return Proxy(this, i);
    }
};

int main()
{
    Object o;
    std::cout << o[2][3] << std::endl;
}

Es wäre toll, wenn du mir sagen könntest, was function, function[x] und function[x][y] sind. Aber lassen Sie mich es trotzdem als ein Objekt betrachten, das irgendwo deklariert ist

SomeClass function;

(Weil Sie gesagt haben, dass es sich um eine Operatorüberladung handelt, werden Sie sich wahrscheinlich nicht für Arrays interessieren SomeClass function[16][32];)

Damit function ist eine Instanz des Typs SomeClass. Dann schlagen Sie Erklärung von nach SomeClass für den Rückgabetyp von operator[] Überlastung, genau wie

ReturnType operator[](ParamType);

Dann function[x] wird den Typ haben ReturnType. Schau wieder nach oben ReturnType für die operator[] Überlast. Wenn es eine solche Methode gibt, könnten Sie dann den Ausdruck verwenden function[x][y].

Beachten Sie, anders function(x, y), function[x][y] sind 2 getrennte Anrufe. Daher ist es für Compiler oder Runtime schwierig, die Atomarität zu garantieren, es sei denn, Sie verwenden eine Sperre im Kontext. Ein ähnliches Beispiel ist, sagt libc printf ist atomar, während die überladenen nacheinander aufgerufen werden operator<< im Ausgabestrom sind es nicht. Eine Aussage wie

std::cout << "hello" << std::endl;

könnte ein Problem bei Multi-Thread-Anwendungen haben, aber so etwas wie

printf("%s%s", "hello", "\n");

ist gut.