Discussion: Jeu de la vie

  1. #1
    Membre à l'essai
    Profil pro
    Inscrit en
    décembre 2003
    Messages
    32
    Détails du profil
    Informations personnelles :
    Localisation : France

    Informations forums :
    Inscription : décembre 2003
    Messages : 32
    Points : 15
    Points
    15

    Par défaut Jeu de la vie

    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.

  2. #2
    Modérateur
    Avatar de dinobogan
    Homme Profil pro
    ingénieur
    Inscrit en
    juin 2007
    Messages
    3 962
    Détails du profil
    Informations personnelles :
    Sexe : Homme
    Âge : 36
    Localisation : France

    Informations professionnelles :
    Activité : ingénieur
    Secteur : High Tech - Éditeur de logiciels

    Informations forums :
    Inscription : juin 2007
    Messages : 3 962
    Points : 6 921
    Points
    6 921

    Par défaut

    Citation Envoyé par l ours blanc Voir le message
    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.
    N'oubliez pas de consulter les FAQ Java et les cours et tutoriels Java
    Que la force de la puissance soit avec le courage de ta sagesse.

  3. #3
    Membre expert
    Homme Profil pro
    Ingénieur développement matériel électronique
    Inscrit en
    décembre 2015
    Messages
    647
    Détails du profil
    Informations personnelles :
    Sexe : Homme
    Localisation : France, Bouches du Rhône (Provence Alpes Côte d'Azur)

    Informations professionnelles :
    Activité : Ingénieur développement matériel électronique
    Secteur : High Tech - Électronique et micro-électronique

    Informations forums :
    Inscription : décembre 2015
    Messages : 647
    Points : 3 220
    Points
    3 220

    Par défaut

    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.

  4. #4
    Membre à l'essai
    Profil pro
    Inscrit en
    décembre 2003
    Messages
    32
    Détails du profil
    Informations personnelles :
    Localisation : France

    Informations forums :
    Inscription : décembre 2003
    Messages : 32
    Points : 15
    Points
    15

    Par défaut

    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.

  5. #5
    Modérateur
    Avatar de dinobogan
    Homme Profil pro
    ingénieur
    Inscrit en
    juin 2007
    Messages
    3 962
    Détails du profil
    Informations personnelles :
    Sexe : Homme
    Âge : 36
    Localisation : France

    Informations professionnelles :
    Activité : ingénieur
    Secteur : High Tech - Éditeur de logiciels

    Informations forums :
    Inscription : juin 2007
    Messages : 3 962
    Points : 6 921
    Points
    6 921

    Par défaut

    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 ;-)
    N'oubliez pas de consulter les FAQ Java et les cours et tutoriels Java
    Que la force de la puissance soit avec le courage de ta sagesse.

  6. #6
    Expert confirmé
    Homme Profil pro
    Analyste/ Programmeur
    Inscrit en
    juillet 2013
    Messages
    2 234
    Détails du profil
    Informations personnelles :
    Sexe : Homme
    Localisation : France, Bouches du Rhône (Provence Alpes Côte d'Azur)

    Informations professionnelles :
    Activité : Analyste/ Programmeur

    Informations forums :
    Inscription : juillet 2013
    Messages : 2 234
    Points : 4 957
    Points
    4 957

    Par défaut

    Citation Envoyé par l ours blanc Voir le message
    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.


    Citation Envoyé par dinobogan Voir le message
    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)

  7. #7
    Membre expert
    Inscrit en
    mars 2005
    Messages
    1 169
    Détails du profil
    Informations forums :
    Inscription : mars 2005
    Messages : 1 169
    Points : 3 386
    Points
    3 386

    Par défaut

    Citation Envoyé par l ours blanc Voir le message
    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).

  8. #8
    Expert éminent sénior
    Avatar de Sve@r
    Homme Profil pro
    Ingénieur développement logiciels
    Inscrit en
    février 2006
    Messages
    5 935
    Détails du profil
    Informations personnelles :
    Sexe : Homme
    Âge : 49
    Localisation : France, Oise (Picardie)

    Informations professionnelles :
    Activité : Ingénieur développement logiciels
    Secteur : Aéronautique - Marine - Espace - Armement

    Informations forums :
    Inscription : février 2006
    Messages : 5 935
    Points : 16 401
    Points
    16 401
    Billets dans le blog
    1

    Par défaut

    Citation Envoyé par l ours blanc Voir le message
    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...

    Citation Envoyé par l ours blanc Voir le message
    -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...
    Mon Tutoriel sur la programmation «Shell»
    Sinon il y en a pleins d'autres. N'oubliez pas non plus les différentes faq disponibles sur ce site

Discussions similaires

  1. Problème jeu de la vie de Wolfram
    Par romromp dans le forum Pascal
    Réponses: 14
    Dernier message: 11/03/2007, 20h58
  2. algorithme d'évolution du "jeu de la vie" en caml
    Par nono88 dans le forum Général Algorithmique
    Réponses: 6
    Dernier message: 13/12/2006, 01h56
  3. Conway's life (jeu de la vie) pour images
    Par O( N ) dans le forum C
    Réponses: 1
    Dernier message: 26/09/2006, 03h13
  4. [Conception] Jeu de la vie
    Par deuscapser dans le forum Général Java
    Réponses: 16
    Dernier message: 09/03/2006, 13h47
  5. [VB] projet à réaliser: Jeu de la vie
    Par mauriiice dans le forum VB 6 et antérieur
    Réponses: 5
    Dernier message: 02/12/2005, 21h06

Partager

Partager
  • Envoyer la discussion sur Viadeo
  • Envoyer la discussion sur Twitter
  • Envoyer la discussion sur Google
  • Envoyer la discussion sur Facebook
  • Envoyer la discussion sur Digg
  • Envoyer la discussion sur Delicious
  • Envoyer la discussion sur MySpace
  • Envoyer la discussion sur Yahoo