Discussion :

[Grumpy64]

Soit une classe X, ayant pour membre une std::list<int>

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
class X {
    private:
      std::list<in> * XList;
    public:
        at(int iArg)
 
};

Comment accéder à l'élément iArg de la liste XList ?

Une question de newbie qui vous semble surement triviale....
Une solution serait ausii de me dire ou chercher sur ce site....j'ai cherché mais sans trouver....

Merci de votre aide.

Grump

[nuKs]

A l'aide d'une boucle. Mais je pense que ton conteneur est mal choisis.
http://cpp.developpez.com/faq/cpp/?p...hoix_conteneur
http://www.cppreference.com/wiki/stl/list/start

[koala01]

Salut, et bienvenue sur le forum.

Effectivement, si tu envisages de nombreux accès aléatoires aux différents éléments de ta collection, une liste n'est peut être pas la meilleure des solutions.

En effet, le propre d'une liste est de fournir un accès séquentiel à ses différents éléments: lorsque tu es au 5eme élément, tu as un accès très rapide au 6eme ou au 4eme, mais un accès excessivement lent au...128 eme parce qu'il faut passer part tous les éléments qui se trouvent entre l'élément courent et l'élément recherché (ou que l'on souhaite atteindre)

La collection qui, de prime abord, semble la plus opportune serait sans doute du type std::vector, bien qu'une collection basée sur les arbre binaire (std::map ou std::set ) pourrait aussi être envisagée selon les circonstances (qui nous manquent pour nous faire une idée précise)

Au passage, il est préférable de ne pas utiliser de pointeur sur les collections de la STL.

Ta classe serait donc plutôt proche de

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
class X
{
    private:
        std::list<Type> XList; //pas besoin que XList soit un pointeur ;)
    public:
        Type & at(int argX);
};

Pour, quand même, répondre à ta question, il faut, effectivement passer par une boucle, mais en prenant soin de vérifier... qu'on n'atteint pas la fin de la liste.

La première implémentation "irrérfléchie" qui vient à l'idée serait proche de

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
10
11
12
13
Type & at(int argX)
{
    int cpt=0;
    std::list<Type>::iterator it=XList.begin();
    while(cpt!= argX && it!=XList.end())
    {
        ++cpt;
        ++it;
    }
    if(it!=XList.end())
        return (*it);
    throw BadIndex();
}

qui pourrait avantageusement, dans un premier temps, être réécrite sous la forme de

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
10
11
12
13
Type & at(int argX)
{
    int cpt=0;
    std::list<Type>::iterator it=XList.begin();
    while(cpt!=argX)
    {
        ++cpt;
        ++it;
        if(it==XList.end())
            throw BadIndex();
    }
    return (*it);
}

et qui pourrait enfin être optimisée sous une forme proche de

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
Type & at(int argX)
{
    if(argX>=XList.size())
        throw BadIndex();
    std::list<Type>::iterator it=XList.begin();
    for(int i=0;i<argX;++i)
        ++it,
    return (*it);
}

(BadIndex est à chaque fois une exception qui indique que tu essaye d'accéder à un élément inexistant, et peut très bien être de type std::out_of_range)

[3DArchi]

Salut,
std::advance fait le boulot pour toi avec un avancement spécialisé selon le type de conteneur - donc le code ne sera pas à changer en cas de changement de conteneur :

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
10
11
12
13
 
class X {
    private:
      std::list<int> XList;
//...
};
 
Type X::at(int index) const
{
std::list<int>::const_iterator it = XList.begin();
std::advance(it,index);
return *it;
}

[Grumpy64]

Merci pour votre aide, et pour vos réponses qui sont pour moi des mines de réflexion

Grump