Jeu de la vie

**l ours blanc** · 09/01/2018, 00h14

Bonjour,

J'ai trouvé un petit exercice dans un des cours du site. (ici)
Donc objectif réussi pour ma part. Voila la solution que j'ai trouvé :

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
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
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
/**************************************
            JEU DE LA VIE
****************************************/
#include <stdio.h>
#include <stdlib.h>
#include <time.h>
 
#define TAILLE_SUR_MATRICE  50
/* Taille de la matrice contenant */
/* les cellules + 2 pour la bordure */
/****************************************/
/*******   P R O T O T Y P E S   ********/
/****************************************/
/* Initialisation de la matrice de départ */
void init(int matrice [][TAILLE_SUR_MATRICE ]);
/* Indique pour la cellule de coordonnées (ligne,colonne) */
/* le nombre de cellules voisines vivantes */
int nombre_voisins (int matrice [][TAILLE_SUR_MATRICE], int ligne, int colonne);
/* Réalise une étape de plus dans la mise à jour de la matrice: */
/* autrement dit, on réalise un cycle de vie */
void mise_a_jour(int matrice[][TAILLE_SUR_MATRICE]);
/* Affichage de la matrice en cours */
void affiche_matrice(int matrice [][TAILLE_SUR_MATRICE]);
/****************************************/
/*******   F O N C T I O N S   **********/
/****************************************/
int main() {
    int i,y,nb=0;
    int nbr_cycles;
    int matrice[TAILLE_SUR_MATRICE] [TAILLE_SUR_MATRICE ];
    init(matrice);
    printf("entrer le nombre de cycles voulus: ");
    scanf("%d",&nbr_cycles);
    do{
    affiche_matrice(matrice);
    mise_a_jour(matrice);
    nb++;
    }while(nb!=nbr_cycles);
}
 
//3=bordure 0=vide 1=cellule
void init(int matrice [][TAILLE_SUR_MATRICE]) {
    int i,y;
    srand(time(NULL));
    for(i=0;i<TAILLE_SUR_MATRICE;i++){
        for(y=0;y<TAILLE_SUR_MATRICE;y++){
            if(i<2 || i>TAILLE_SUR_MATRICE-3 || y<2 || y>TAILLE_SUR_MATRICE-3)//creer la bordure
                matrice[i][y]=3;
            else
                matrice[i][y]=rand()%2;
        }
    }
}
 
void affiche_matrice(int matrice [][TAILLE_SUR_MATRICE]){
    int i,y;
    for(i=0;i<TAILLE_SUR_MATRICE;i++){
        for(y=0;y<TAILLE_SUR_MATRICE;y++){
            if(matrice[i][y]==0)
                printf("%c",32);
            else
                if(matrice[i][y]==1)
                    printf("%c",219);
                else
                    printf("%c",43);
        }
    printf("\n");
    }
}
 
void mise_a_jour(int matrice[][TAILLE_SUR_MATRICE]){
    int i,y,nb_voisins=0;
 
    for(i=0;i<TAILLE_SUR_MATRICE;i++){
        for(y=0;y<TAILLE_SUR_MATRICE;y++){
            nb_voisins=nombre_voisins(matrice,i,y);
            if((matrice[i][y]==1) && (nb_voisins<2 || nb_voisins>3) )
                matrice[i][y]=0;
            if(matrice[i][y]==0 && nb_voisins==3)
                matrice[i][y]=1;
        }
    }
}
 
int nombre_voisins (int matrice [][TAILLE_SUR_MATRICE], int ligne, int colonne){
    int i,y,nb_voisins=0;
    if(matrice[ligne][colonne]==3)//si c est une bordure on ne fait pas de calcul
        return(1);
    else{
        for(i=ligne-1;i<ligne+2;i++){
            for(y=colonne-1;y<colonne+2;y++){
                if(matrice[i][y]!=3)
                    nb_voisins=nb_voisins+matrice[i][y];
            }
        }
        nb_voisins=nb_voisins-matrice[ligne][colonne];
        return(nb_voisins);
    }
}

