Le jeu de la vie - compréhension des pointeurs

Version imprimable

Bonjour, je débute en c. je me suis intéressé au jeu de la vie et ai trouvé un programme de ce jeu sur ce même site. Cependant une partie du programme m'échappe car je ne suis pas encore très à l'aise avec les pointeurs.
Je vous remercie pour votre aide et m'excuse pour les fautes d'orthographe.
La partie que je ne comprends pas est la fonction nb_voisin.
Ci-dessous le code :

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
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
#include <stdlib.h>
#include <stdio.h>
#include <time.h>
#define TAILLE 10
void init_damier(int (*damier)[TAILLE][TAILLE]); //initialisation du damier
void afficher_matrice(int (*damier)[TAILLE][TAILLE]); //affichage du damier
int nb_voisin(int i, int j, int (*damier)[TAILLE][TAILLE]); //comptage du nombre de voisins vivants/morts
void cel_vivante(int* cellule, int nb_voisin);  //changement des cellules en fonction du nb voisins
void next_gen(int (*damier)[TAILLE][TAILLE]); //generation suivante
#define VIVANTE 1
#define MORTE 0
int main()
{
    int damier[TAILLE][TAILLE];
    srand(time(NULL));
    init_damier(&damier);
    afficher_matrice(&damier);
    next_gen(&damier);
    afficher_matrice(&damier);
    return 0;
}
void init_damier(int (*damier)[TAILLE][TAILLE])
{
    int i, j;
    for (i = 0; i < TAILLE; ++i) {
        for (j = 0; j < TAILLE; ++j) {
            if((rand()%100) < 20) {
                (*damier)[i][j] = VIVANTE;
            } else  {
                (*damier)[i][j] = MORTE;
            }
        }
    }
}
void afficher_matrice(int (*damier)[TAILLE][TAILLE])
{
    int i, j;
    for (i = 0; i < TAILLE; ++i) {
        for (j = 0; j < TAILLE; ++j) {
            if ((*damier)[i][j] == VIVANTE) {
                printf("0" );
            } else {
                printf("-" );
            }
        }
        printf("\n" );
    }
    printf("\n" );
}
#define MODT(i)  ((TAILLE + (i)) % TAILLE)
int nb_voisin(int i, int j, int (*damier)[TAILLE][TAILLE])
{
    return (*damier)[MODT(i-1)][MODT(j-1)] + (*damier)[MODT(i-1)][MODT(j)]
           + (*damier)[MODT(i-1)][MODT(j+1)] + (*damier)[MODT(i)][MODT(j-1)]
           + (*damier)[MODT(i)][MODT(j+1)] + (*damier)[MODT(i+1)][MODT(j-1)]
           + (*damier)[MODT(i+1)][MODT(j)] + (*damier)[MODT(i+1)][MODT(j+1)];
}
void cel_vivante(int* cellule, int nb_voisin)
{
    if (*cellule == VIVANTE) {
        if ((nb_voisin <= 1) || (nb_voisin >=4)) {
            *cellule = MORTE;
        }
    } else {
        if (nb_voisin == 3) {
            *cellule = VIVANTE;
        }
    }
}
void next_gen(int (*damier)[TAILLE][TAILLE])
{
    int i,j;
    for(i = 0; i < TAILLE; ++i) {
        for (j = 0; j < TAILLE; ++j) {
            cel_vivante(&(*damier)[i][j], nb_voisin(i,j,damier)); //on change la cellule si elle satisfait les conditions
        }
    }
}

Bonjour,
C'est difficile d'expliquer les pointeurs à partir d'un code écrit par quelqu'un qui ne les a pas bien compris. Il y a systématiquement une indirection de trop dans ce code. Commençons par réécrire correctement la fonction.
Code:

1 2 3 4 5 6 7 8 #define MODT(i) ((TAILLE + (i)) % TAILLE) int nb_voisin( int i, int j, int const damier[][TAILLE] ) { return damier[MODT(i-1)][MODT(j-1)] + damier[MODT(i-1)][j] + damier[MODT(i-1)][MODT(j+1)] + damier[i][MODT(j-1)] + damier[i][MODT(j+1)] + damier[MODT(i+1)][MODT(j-1)] + damier[MODT(i+1)][j] + damier[MODT(i+1)][MODT(j+1)]; }
Cette fonction examine les 8 cases contiguës à la case (i,j), elle utilise le fait que VIVANTE vaut 1 et MORTE vaut 0, et donc en ajoutant ces cases on obtient bien le nombre de VIVANTEs autour de (i,j).
Par exemple, la case à gauche est damier[i-1][j]. Mais que faire si i vaut 0, il n'y a pas de case à gauche. On est ici dans le cas où on considère que la table est cyclique, et donc que la case à considérer à gauche est la case [TAILLE-1][j]. Pour cela il force par un modulo à rester entre 0 et TAILLE-1. la formule (TAILLE+i)%TAILLE dans la macro MODT() gère cette conversion.

