Discussion :

[nault]

Bien le bonsoir

Je me casse la tête depuis un bon 2 heures la dessus.

Je tiens a mentionner que j'ai commencer le C que récemment
Donc, ne soyer po trop dur svp hehe.

En gros j'ai une structure Stage, et dedans, il peut y avoir un nombre X de cases.
Les cases aussi son de type structure;

1- Jai creé mes 2 structures

stage à une variable Sokoban_Stage_Case* cases; qui va pointer vers une
allocation de mémoire de malloc caster en (Sokoban_Stage_Case*)

Mon problème vient de mon loop,
j'arrive à assigner des valeurs, mais pas à les afficher.
je suis a peut près certain que dans mon loop (Stage.cases + iii) est l'adresse mémoire

pkoi (Stage.cases + iii)->x = kkchose , fonction
et *(Stage.cases + iii).x ou *(Stage.cases + iii).y ne marche pas ?

Merci mille fois d'avance, j'ai hate de continuer mon jeux!

ps : Tout est dans la main() juste pour lexpliquation, ça ne sera pas là en bout de ligne...

Code :

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

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
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
 
int main ( int argc, char** argv )
{
    int i,ii,iii,iiii;
    int nbOfRow = 4; // Number of Rows (will be dynamic value)
    int nbOfCol = 6; // Number of Cols (will be dynamic value)
 
    // Case structure
    typedef struct Sokoban_Stage_Case Sokoban_Stage_Case;
    struct Sokoban_Stage_Case {
        int x;
        int y;
    };
 
 
    // Stage structure
    typedef struct Sokoban_Stage Sokoban_Stage;
    struct Sokoban_Stage {
        int nbOfCase;
        int nbOfRow;
        int nbOfCol;
        Sokoban_Stage_Case* cases;
    };
 
    // New stage
    Sokoban_Stage Stage;
    Stage.nbOfRow  = nbOfRow;
    Stage.nbOfCol  = nbOfCol;
    Stage.nbOfCase = (nbOfRow * nbOfCol);
    Stage.cases    = (Sokoban_Stage_Case*) malloc(sizeof(Sokoban_Stage_Case) * Stage.nbOfCase);
 
    // Fill coord to all stage.cases
    iii=0;
    for (i=0;i<Stage.nbOfRow;i++) {
        for (ii=0;ii<Stage.nbOfCol;ii++) {
            printf("(%d,",i);
            printf("%d)\n",ii);
 
            (Stage.cases + iii)->x = i;
            (Stage.cases + iii)->y = ii;
 
            printf("  (%d,",*(Stage.cases + iii)); // Get the X cool
            printf("%d)\n",*(Stage.cases + iii+1)); // how i target the y?
            iii++;
        }
    }
 
    return 0;
}

[diogene]

- A noter que *(Stage.cases + iii) est équivalent à Stage.cases[iii]

- Stage est une structure Sokoban_Stage

- Stage.cases est un pointeur sur des Sokoban_Stage_Case : Sokoban_Stage_Case *

- Stage.cases[iii] est donc un Sokoban_Stage_Case (le iii+1 ième élément du tableau débutant en Stage.cases).

- Stage.cases[iii].x et Stage.cases[iii].y sont les deux champs de la stucture Sokoban_Stage_Case