Et voici celui de la correction :

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
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
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
/***************************************
            JEU DE LA VIE
***************************************/
#include <stdio.h>
#include <stdlib.h>
#define TAILLE_SOUS_MATRICE 7
/* On peut avoir 7 * 7 cellules vivantes */
#define TAILLE_SUR_MATRICE  9
/* On place une bordure autour qui facilite la vie du programmeur... */
/***************** PROTOTYPES ***********************/
void init(int matrice [][TAILLE_SUR_MATRICE ]);
int nombre_voisins (int matrice [][TAILLE_SUR_MATRICE ],
                    int ligne, int colonne);
void mise_a_jour(int matrice[][TAILLE_SUR_MATRICE ]);
void affiche_matrice(int matrice [][TAILLE_SUR_MATRICE ]);
void ligne(int largeur);
/*****************************************************/
int main( ) {
   int i;
   int nbr_cycles;
   int matrice[TAILLE_SUR_MATRICE] [TAILLE_SUR_MATRICE ];
   char s[2];
   printf("Nombre de cycles : ");
   scanf("%i",&nbr_cycles);
   init(matrice);
   printf("La population au départ : \n");
   affiche_matrice(matrice);
   printf("Pressez sur ENTER pour continuer...\n");
   gets(s);
   for(i=0; i<nbr_cycles; i++) {
      mise_a_jour (matrice);
      printf("La population après %d cycles: \n", i+1);
      affiche_matrice (matrice);
      printf("Pressez sur ENTER pour continuer...\n");
      gets(s);
   }
   return 0;
}
 
/****************************************/
/* Initialisation de la matrice */
void init(int matrice [][TAILLE_SUR_MATRICE ]) {
/****************************************/
   int i,j;
   for(i=0; i<TAILLE_SUR_MATRICE; i++) {
      for(j=0; j<TAILLE_SUR_MATRICE; j++) {
         if (i<=j && i>0 && j<=7)
            matrice[i][j]=1;
         else
            matrice[i][j]=0;
      }
   }
   /* On pourrait aussi faire une initialisation aléatoire */
}
/****************************************/
/* Calcul du nombre de voisins vivants */
int nombre_voisins (int matrice[][TAILLE_SUR_MATRICE ],
                    int ligne, int colonne) {
/****************************************/
   int compte=0; /* compteur de cellules */
   int i,j;
/* On additionne les 9 cellules centrées en ligne,colonne */
   for (i=ligne-1;i<=ligne+1;i++)
      for(j=colonne-1;j<=colonne+1;j++)
         compte=compte+matrice[i][j];
 
         /* Puis on retire celle du milieu... */
         compte -= matrice[ligne][colonne];
         return compte;
}
/****************************************/
/* Correspond à l'étape n+1 */
void mise_a_jour(int matrice[ ][TAILLE_SUR_MATRICE ]) {
/****************************************/
   int i,j;
   int nbr_voisins;
   int matrice_densite[TAILLE_SOUS_MATRICE][TAILLE_SOUS_MATRICE];
   /* matrice qui comptabilise le nombre de voisins */
   /* et cela, case par case */
   for(i=0; i< TAILLE_SOUS_MATRICE; i++)
         for(j=0; j< TAILLE_SOUS_MATRICE; j++)
            matrice_densite[i][j]=nombre_voisins(matrice,i+1,j+1);
      /* i+1 et j+1 car on passe de la SOUS_MATRICE à la MATRICE   */
 
   for(i=0; i< TAILLE_SOUS_MATRICE; i++)
      for(j=0; j< TAILLE_SOUS_MATRICE; j++) {
            nbr_voisins=matrice_densite[i][j];
            if(nbr_voisins==2)
                  matrice[i+1][j+1]=1;
            else if (nbr_voisins==0 || nbr_voisins==4)
                  matrice[i+1][j+1]=0;
   }
}
/****************************************/
/* Affichage à l'écran des cellules vivantes */
void affiche_matrice(int matrice[ ][TAILLE_SUR_MATRICE ]) {
/****************************************/
   int i,j;
   for(i=1; i<=TAILLE_SOUS_MATRICE; i++) {
      ligne(7);
      for(j=1; j<= TAILLE_SOUS_MATRICE; j++)
         if (matrice[i][j]==1)
            printf("|%c",'*');
         else
            printf("|%c",'|');
      printf("|\n");
   }
   ligne(TAILLE_SOUS_MATRICE);
}
/****************************************/
/* Tracé d'une ligne */
void ligne(int largeur) {
/****************************************/
   int i;
   for(i=0; i<largeur; i++)
      printf("+-");
   printf("+\n");
}

