also erstmal kurz mein aufbau:

template <class T>
class A
{
 private:
 T p;
 public:
 ...
 void A::bla()
 { int i; ....
   p[i].irgendwas(3);
 }

......
};

class B
{private:
 vector<C> K;
 public:
  ....
 C& operator[](int Zaehl)
 { return K[Zaehl];}
};

class C
{
 private:
 int bla;
 public:
 .....
 void C::irgendwas(int i){bla=i;}
};

Ihr seht vlt schon warum ich frage:
das mit dem zugriff über

p[i].irgendwas(i)

klappt net so ganz (also eher gesagt gar net...)
könnt ihr mir kurz n stupser geben??
thx

das mit dem zugriff über

p[i].irgendwas(i)

klappt net so ganz (also eher gesagt gar net...)

Das ist keine Fehlerbeschreibung.

mein problem:
p[i]!=K[i]
ursache: (wahrscheinlich)

C& operator[](int Zaehl)
 { return K[Zaehl];}

also die operator fkt ,... ich weiß net wie ich die ummodeln soll,.. thx

C operator[](int Zaehl) const
 { return K[Zaehl];}

ergänzt,.. jetzt läufts,..

ok habe den source um

C operator[](int Zaehl) const
 { return K[Zaehl];}

ergänzt,.. jetzt läufts,..

Weißt Du eigentlich, wsa Du da tust, oder bastelst Du nur rum, bis es irgendwie läuft ?

Dir ist schon klar, dass der operator[]() jetzt eine Kopie des Wertes im Vektor zurückliefert, oder ?

Probier mal aus, was mit Deinen Vektorwerte passiert, nachdem irgendwas() gelaufen ist .... oder wenn C eine richtig große Klasse ist...

Gruß,

Simon2.

C& operator[](....

)
,... ??

AUFRUF:

int main(void)
{
  A<B> F;
  F.bla();
}

man siehe
in F.bla() kommt p[i].irgendwas(3) vor,..

die methode hat hat er (das prog) aber net ausgeführt,..
thx,.. leude

bei mir läuft (in Deiner ursprünglichen Version) alles prima (die "..." habe ich mal gefüllt):

template <class T>
class A
{
private:
   T p;
public:
   void bla(){ p[0].irgendwas(3);  }
   void getBla(){ cout << "bla = " << p[0].bla << "\n";  }
};

class C {
public:
   int bla;
   void irgendwas(int i){ bla=i; cout << "bla(" << i << ")\n"; }
};

class B
{
private:
   vector<C> K;
public:
   B() { C c; c.bla = -1; K.push_back(c); }
   C& operator[](int Zaehl) { return K[Zaehl]; }
};

int main(void)
{
  A<B> f;
  f.bla();
  f.getBla();
}

ergibt als Ausgabe:
`

bla(3)

bla = 3

`

also so, wie es sein sollte:

• A::bla() ruft B::operator[]() auf
• für das (per Referenz) zurückgelieferte C wird C::irgendwas() aufgerufen
• hinterher ist (wie erwartet) das C-Objekt im vector B::K geändert.

Wenn Du ein Problem hast, liegt es woanders.

Gruß,

Simon2.

was ar denn jetzt falsch bei Dir ? (nicht, um Dich in die Pfanne zu hauen, sondern eil es mich interessiert)

Gruß,

Simon2.

C operator[](int i) const {...}

eingeführt,..
und tadaA,.. es hat geklappt,..

der menschliche fehlerfaktor sei hier mal gänzlich ausgeschlossen *g*

ich probier es nachher nochmal ohne,..

wie gesagt,.. ich habe die gleiche variante wie bei dir,.. hat net gefunzt,.. ...

Ja - aber meine "funzt" doch ....

Gruß,

Simon2.