Ich bin im Moment dabei sowas ähnliches wie eine map<> nachzubauen und habe ein kleines Problem mit dem Operator []. Mit folgendem Code habe ich ihn überladen:

t& operator[](const k key)
{
    return content[key];
}

Funktioniert sowohl beim Auslesen als auch beim Ändern eines Wertes in der Variable "content" (bei der es sich um eine normale map<k,t> handelt). Problem ist aber, dass ich beim Zuweisen (map[k] = t) nicht nur den Wert ändern möchte, sondern auch noch etwas an einer anderen Variable der Klasse ändern möchte (vector<k> um genau zu sein). Wenn ich aber noch den =-Operator überlade wird das überhaupt nicht beachtet, die Methode wird nicht einmal aufgerufen (nur bei map = k). Wie mache ich es also richtig?

template <typename t>
class MyMap;

template <typename T>
class MyProxy
{
    MyMap& myMap;
    T& myValue;
  public:
    MyProxy(myMap& m, T& v)
      : myMap(m), myValue(v)
    { }
    // mach Proxy-objekt konvertierbar in den ursprünglichen Typ
    operator T&             { return myValue; }
    operator const T& const { return myValue; }
    MyProxy& operator= (const T& newVal)
    {
      myValue = newVal;
      myMap.notify(newVal);
    }
};

template <typename t>
class MyMap
{
    friend class MyProxy<t>;
    void notify(const t&)
    {
      // es wurde eine Zuweisung durchgeführt
    }
  public:
    MyProxy<t> operator[](const k key) 
    { 
       return MyProxy<t>(*this, content[key]); 
    }
};

Gruß

Tommi

So einfach ist das nicht.

Das hatte ich befürchtet
Nunja, ich gucke mir deine Idee mal an und melde mich dann bei Erfolg/Misserfolg.

7 [...] ISO C++ forbids declaration of `MyMap' with no type
14 [...] invalid member function declaration 
15 [...] `const' qualifiers cannot be applied to `const T&'

10 [...] expected `)' before '&' token

Ein <T> muss da jedenfalls nicht hin.

*nochmal den Code durchsieht* mir fallen jetzt keine Fehler mehr auf

keine gute idee - das führt nähmlich schnell zu mehrdeutigkeiten, ausserdem könnte man den proxy so (scheinbar) umgehen. denn sowohl ein T& als auch ein const T& können gleichermassen benutzt werden um ein T zu erzeugen. die auswahl von benutzerdefinierten konvertierungsoperatoren richtet sich NICHT nach den const-qualifierern des arguments sondern nur nach den argumenten der zielfunktion - alle konvertierungs-operatoren (soweit aufrufbar) sind gleichermassen gut.

besser:

operator T const { return myValue; }

und dafür ein const overload für op[] in MyMap das einfach ein T zurückgibt. sobald man mit proxies arbeitet sollte man nirgend mehr referenzen verwenden (höchtens als optimierung). denn ein

&map[..]

ist dann nicht mehr sinnvoll.

und dafür ein const overload für op[] in MyMap das einfach ein T zurückgibt.

Wie genau sollte es dann aussehen?

Das geht so nicht wie ich grade feststelle.

105 [...] invalid member function declaration

operator T&             { return myValue; }
    operator const T& const { return myValue; }

keine gute idee - das führt nähmlich schnell zu mehrdeutigkeiten, ausserdem könnte man den proxy so (scheinbar) umgehen. denn sowohl ein T& als auch ein const T& können gleichermassen benutzt werden um ein T zu erzeugen. die auswahl von benutzerdefinierten konvertierungsoperatoren richtet sich NICHT nach den const-qualifierern des arguments sondern nur nach den argumenten der zielfunktion - alle konvertierungs-operatoren (soweit aufrufbar) sind gleichermassen gut.

Ne, die Lage ist klar.richtig ist, dass beide rückgabewerte gleich gut sind, aber es ist nicht egal, welche der beiden überladungen aufgerufen wird. das const in der 2. methode hat ne große wirkung ;).

(flugs nochmal getestet)

struct test{
    int i,j;
    test():i(1),j(2){}
    operator int&(){//klammern net vergessen
        return i;
    }

    operator const int&()const{//dito
        return j;
    }
};
int main(){
    test t;
    cout<<t<<endl;
	cout<<const_cast<const test&>(t);
	int i;
	cin>>i;
}

ausgabe: 1 2

umap<string, umap<string,string> > test;
test["foo"]["bar"] = "test";

Auch das nicht:

struct t {
	string foo;
	string bar;
};

umap<string,t> test2;
test2["foo"].foo = "test";

Diese Funktionalität ist mir aber von äußerster Wichtigkeit. Also was tun?

30 [...] 'class MyProxy<std::string, t>' has no member named 'foo'

also konvertierst du entweder von hand mithilfe eines casts, doer lässt dir was einfallen.

möglichkeit 0:
einfach casten:

static_cast<t>(test2["foo"]).foo

möglichkeit 1:
eine get methode einbauen. dann sieht es so aus:

test2["foo"].get().foo

möglichkeit 2:
überladen des op->

test2["foo"]->foo

also konvertierst du entweder von hand mithilfe eines casts, doer lässt dir was einfallen.

Also das "lässt dir was einfallen" wollte ich eigentlich euch überlassen

möglichkeit 0:
einfach casten:

static_cast<t>(test2["foo"]).foo

Funktioniert, macht den Code aber nicht grade schöner.

möglichkeit 1:
eine get methode einbauen. dann sieht es so aus:

test2["foo"].get().foo

möglichkeit 2:
überladen des op->

test2["foo"]->foo

Das geht für meinen ersten Fall

test["foo"]["bar"] = "test";

aber nicht, oder?

du musst ja nicht interna des proxys zurückgeben, sondern interna des objekts, vor das sich der proxy vorschaltet ;).

womit der proxy sich selbst ausschaltet - ich dachte der zweck des proxies wäre gerade, den zugriff auf diese interna zu maskieren.
original:

struct X
{
    // ...
    int& operator[](size_t i) { return data[i]; }
};
void foo(int&)
{
// ...
}
void bar()
{
   X x;
   foo(x[1]);
}

jetzt mit proxy:

struct X
{
    struct Proxy
    {
        // ...
        int& ref_;
        operator int&() { return ref_; }
    };
    // ...
    Proxy operator[](size_t i) { return Proxy(data[i]); }
};
void foo(int&)
{
// ...
}
void bar()
{
   X x;
   foo(x[1]);
}

ups, das kompiliert ja immer noch... und dabei wollten wir doch einen proxy damit wir bei veränderungen noch ein bisschen extra arbeit erledigen können.

normale maps benutzen keinen proxy. normale maps geben das objekt ansich zurück.[...]Die einzige lösung wär, beim proxy den operator. zu überladen, aber das _darfst_ du nicht. Das sieht der Standard leider nicht vor.

Und wie konkret machen die maps das bzw. warum kann ich das nicht auch so machen?

du müsstest dir dann schonmal was basteln, was dir das objekt selber gibt(also zb der op->).

Das kann ich mal ausprobieren.