J'ai un peu de mal à voir en quoi la solution proposée est plus optimisée.
D'autre part je ne comprend pas pourquoi je peux passer la variable matrice de main aux autres fonctions et que les modifications sur matrice soit prisent en compte sans passer par des pointeurs.
Puis faire plus simple dans la déclaration des fonctions ?

Merci.

**dinobogan** · 09/01/2018, 11h42

Envoyé par l ours blanc

J'ai un peu de mal à voir en quoi la solution proposée est plus optimisée.

Dès qu'on parle optimisation, il faut être précis. Gain de temps ? De charge CPU ? D'utilisation mémoire ? De nombre de lignes de code ? De lisibilité du code ? Autre ?

D'autre part je ne comprend pas pourquoi je peux passer la variable matrice de main aux autres fonctions et que les modifications sur matrice soit prisent en compte sans passer par des pointeurs.

La variable matrice est déclarée comme un tableau donc gérée comme un pointeur lorsqu'elle est passée en paramètre à une fonction.

Puis faire plus simple dans la déclaration des fonctions ?

Je te donne mon point de vue, personnel et subjectif : je déteste les déclarations de paramètres du genre void init(int matrice [][TAILLE_SUR_MATRICE ]); car un tableau se suffit rarement à lui-même. Il faut quasiment toujours ajouter des infos comme la taille utilisée, la taille maximum...
Et quand bien même le tableau serait de taille fixe partout tout le temps sans besoin d'informations supplémentaires, je préfère la syntaxe plus sécurisée de la structure => on ne répète jamais de taille dans les déclarations de fonctions. Pas de répétitions donc moins de chance de se tromper. La taille est donnée une fois pour toute dans la déclaration de la structure.

Dans ce cas, j'aurai fait ainsi :

Code :

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

1
2
3
4
typedef struct
{
  int tab[LARGEUR][HAUTEUR];
} Matrice;

Dans le main :

Code :

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

1
2
Matrice ma_matrice;
init( & ma_matrice );

Exemple sur la fonction init :

Code :

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

void init(Matrice * matrice)

Les déclarations sont simplifiées et on comprend plus rapidement les signatures. Mais c'est une affaire de point de vue.

**dalfab** · 09/01/2018, 14h32

Bonjour,

Attention, ta fonction mise_a_jour() ne fonctionne pas correctement.
On ne peut pas mettre à jour les éléments générés/détruits au fur et à mesure. Car en faisant cela, tu changes le nombre de voisins de la prochaine cellule alors qu'il faut utiliser les voisins qu'elle a à la fin du cycle précédent. Le 2nd code est lui correct.

**l ours blanc** · 11/01/2018, 15h15

Merci a tout les deux pour vos réponses :p.

En effet j'ai complètement zappé ce passage.J'ai résolu le soucis en copiant matrice dans une variable doublon grâce a deux boucle for. Mais je me dis qu'il y a peut être mieux a faire pour copier un tableau a deux dimensions dans un autre tableau.

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
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
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
/**************************************
            JEU DE LA VIE
****************************************/
#include <stdio.h>
#include <stdlib.h>
#include <time.h>
 
