Ich habe in meiner Klasse den []-Operator überladen. Nun ist es so, dass Lesezugriffe ohne weiteres möglich sein sollen (d.h. es wird einfach ein Wert zurückgegeben) während bei Schreibzugriffen interne Daten verändert (neu berechnet) werden müssen.

Da die Neuberechnung der Daten relativ zeitintensiv ist und Schreibzugriffe im Vergleich zu Lesezugriffen auch sehr selten vorkommen, möchte ich nicht unnötig eine Neuberechnung starten, wenn das nicht notwendig ist.

Kann man irgendwie feststellen, ob bei der Verwendung des []-Operators eine Zuweisung gemacht wird, (z.B. instanz[10] = 30;) oder ob nur gelesen wird (a = instanz[3];)?

Konkret handelt es sich bei meiner Klasse um einen Container für Koordinaten im 3D-Raum (für eine Grafikanwendung). Daten sollen jederzeit gelesen werden können, während beim Änderung von Daten (also bei Schreibzugriffen) diverse Werte, wie beispielsweise die Bounding Box einer Figur, aktualisiert werden müssen.

Direkt feststellen ob es ein Schreibzugriff ist geht vermutlich nicht, weil dieser ja eigentlich erst nach Ende des Operators erfolgt. Wie würdet ihr diese Funktionalität sonst implementieren?

Danke im Voraus.

mfg

// Simples Beispiel:
template <typename Element>
class Container
{
    void regen ()
    {
        // Mach was sinnvolles
    }

    class Proxy
    {
    public:
        Proxy (Container& c, Element& e) : _ref (c), _el (e)
        {}

        operator Element ()
        {
            return _el;
        }

        void operator= (const Element& e)
        {
            _el = e;
            _ref.regen ();
        }
    private:
        Container& _ref;
        Element& _el;
    };

public:
    // ...
    Proxy operator[] (unsigned int i)
    {
        return Proxy (*this, _a[i]);
    }

    const Element& operator[] (unsigned int i) const
    {
        return _a[i];
    }

private:
    Element _a[10];
};