passage d'un tableau de structure en paramètre d'une fonction

Version imprimable

Bonjour à tous,

J'ai un petit soucis que je n'arrive pas à résoudre seul.
J'ai une structure:

Code:

1
2
3
4
5
6
7
8
9
 
    struct S_RailVirtuel
    {
        string idrail_virtuel;
        int position_h;
        int largeur;
        string type;
        string idtablette;
    };

je veux créer un tableau avec cette structure. Seulement je ne connais pas sa taille lorsque je la créé.
Je la passe en paramètre d'une fonction:

Code:

1
2
3
 
S_RailVirtuel * aRailVirtuel=NULL;
nbRailVirtuel = this->SelectRailVirtuelByIdtablette(&aRailVirtuel,idtablette);

Voici la déclaration de cette fonction:

Code:

1
2
 
int SelectRailVirtuelByIdtablette(S_RailVirtuel ** aRailVirtuel,string idtablette)

Et une partie de son code:

Code:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
 
if((nbEnregistrement = this->mysql_rob->Querry(requeteSQL.c_str(),&result)))
    {
        //création de la structure
        *aRailVirtuel = new S_RailVirtuel [nbEnregistrement] ;
 
        //parcours des lignes
        for(int cpt=0;cpt<nbEnregistrement;cpt++)
        {
            uneLigne = mysql_fetch_row(result);
            aRailVirtuel[cpt] = new  S_RailVirtuel;
            aRailVirtuel[cpt]->idrail_virtuel = uneLigne[0];     //idrail_virtuel
            aRailVirtuel[cpt]->position_h = atoi(uneLigne[1]);   //position_h
            aRailVirtuel[cpt]->largeur = atoi(uneLigne[2]);      //largeur
            aRailVirtuel[cpt]->type = uneLigne[3];               //type de RV
            aRailVirtuel[cpt]->idtablette = uneLigne[4];         //idtablette
        }
    }
    mysql_free_result(result);
    return nbEnregistrement;

Tout se passe bien dans la fonction SelectRailVirtuelByIdtablette(), seulement lorsque je veux utiliser aRailVirtuel dans la fonction appelant, je ne peux accéder qu'à ma première ligne de mon tableau... dois-je utiliser une liste chaînée? Merci pour vos réponses

08/11/2012, 11h44
ternel

Tu es en c++? utilise une classe avec un constructeur, ca ira mieux.

On est bien d'accord que:
*aRailVirtuel = new S_RailVirtuel [nbEnregistrement]; définit aRailVirtuel comme l'adresse d'un tableau de S_RailVirtuel.

aRailVirtuel[cpt] = new S_RailVirtuel;, définit l'élément cpt de aRailVirtuel comme l'adresse d'un nouveau S_RailVirtuel.

Ce n'est pas du tout la même chose que aRailVirtuel[cpt] = S_RailVirtuel(...); (affectation via operator=(S_RailVirtuel const&) )
ou encore Ce n'est pas du tout la même chose que (*aRailVirtuel)[cpt] = S_RailVirtuel(...); (affectation du pointé via operator=(S_RailVirtuel const&) )

aRailVirtuel[cpt] est strictement équivalent à *(cpt+aRailVirtuel), qui du jeu des pointeurs est numériquement égal à "le pointé par l'adresse: cpt*sizeof (S_RailVirtuel*) + aRailVirtuel", c'est à dire cpt pointeur de S_RailVirtuel plus loin que aRailVirtuel.

(*aRailVirtuel)[cpt] est au contraire équivalent à *(cpt + (*aRailVirtuel) ) c'est à dire "le pointé par l'adresse: cpt*sizeof (S_RailVirtuel) + *aRailVirtuel", c'est à dire cpt S_RailVirtuel plus loin que le pointé de aRailVirtuel

En fait, ca marcherait mieux, de mon point de vue, avec un vector<*S_RailVirtuel>& en argument.

De même, atoi devrait être remplacé par un istringstream et son operateur >>.

Salut,

Si tu travailles en C++, le plus facile est de travailler avec l'une des collection de la STL...

L'équivalent d'un tableau d'éléments contigus est std::vectorSinon, ainsi que leternel l'as indiqué, meme les structures peuvent prendre un constructeur, ce qui est de nature à faciliter grandement le travail...

Ta structure pourrait donc ressembler à quelque chose comme

Code:

1
2
3
4
5
6
7
8
9
10
11
12
    struct S_RailVirtuel
    {
        S_RailVirtuel(std::string const & id, int h, int l, std::string const & type,
                     std::string const & type, std::string const & tablette):
         idrail_virtuel(id), position_h(h),largeur(l),type(type),idtablette(tablette)
        { }
        string idrail_virtuel;
        int position_h;
        int largeur;
        string type;
        string idtablette;
    };

Ton code d'appel pourrait donc ressembler à

Code:

1
2
3
4
5
std::vector<S_RailVirtuel> tab;
/* meme plus besoin de récupérer nbRailVirtuel car tu dispose de l'information 
 * via tab.size() ;)
 */
    SelectRailVirtuelByIdtablette(tab,idtablette);

avec une fonction SelectRailVirtuelByIdtablette dont le prototype serait

Code:

void SelectRailVirtuelByIdtablette(std::vector<S_RailVirtuel> & tab, std::string const & idtablette)

et un code remplicant le tableau qui prendrait la forme de

Code:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
 
if((nbEnregistrement = this->mysql_rob->Querry(requeteSQL.c_str(),&result)))
    {
        //création de la structure
        *aRailVirtuel = new S_RailVirtuel [nbEnregistrement] ;
 
        //parcours des lignes
        for(int cpt=0;cpt<nbEnregistrement;cpt++)
        {
            uneLigne = mysql_fetch_row(result);
            S_RailVirtuel temp( uneLigne[0]  ,   //idrail_virtuel
                                atoi(uneLigne[1]),   //position_h
                                atoi(uneLigne[2]),      //largeur
                                uneLigne[3],               //type de RV
                                uneLigne[4] );        //idtablette
            tab.push_back(temp);
        }
    }
    mysql_free_result(result);

C'est d'autant plus vrai que ton dernier code est en réalité faux, vu que l'idée est de faire en sorte que le pointeur aRailVirtuel fournit lors de l'appel prenne l'adresse du premier élément du tableau...

Ton code corrigé devrait ressembler à quelque chose comme
if((nbEnregistrement =

Code:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
this->mysql_rob->Querry(requeteSQL.c_str(),&result)))
    {
        //création de la structure
        *aRailVirtuel = new S_RailVirtuel [nbEnregistrement] ; //ca, c'est bon
        for(int cpt=0;cpt<nbEnregistrement;cpt++)
        {
            uneLigne = mysql_fetch_row(result);
            /* tu as déjà nbEnregistrement éléments, il ne sert à rien d'en créer 
             * d'autres ;)
            aRailVirtuel[cpt] = new  S_RailVirtuel;
            * par contre, tu doit accéder à "ce qui est pointé par" ce qui 
            * ce trouve à aRailVirtuel[cpt]
            */
            *aRailVirtuel[cpt]->idrail_virtuel = uneLigne[0];     //idrail_virtuel
            *aRailVirtuel[cpt]->position_h = atoi(uneLigne[1]);   //position_h
            *aRailVirtuel[cpt]->largeur = atoi(uneLigne[2]);      //largeur
            *aRailVirtuel[cpt]->type = uneLigne[3];               //type de RV
            *aRailVirtuel[cpt]->idtablette = uneLigne[4];         //idtablette
        }
    }
    mysql_free_result(result);
    return nbEnregistrement;

Une autre solution consisterait à transmettre une référence sur un pointeur "simple", car la référence permet de garder la même syntaxe et agit comme un alias pur et simple de l'argument transmis...

Le prototype de la fonction serait donc poche de

Code:

int SelectRailVirtuelByIdtablette(S_RailVirtuel *& aRailVirtuel,string idtablette)

et le code correspondant ressemblerait à

Code:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
 
if((nbEnregistrement = this->mysql_rob->Querry(requeteSQL.c_str(),&result)))
    {
        //création de la structure
        aRailVirtuel = new S_RailVirtuel [nbEnregistrement] ;
 
        //parcours des lignes
        for(int cpt=0;cpt<nbEnregistrement;cpt++)
        {
            uneLigne = mysql_fetch_row(result);
            aRailVirtuel[cpt]->idrail_virtuel = uneLigne[0];     //idrail_virtuel
            aRailVirtuel[cpt]->position_h = atoi(uneLigne[1]);   //position_h
            aRailVirtuel[cpt]->largeur = atoi(uneLigne[2]);      //largeur
            aRailVirtuel[cpt]->type = uneLigne[3];               //type de RV
            aRailVirtuel[cpt]->idtablette = uneLigne[4];         //idtablette
        }
    }
    mysql_free_result(result);
    return nbEnregistrement;

mais la solution préférée est vraiment celle qui utilise std::vector car elle te dégage de la responsabilité de la gestion dynamique de la mémoire ;)

08/11/2012, 13h56
lothar83fr

Whoua merci a vous deux pour la qualité de vos réponses!
Par soucis de rapidité, je préfère corriger le code existant par le passage de référence sur pointeur mais effectivement les vecteurs me semblent bien plus appropriés. Ca sera pour la prochaine fois ;)
Encore merci!
08/11/2012, 15h11
ternel

C'est plus rapide de prendre un vecteur, parce que tu auras plein d'endroit ou ne pas gérer la mémoire.

Ici, ta fonction alloue le résultat, mais comment es-tu certains que son appeleur la libérera?