#define TAILLE_SUR_MATRICE 9
/* Taille de la matrice contenant */
/* les cellules + 2 pour la bordure */
/****************************************/
/*******   P R O T O T Y P E S   ********/
/****************************************/
/* Initialisation de la matrice de départ */
void init(int matrice [][TAILLE_SUR_MATRICE ]);
/* Indique pour la cellule de coordonnées (ligne,colonne) */
/* le nombre de cellules voisines vivantes */
int nombre_voisins (int doublon [][TAILLE_SUR_MATRICE], int ligne, int colonne);
/* Réalise une étape de plus dans la mise à jour de la matrice: */
/* autrement dit, on réalise un cycle de vie */
void mise_a_jour(int matrice[][TAILLE_SUR_MATRICE]);
/* Affichage de la matrice en cours */
void affiche_matrice(int matrice [][TAILLE_SUR_MATRICE]);
void copie_tableau(int matrice[][TAILLE_SUR_MATRICE],int doublon [][TAILLE_SUR_MATRICE]);
/****************************************/
/*******   F O N C T I O N S   **********/
/****************************************/
int main() {
    int i,y,nb=0;
    int nbr_cycles;
    int matrice[TAILLE_SUR_MATRICE] [TAILLE_SUR_MATRICE ];
    init(matrice);
    printf("entrer le nombre de cycles voulus: ");
    scanf("%d",&nbr_cycles);
    do{
    affiche_matrice(matrice);
    mise_a_jour(matrice);
    nb++;
    }while(nb!=nbr_cycles);
}
 
//3=bordure 0=vide 1=cellule
void init(int matrice [][TAILLE_SUR_MATRICE]) {
    int i,y;
    srand(time(NULL));
    for(i=0;i<TAILLE_SUR_MATRICE;i++){
        for(y=0;y<TAILLE_SUR_MATRICE;y++){
            if(i<2 || i>TAILLE_SUR_MATRICE-3 || y<2 || y>TAILLE_SUR_MATRICE-3)//creer la bordure
                matrice[i][y]=3;
            else
                matrice[i][y]=rand()%2;
        }
    }
}
 
void affiche_matrice(int matrice [][TAILLE_SUR_MATRICE]){
    int i,y;
    for(i=0;i<TAILLE_SUR_MATRICE;i++){
        for(y=0;y<TAILLE_SUR_MATRICE;y++){
            if(matrice[i][y]==0)
                printf("%c",32);
            else
                if(matrice[i][y]==1)
                    printf("%c",219);
                else
                    printf("%c",43);
        }
    printf("\n");
    }
}
 
void mise_a_jour(int matrice[][TAILLE_SUR_MATRICE]){
    int i,y,nb_voisins=0;
    int doublon [TAILLE_SUR_MATRICE][TAILLE_SUR_MATRICE];
    copie_tableau(matrice,doublon);
    for(i=0;i<TAILLE_SUR_MATRICE;i++){
        for(y=0;y<TAILLE_SUR_MATRICE;y++){
            nb_voisins=nombre_voisins(doublon,i,y);
            if((matrice[i][y]==1) && (nb_voisins<2 || nb_voisins>3) )
                matrice[i][y]=0;
            if(matrice[i][y]==0 && nb_voisins==3)
                matrice[i][y]=1;
        }
    }
}
 
void copie_tableau(int matrice[][TAILLE_SUR_MATRICE],int doublon[][TAILLE_SUR_MATRICE]){
    int i,j;
    for(i=0;i<TAILLE_SUR_MATRICE;i++){
        for(j=0;j<TAILLE_SUR_MATRICE;j++)
            doublon[i][j]=matrice[i][j];
    }
}
 
int nombre_voisins (int doublon [][TAILLE_SUR_MATRICE], int ligne, int colonne){
    int i,y,nb_voisins=0;
    if(doublon[ligne][colonne]==3)//si c est une bordure on ne fait pas de calcul
        return(1);
    else{
        for(i=ligne-1;i<ligne+2;i++){
            for(y=colonne-1;y<colonne+2;y++){
                if(doublon[i][y]!=3)
                    nb_voisins=nb_voisins+doublon[i][y];
            }
        }
        nb_voisins=nb_voisins-doublon[ligne][colonne];
        return(nb_voisins);
    }
}

