Probleme de debutant

Version imprimable

Bonjour,

Je me retrouve confronte a un probleme que je ne pensais pas avoir.

J'ai declarer une structure nommé "Piece".

Voici le main :

Code:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
 
int main(int argc, char *argv[])
{
    /* Debut du code */
 
    /* Creation du tableau recapitulant les pieces */
    Piece ListePiece[NOMBRE_DE_PIECE];
    InitialisationListePiece (ListePiece);
 
    /* Un pointeur vers une Piece */
    Piece *PieceCourante = &(ListePiece[T]);
 
    /* Plein de code sans rapport */
 
    RotationPiece(PieceCourante, "horaire");
 
    /* Fin du code */
 
    return EXIT_SUCCESS;
 
}

Voici la fonction RotationPiece :

Code:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
 
void RotationPiece (Piece *UnePiece, char Sens[])
{
    int futurPositionX;
    int futurPositionY;
 
    if (strcmp("horaire",Sens) == 0)
    {
        futurPositionX = UnePiece->positionPiece.x + UnePiece->positionSuivant.x;
        futurPositionY = UnePiece->positionPiece.y + UnePiece->positionSuivant.y;
 
        UnePiece = UnePiece->suivant;
 
        UnePiece->positionPiece.x = futurPositionX;
        UnePiece->positionPiece.y = futurPositionY;
    }
    else
    {
        futurPositionX = UnePiece->positionPiece.x + UnePiece->positionPrecedent.x;
        futurPositionY = UnePiece->positionPiece.y + UnePiece->positionPrecedent.y;
 
        UnePiece = UnePiece->precedent;
 
        UnePiece->positionPiece.x = futurPositionX;
        UnePiece->positionPiece.y = futurPositionY;
    }
}

Bon, normalement, lorsque j'appelle RotationPiece, mon pointeur devrait pointer vers une autre instance de structure grace a UnePiece = UnePiece->suivant;

Or, cette modification n'est pas faite.
Je pensais pourtant en envoyant un pointeur que cela irai, mais apparement non.

Ou est mon erreur ? :cry:

Je sais qu'en envoyant un pointeur sur mon pointeur, ca marche, mais je pensais que cela été inutile.

05/08/2009, 18h48
ram-0000

Hé non, dans ce cas, il faut bien un pointeur de pointeur en paramètre de la fonction et passer l'adresse du pointeur à la fonction :P

Sinon, ce que ta fonction appelée modifie est perdu pour l'appelant.
05/08/2009, 18h57
SofEvans

Merci, mais pourquoi ?????

est-ce parce que c'est une structure ? Ou bien parce que l'element initial est dans un tableau ?

Parce que (*UnePiece) = (*UnePiece)->suivant; , c'est vraiment moche ...
05/08/2009, 19h13
ram-0000
Je ne sais pas bien l'expliquer de manière scolaire (je ne suis pas prof :P) mais :

Lorsque une fonction doit modifier une valeur passée en paramètre, il faut passer l'adresse de cette valeur afin que l'appelant puisse travailler avec cette nouvelle valeur.

Ceci est valable pour un type simple comme int mais aussi pour un pointeur. Quand une fonction veut modifier une variable de l'appelant, il faut passer cette variable par adresse et pas par valeur. Si la variable est passée par valeur, elle est modifiée dans la fonction et la portée de cette modification reste dans la fonction appelée.

Voici un exemple simple avec un type int mais c'est le même raisonnement avec un pointeur sur struct de ce que tu veux.
Code:

1 2 3 4 5 6 7 8 9 10 11 12 13 void double(int *p_var) { int val = *p_var; *p_var = val * 2; } void main(void) { int var = 12; double(var); // ici var vaut 24 }
Ceci dit, si quelqu'un a mieux comme explication, je suis preneur aussi.
05/08/2009, 19h17
SofEvans

Ca y est, en posant calmement le fonctionnement de mon code, j'ai reussi a comprendre pourquoi je devais utiliser un pointeur de pointeur sur struct.

Merci beaucoup.