struct myStruct{
		int x;
		int y;
		int z;
};

meine Methode sieht so aus:

void change(list<myStruct> myStruct);

int main(int argc, char **argv) {
        list<myStruct> myStructList= initList();
        change(myStructList);
        // nachdem myStructList in der change methode verändert wurde
        // würde ich hier gerne mit der abgeänderten liste weiter arbeiten
	return(0);
}

void change(list<myStruct> myStruct){
	for(list<myStruct>::iterator i=myStruct.begin();i != myStruct.end();i++){

	}
}

Ich bin noch nicht so der Auskenner, daher ändert es ab wie es euch passt^^. Mein Ziel ist natürlich nicht nur das abändern, das problem liegt jedoch darin, das ich für jedes i , über welches ich iteriere und mir den jeweiligen Eintrag der Liste anschaue, auch den dazugehörigen Listeneintrag abändere.
Ich möchte also z.b. pro iteration das z aus meiner structur jeweils um eins erhöhen und in meiner main mit der abgeänderten Liste weiter arbeiten. Kann mir jemand zeigen wie das geht?

void change(list<myStruct>& myStructs);

Erstens musst du die Liste als Referenz übergeben und nicht als Kopie, denn wenn die Kopie verändert wird, kriegt der Aufrufer das nicht mit.
Zweitens darfst du den Parameter nicht gleich nennen, wie die Struktur selbst.

Wie du vom Iterator an den Wert kommst, kannst du sicher selbst rausfinden.

i->z

aber ist das i eine reference meiner structure? wenn ich jetzt über das i mein z verändere

i->z+1;

ändert sich auch der Eintrag meiner Liste? Bin noch nicht so c++ begabt. Wenn es nicht so passt, könnte jemand sagen wie es geht?

Edit: Ist ja cool, das klappt sogar. Vielen Dank. Deine Info war ausschlaggebend!

void change( list<myStruct>::iterator first,
             list<myStruct>::iterator last ){
    while( first != last )
    {
        // ...
    }
}

Wenn vielleicht sogar der Iteratorentyp nicht wichtig ist, dann wäre noch besser:

template<typename Iterator>
void change( Iterator first,
             Iterator last ){
    while( first != last )
    {
        // ...
    }
}

Es klappt, weil i intern einen Verweis auf deine originalen Listenelemente hat. Also in gewisser Weise ja, ist es eine Referenz. Ähnlich wie ein Zeiger.

Die Signatur sollte besser gar kein Objekt nehmen sondern ein Iteratoren-Paar.
Denn wenn die Funktion schon so aussieht, dann ist es wahrscheinlich so besser:

void change( list<myStruct>::iterator first,
             list<myStruct>::iterator last ){
    while( first != last )
    {
        // ...
    }
}

Wenn vielleicht sogar der Iteratorentyp nicht wichtig ist, dann wäre noch besser:

template<typename Iterator>
void change( Iterator first,
             Iterator last ){
    while( first != last )
    {
        // ...
    }
}

Es klappt, weil i intern einen Verweis auf deine originalen Listenelemente hat. Also in gewisser Weise ja, ist es eine Referenz. Ähnlich wie ein Zeiger.

Und was ist, wenn die Implementation seiner Liste keine Iteratoren anbietet?

Und was ist, wenn die Implementation seiner Liste keine Iteratoren anbietet?

Er verwendet offensichtlich std::list als unqualified-id. Wo redet er von einer eigenen Implementation? Schließt du das aus "meine Liste"? Ich glaube, damit meint er einfach, dass er ein "eigenes" Listenobjekt hat.

DocShoe schrieb:

Und was ist, wenn die Implementation seiner Liste keine Iteratoren anbietet?

Er verwendet offensichtlich std::list als unqualified-id. Wo redet er von einer eigenen Implementation? Schließt du das aus "meine Liste"? Ich glaube, damit meint er einfach, dass er ein "eigenes" Listenobjekt hat.

Jau, mein Fehler. 11:00 Uhr und Lesen fällt immer noch schwer o.O
=> Kaffee