Pour l'optimisation je dirais un peu tout en fait :p. Mais la cela serait demander beaucoup.
En premier je mettrais la lisibilité du code ensuite je dirais de gain CPU même si la notion est un peu désuète vu la puissance des machines actuel.

Je me permets de posé deux autres questions.

-Pour la taille de la matrice on est passé par une variable global mais il n'aurait pas plutôt fallu passer par une variable local et la transmettre aux fonctions.Les variables globals c'est le mal non ??
-J'ai vraiment du mal avec les tableaux (surtout pour les transmettre aux fonctions).

je n'ai pas l'air d'avoir le droit de faire

Code :

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

void laFonction (monTableau [][]);

et là dans mes déclarations j'ai

Code :

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

void laFonction (monTableau [][TAILLE]);

Je ne spécifie qu'une seule dimension car elles sont identique ?
Existe t'il d'autre manière de procéder a al déclaration.

Merci d'avance pour votre aide et désoler si les questions pour vous son simple mais je ne sais pas pourquoi je bute sur les tableaux.

**dinobogan** · 11/01/2018, 16h52

Utiliser une structure contenant les données simplifie beaucoup les choses : plus simple pour le passage de paramètre, plus simple pour recopier les données.
Par exemple, copier une structure dans une autre structure se fait via "memcpy", en un seul appel.
Placer ton tableau dans une structure permet justement de mieux structurer ton programme ;-)

**foetus** · 11/01/2018, 17h35

Envoyé par l ours blanc

les modifications sur matrice soit prisent en compte sans passer par des pointeurs.

Ce n'est pas tout à fait vrai

Tu peux modifier les valeurs dans les cases mais tu ne peux pas supprimer ou créer la matrice. Pour ces 2 derniers cas, tu dois avoir un double pointeur.

Envoyé par dinobogan

Utiliser une structure contenant les données simplifie beaucoup les choses

Cela s'appelle

, selon le contexte, soit un DO (Domain Object) soit un DTO (Data Transfert Object) (<- liens wiki en anglais)

**Matt_Houston** · 11/01/2018, 23h41

Envoyé par l ours blanc

J'ai résolu le soucis en copiant matrice dans une variable doublon grâce a deux boucle for. Mais je me dis qu'il y a peut être mieux a faire pour copier un tableau a deux dimensions dans un autre tableau.

Tu peux surtout complètement éviter une copie temporaire puisque tu as besoin des deux matrices à chaque mise à jour : celle que tu consultes et celle dans laquelle tu écris. Autant allouer les deux une bonne fois pour toute et basculer de l'une à l'autre à chaque changement de génération. On appelle cela du double buffering.

Un exemple :

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
#define DIM    9
#define DIMSQ (DIM * DIM)
 
typedef struct session {
    int    grids[2 * DIMSQ]; // two grids: only one is written to each update
    size_t ngen;             // generation counter
} session_t; // game-of-life session
 
/* computes the next generation for cell at specified index */
int get_next(const int *grid, size_t pos);
 
/* computes the next generation and swaps the buffers */
void update(session_t *s) {
    const size_t curr = s->ngen++ % 2, // current generation's grid index
                 next = s->ngen   % 2; //    next generation's grid index
    const int *in  = &s->grids[curr * DIMSQ]; //  input grid (generation n)
          int *out = &s->grids[next * DIMSQ]; // output grid (generation n + 1)
 
    // fill output grid with information from input grid
    for (size_t i = 0; i < DIMSQ; ++i)
        out[i] = get_next(in, i);
 
    ++s->ngen;
}

Pour une génération donnée n, le buffer contenant la grille à jour est &grids[(n % 2) * DIM * DIM] (n % 2 vaut 0 ou 1).

**Sve@r** · 13/01/2018, 08h29

Envoyé par l ours blanc

Je me permets de posé deux autres questions.

-Pour la taille de la matrice on est passé par une variable global mais il n'aurait pas plutôt fallu passer par une variable local et la transmettre aux fonctions.Les variables globals c'est le mal non ??

