Hello,

j´ai actuellement un petit problème en fait :
Je désire faire passer une structure à une liste mais je n´y arrive pas lol^^
J´ai procédé ainsi :

1. include <iostream>
2. include <list>

using namespace std;

struct mastruct
{
int nmstruct1;
int nmstruct2;
};

void ShowList(list<mastruct>& container)
{
list<mastruct>::iterator I;
for(I=container.begin();I!=container.end();I++)
{
//ben la je sais pas comment appeler
//les membres de ma structure!
}
}

int main()
{
mastruct struct1;
struct1.nmstruct1=12;
struct1.nmstruct2=8;
list<mastruct> container;
L.push_back(struct1);
ShowList(container);

}

Donc la ou j´ai mis le message en commentaire, je n´arrive pas à utiliser nmstruct1/2.
Cela vient donc du fait que je ne sais pas les appeler correctement ou que le passage d´une structure dans un list<> est impossible?
Merci d´avance à ceux qui essayeront de m´aider
++

je n´utilise pas d´iterator, donc je ne peut pas te répondre directement, mais ce que je peut te dire, c´est que ça marche exactement comme un autre type :

si pour un :

list<int>::iterator l;

tu fait :
cout << *l; //je crois que c´est ça.

là tu fait ;
(*l).nmstruct1 (ou 2) pour y acceder.
Et je crois même que
l->nmstruct1 doit fonctionner.

Je confirme ce que dis Dnob

Tu déclares un itérateur qui va de begin jusqu´a end : cet itérateur est une "fleche" qui pointe au dessus de l´élément actuel

En faisant *I, tu récuperes ta structure :

void ShowList(list<mastruct>& container)
{
list<mastruct>::iterator I;
for(I=container.begin();I!=container.end();I++)
{
mastruct M = *I;
// ici , tu as récupéré M et tu en fais ce que tu veux, tu l´affiches, tu le modifies, etc...

}
}

Dnob >
"Et je crois même que
l->nmstruct1 doit fonctionner."

Hum, je ne suis pas sur, dans la mesure ou la STL a été faite pour des éléments statiques, je ne sais pas si toutes les implémentations supportent l´operateur ->. Il est plus prudent de faire (*I).truc

ca fonctionne, dans la mesure ou les iterateurs n´ont rien de dynamiques, et les * et -> ne sont que des operateurs surcharges.

"ca fonctionne, dans la mesure ou les iterateurs n´ont rien de dynamiques, et les * et -> ne sont que des operateurs surcharges."

tu veux dire "ça ne fonctionne pas" non ?
Ou alors je n´ai pas compris l´explication qui va derriere
je sais que * est surchargé, mais -> je n´en suis pas sur

Merci infiniment à vous, j´ai testé les trois :
list<mastruct>::iterator I;
for(I=container.begin();I!=container.end();I++)
{
mastruct M = *I;
cout << M.nmstruct1 << endl;
cout << (*I).nmstruct2 << endl;
cout << I->nmstruct1 << endl;
}

et ça marche nickel à chaque fois
a+

D´accord, donc le -> fonctionne ! je ne savais pas je pensais que juste le * était surchargé pour les itérateurs.
LGV avait raison

oui voila, ce que je voulais dire, c´est que cela fonctionne justement parceque les operateurs ont etes surcharges.