(ps: un effort sur la rédaction et l'orthographe serait le très bienvenu)

[nault]

- A noter que *(Stage.cases + iii) est équivalent à Stage.cases[iii]

- Stage.cases[iii].x et Stage.cases[iii].y sont les deux champs de la stucture Sokoban_Stage_Case

(ps: un effort sur la rédaction et l'orthographe serait le très bienvenu)

j'aurais besoin de clarifications svp,

donc :

1 - Stage.cases provient de (Sokoban_Stage_Case*) malloc(sizeof(Sokoban_Stage_Case) * Stage.nbOfCase);

question : Pourquoi peut-on utiliser les crochets[ ] comme si c'étais un array?

C'est comme si :
Sokoban_Stage_Case cases[24];

Retournerais la même chose que:
Sokoban_Stage_Case* cases = (Sokoban_Stage_Case*) malloc(sizeof(Sokoban_Stage_Case) * 24);

Si je comprend bien, un array est comme le retour de malloc, l'adresse du premier élément d'une suite de variables/object du même type en mémoire ?

Donc quand on fait par exemple case[iii] suite au return de malloc

J'en deduis que cela doit aller comme suit ?:
2- Ok, il veuy la 3e case
3- Il regarde kel est ladresse de la première case
4- Il regarde la taille dun element (sizeof struc casse)...
5- Avec la taille de lelement +l'adresse de départ et l'info qu'on demande la 3e caisse ... /// c'est ici que cest +- clair (que ce passe t'il réellement en arrière)
6- Retourne l'adresse mémoire trouvé.

Merci beucoup encore, j'adore vraiment le C jusqua présent même si comparé a php c'est plus long de programmer hehe, Mais j'ai l'impression quon a bcp plus notre pc en contrôle

Je vais aller lire ton doc Diogene, même si il me semble en haut de mon niveau actuelle.

ps : je viens de survoler mon texte pour l'orthographe :S désolé c'est fou comme je n'avais pas fait attention. Il doit rester des erreurs pareils si vous les voyés et si cela vous choque, je le corigerai.



merci aussi jmv!

[diogene]

question : Pourquoi peut-on utiliser les crochets[ ] comme si c'étais un array?

Il ne faut pas confondre deux situations : la définition de variables et le code qui va s'exécuter.

* Partons de tes deux exemples :
-cas 1 Sokoban_Stage_Case cases[24]; est une définition de la variable (objet) cases et dans ce cas les signes [] servent à dire que cases est un tableau.

-cas 2 Sokoban_Stage_Case* cases = (Sokoban_Stage_Case*) malloc(sizeof(Sokoban_Stage_Case) * 24); est une autre définition de la variable cases comme pointeur (initialisé par le malloc()).

Ces deux choses sont donc radicalement différentes.

* Maintenant considérons l'expression cases[iii] qui va être évaluée à l'exécution du programme.
Dans ce cas [] est un opérateur ( comme + , - ou sizeof ou ....). C'est un opérateur qui permet de simplifier l'écriture du code et qui est défini à partir des opérateurs * et + (entre adresse et entier, donc voir l'arithmétique des adresses) : cases[iii] est équivalent à *(cases+iii) (accessoirement, c'est donc aussi équivalent à iii[cases], mais ce n'est vraiment pas une écriture à utiliser). L'opérateur [] a deux opérandes : une adresse (ici cases) et un entier (ici iii).

Si je comprend bien, un array est comme le retour de malloc, l'adresse du premier élément d'une suite de variables/object du même type en mémoire ?

Non, un tableau n'est pas une adresse ni un objet pointeur.
MAIS,
- l'identificateur A d'un tableau représente le tableau dans 3 types d'expressions : &A (adresse de A), sizeof A et (A).
- Dans tous les autres types d'expressions (y compris comme argument des fonctions), l'identificateur A représente l'adresse du premier élément du tableau A.

Si dans le cas 1 on fait sizeof cases on obtient 24*sizeof(Sokoban_Stage_Case) alors que dans le cas 2 on obtient la taille d'un pointeur.
Mais quand on écrit case[iii], dans les deux cas 1 et 2, cases représente l'adresse du premier élément du tableau alloué (dynamiquement pour le cas 2).

[nault]

Merci Diogene pour cette réponse complète.

Je dois avouer que même si tout ça doit être d'une logique naturelle pour vous,
De mon bord,cela en fait beacuoup à ingerer du même coup.
mais je sens que ca commence a rentrer.

Je viens de lire ta doc, vraiment utile, c'est le genre de doc que je cherchais cette semaine. si tu as d'autres ouvrages docs etc a me conseiller, ca me ferais plaisir de les lires

encore merci!

[jmv]

Bonjour,

C'est un problème de priorité d'opérateur car avec une paire de parenthèse en plus, ça passe.

Code :

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

 (*(Stage.cases + iii)).x = i;

Le code que tu as posté ne compile chez moi (cc sous linux), il y a des erreurs lignes 44 et 45, voici le code corrigé :

Code :

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

1
2
            printf("  (%d,",(Stage.cases + iii)->x); // Get the X cool
            printf("%d)\n", (Stage.cases + iii)->y); // how i target the y?

a+
jm
[EDIT]argh ! pris de vitesse par diogene [/EDIT]