Bonjour

Attention aux idées toutes faites. Généralement on conseille d'éviter les variables globales parce que, mal utilisées, elles peuvent amener plus de souci que de bienfaits. Celui qui ira écrire int i en global par fainéantise de devoir se définir son indice de boucle dans chaque fonction qui doit faire une boucle oui, lui on va lui pourrir la tête. Mais celui qui utilise une globale intelligemment nommée et réellement utile dans ses concepts parce que vraiment il en a besoin de partout on sera plus enclin à l'accepter.
D'autant plus qu'il existe des cas où la globale est incontournable, surtout dans le domaine des signaux.
Et d'autant plus qu'il est possible d'utiliser des globales tout en restant assez propre. En effet, le vrai souci des globales, c'est qu'elles sont modifiables de partout. Et donc si une globale change de valeur bizarrement, retrouver la fonction qui y a touché inconsidérément peut devenir difficile.
Mais si, au lieu d'écrire

Code c :

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

1
2
3
4
5
int variable_super_importante;
 
void init() {
    variable_super_importante=0;
}

Tu écris

Code c :

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

1
2
3
4
5
6
int variable_super_importante;
 
void init() {
    extern int variable_super_importante;
    variable_super_importante=0;
}

Ca devient de suite plus visible. En redéfinissant ta variable en "extern" dans ta fonction, 1) tu permets au compilo de passer le truc sans gueuler et à l'éditeur de lien de retrouver ses petits et 2) tu rends ton code plus lisible pour qui a besoin de savoir quelle fonction a touché à ta variable...

Envoyé par l ours blanc

-J'ai vraiment du mal avec les tableaux (surtout pour les transmettre aux fonctions).

je n'ai pas l'air d'avoir le droit de faire

Code :

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

void laFonction (monTableau [][]);

et là dans mes déclarations j'ai

Code :

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

void laFonction (monTableau [][TAILLE]);

Je ne spécifie qu'une seule dimension car elles sont identique ?
Merci d'avance pour votre aide et désoler si les questions pour vous son simple mais je ne sais pas pourquoi je bute sur les tableaux.

En fait c'est beaucoup plus simple: quoi que tu fasses, un tableau n'est au final qu'une seule suite de cases ; donc un tableau 1D. Il est donc nécessaire de pouvoir convertir un tableau xD en tableau 1D. Et pour ce faire, le truc qui fait la conversion est obligé de connaitre les dernières dimensions du tableau (il peut se passer de la première).
Prenons un tableau 2D int x[2][3]. C'est un tableau qu'on pourra se représenter comme faisant 2 lignes de 3 cases.
A1 A2 A3
B1 B2 B3

De cette représentation, tu te rends compte immédiatement que si on l'aligne (A1 A2 A3 B1 B2 B3) et qu'on veut touver une équivalence entre la matrice et la ligne, alors chaque case [x][y] se calcule de la façon suivante: x * 3 + y (exemple B3 en position [1][2] est bien la case n° 5 puisque la première A1 est la case 0). Mais pour que ce calcul puisse se faire, il a été necessaire de savoir que chaque ligne faisait 3 colonnes. En fait, seule la limite "2" est inutile à la conversion.
Donc le C, quand il a besoin de faire ses conversions d'un tableau (par exemple) 5D en tableau 1D, il a besoin de connaitre les limites des dimensions 2, 3, 4 et 5 mais peut se passer de la 1ère.
Donc si tu passes un tableau 5D (exemple int tab[2][3][4][5][6]) a une fonction, tu dois alors informer la fonction des 4 dernières limites du tableau et tu peux laisser (ou pas) la première => void fct(int tab[][3][4][5][6]) {...}.

Mais comme l'a dit dinobogan, on s'évite tous ces tracas si on encapsule le tableau dans une matrice. Surtout qu'ensuite on peut y rajouter d'autres trucs utiles...

Jeu de la vie

C

Discussions similaires

Partager

Partager