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 }