Je n'ai pas parlé de pointeur. Pourtant damier est bien ici un pointeur. Il pointe sur le premier élément d'un tableau de tableaux, et s'utilise comme s'il était un tableau de tableaux.

Bonjour

Tu ne peux pas comprendre les pointeurs sans avoir appris les pointeurs. Et tu n'apprendras pas les pointeurs en lisant un code qui est présumé fait pour quelqu'un qui les connait déjà. Apprendre les pointeurs c'est faire tes propres essais avec éventuellement des exemples simples qui expliquent les notions de base.

Pour comprendre les pointeurs, il faut savoir
sur quels principes ils s'appuient
à quoi ils servent
leur syntaxe

Sur quoi ils s'appuient: ils s'appuient sur le fait que le programme a beau être découpé en fonction, il n'y a qu'une seule grosse zone mémoire pour tout ça. Et donc même si une fonction n'a qu'une petite partie de cette mémoire qui lui est allouée pour ses propres variables (variables locales à la fonction), si elle connait l'adresse d'une autre partie elle a tout à fait le droit d'aller à cette adresse voir ce qu'il y a, bien que cette autre adresse soit dans une partie de la mémoire utilisée par une autre fonction.

A quoi ils servent: principalement pour qu'une fonctionX puisse modifier une variable située dans une fonctionY. Car même si la fonctionY passe la variable à la fonctionX, cette dernière n'en reçoit qu'une copie et donc même si elle la modifie, elle ne modifie que la copie. Si elle veut modifier l'original, elle doit aller à l'adresse correspondant à cet original pour le modifier. Or une adresse en C se stocke dans un pointeur.
Une autre utilité est de pouvoir accéder très rapidement à un élément [x] d'un tableau. En effet, tous les éléments d'un tableau se suivent en mémoire. Or l'accès par indice (par crochets) est long (enfin "long" du point de vue processeur mais si tu fais du C c'est parce que tu veux aller vite donc autant ne rien perdre bêtement). Or si tu places un pointeur sur ledit élément, l'accès par pointeur est alors immédiat. Et pour placer un pointeur sur un élément X d'un tableau, suffit de le placer sur le tableau et ensuite l'incrémenter. Le C "reconnaissant" la nature "tableau" du pointeur remplacera cet incrément par un décalage approprié ce qui fait que chaque incrément placera le pointeur sur l'élément suivant du tableau.

La syntaxe: c'est le plus compliqué à comprendre car celle-ci utilise l'étoile de deux façons différentes. Dans une déclaration, l'étoile signifie "ceci est un pointeur" tandis que dans une expression, elle signifie "la case mémoire pointée par ce pointeur". Donc si j'écris int *pt cela signifie "pt est un pointeur" tandis qu'écrire *pt=123 signifie "à la case pointée par pt j'y mets la valeur 123".
Mais pourquoi mettre une étoile? Puisqu'une adresse est un simple nombre, ne pourrait-on pas utiliser un simple int pour le stocker? Malheureusement non car l'étoile permet aussi de montrer autre chose: dans l'écriture int *pt, cela indique "pt est un pointeur (il va stocker une adresse)" et aussi "à cette adresse *pt il y a un int" (par opposion au fait qu'il pourrait y avoir un float, un long ou autre) ; chose qu'on ne pourrait pas avoir avec un simple int pour stocker cette adresse.

Et enfin un exemple: une fonction qui permute 2 int.
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 28 29 30 31 32 33 #include <stdio.h> // La fonction va permuter deux int // Elle va donc recevoir les adresses de ces variables pour pouvoir les modifier // Elle stockera ces adresses dans des pointeurs void permut(int *x, int *y) { // Une variable de transfert int tmp; // On sauvegarde la valeur de la première tmp=(*x); // On place la seconde dans la première *x=(*y); // On remet la sauvegarde dans la seconde *y=tmp; } // Test int main() { int a=123; int b=456; // Affichage initial printf("a=%d, b=%d\n", a, b); // Permutation - On passe les adresses des variables à la fonction permut(&a, &b); // Vérification printf("a=%d, b=%d\n", a, b); }
Et un exemple qui montre comment on peut utiliser un pointeur pour traiter un tableau
Code:

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 #include <stdio.h> // Test int main() { int tab[]={10, 20, 30, 40, 50, -1}; size_t i; // Affichage classique printf("\n"); for (i=0; tab[i] != -1; i++) printf("Tab[%hu]=%d (carré=%d)\n", i, tab[i], tab[i] * tab[i]); // Quatre appels à tab[i] => quatre fois le même calcul pour se placer sur l'indice [i] // Utilisation d'un pointeur int *pt; printf("\n"); for (pt=tab, i=0; *pt != -1; pt++, i++) printf("Tab[%hu]=%d (carré=%d)\n", i, *pt, (*pt) * (*pt)); // Le pointeur est incrémenté une seule fois - On peut l'utiliser quatre fois cela ne coûte rien }