Aide C++ : Structure & Fichier

tu pe verifier mon programme car jarrive pa a obtenir ce quil me demande voila ce quil ve

Jeu de vie ou mort
Sur une matrice n x n, une "situation" est composée de cases noires et de cases blanches. Les
cases noires indiquent une "situation de vie", et les cases blanches, une "situation de mort".
Pour une case m[i][j], on définit quatre voisins :
m[i-1][j], m[i+1][j], m[i][j-1] et m[i][j+1].
À chaque tour de jeu, on réexamine la situation des cases de la grille selon les règles
suivantes:
Quatre voisins noirs : "mort par étouffement".
Si la case est blanche, elle reste blanche.
Si la case est noire, elle devient blanche.
Trois voisins noirs : aucun changement.
Deux voisins noirs : "naissance".
Si la case est noire, elle reste noire.
Si la case est blanche, elle devient noire.
Un voisin noir : aucun changement
Zéro voisin noir : "mort par isolement".
Si la case est blanche, elle reste blanche.
Si la case est noire, elle devient blanche.
Écrire un programme qui, après avoir lu une configuration initiale, demande à l'utilisateur le
nombre d'étapes qu'il veut visualiser, et les affiche une à une à l'écran.
Le problème peut être simplifié en prenant une matrice (n+2)x(n+2) dont les contours sont
toujours blancs. En effet, comme les cases blanches n'interviennent pas dans la décision de
modification de l'état d'une case, cette bordure rajoutée artificiellement permettra de ne pas
faire de traitement particulier pour les cases de bordure ou pour les cases d'angle de la matrice
n x n, qui sans cela ne posséderaient que deux ou trois voisins chacune.
On pourra tester le programme produit sur la configuration initiale suivante :
Pour cela, créer un tableau contenant 49 caractères B (pour "blanc") ou N (pour "noir") dans
un ordre qui corresponde à la configuration du dessin ci-dessus, lue ligne par ligne.
On aura intérêt à utiliser les définitions suivantes :
#define T 9
char grille[T][T];
On écrira les fonctions suivantes :
· initialise : initialise la matrice, en mettant des cases blanches sur tout le contour, et en
lisant la couleur initiale de chacune des cases non situées au bord.
· compte : retourne le nombre de voisins noirs d'une case.
· change : calcule une nouvelle situation.
Attention :
Pour l'écriture de cette fonction, il est absolument nécessaire de compter le nombre de
voisins noirs de chaque case en se référant à la situation précédente, et non à la
situation courante.
· affiche : affiche une situation, par exemple sous la forme suivante :
Combien d'étapes souhaitez-vous visualiser : 15
Etape : 0
B B B B B B N
B B B B B N N
B B B B N N N
B B B N N N N
B B N N N N N
B N N N N N N
N N N N N N N
Etape : 1
...
Etape : 15
N N N N N N N
N N B N B N N
N B N N N B N
N N N B N N N
N B N N B N N
N N B N N B N
N N N N N N N
>

et voila mon programme:

#include <stdio.h>
#define T 9

main()

{
char grille[T][T];
int ligne,colone,limit_debut,limit_fin,nombres_de_voisins_noirs;
int nombre_etape_choisi,numero_etape;

numero_etape = 0;
printf("Combien d'etapes souhaiter vous voir?\n");
scanf("%d", &nombre_etape_choisi);

/*--------------------------------------------------------------------------------------------- */
/* FONCTION INITIALISATION GRILLE */
/*--------------------------------------------------------------------------------------------- */

// On initialise tout avec "B" en prenant en compte les bordures

for (ligne=0; ligne <= 9; ligne++)
{
for (colone=0; colone < 9; colone++)
{
grille[ligne][colone] = 'B';
}
grille[ligne][colone] = grille[ligne+1][colone];
printf("\n");
}

// On initialise tout sauf les bordures

limit_debut = 7;
limit_fin = 0;

for (ligne=1; ligne <= 7; ligne++)
{
for (colone=1; colone < 8; colone++)
{

if(colone >= limit_debut || colone <= limit_fin )
{grille[ligne][colone] = 'N';}
}
limit_debut = limit_debut - 1;
}

// FONCTION AFFICHAGE
system("cls");
printf("\n-----Etape %d-----\n", numero_etape);

for (ligne=1; ligne < 8; ligne++)
{
for (colone=1; colone < 8; colone++)
{
printf("%1c ", grille[ligne][colone]);
}
grille[ligne][colone] = grille[ligne+1][colone];
printf("\n");
}
system("PAUSE");

do{

numero_etape++;
system("cls");

printf("\n-----Etape %d-----\n", numero_etape);
/*--------------------------------------------------------------------------------------------- */
/* FONCTION AFFICHAGE GRILLE */
/*--------------------------------------------------------------------------------------------- */

// FONCTION AFFICHAGE

for (ligne=1; ligne < 8; ligne++)
{
for (colone=1; colone < 8; colone++)
{

/*--------------------------------------------------------------------------------------------- */
/* FONCTION NOMBRE3 VOISINS */
/*--------------------------------------------------------------------------------------------- */

nombres_de_voisins_noirs = 0;

if(grille[ligne - 1][colone] == 'N')
{nombres_de_voisins_noirs++;};
if(grille[ligne + 1][colone] == 'N')
{nombres_de_voisins_noirs++;};
if(grille[ligne][colone - 1] == 'N')
{nombres_de_voisins_noirs++;};
if(grille[ligne][colone + 1] == 'N')
{nombres_de_voisins_noirs++;} ;

/*--------------------------------------------------------------------------------------------- */
/* FONCTION CHANGEMENT SITUATION */
/*--------------------------------------------------------------------------------------------- */

switch(nombres_de_voisins_noirs)
{
case 0:
if(grille[ligne][colone] == 'N')
{
grille[ligne][colone] = 'B';
}
break;
case 2:
if(grille[ligne][colone] == 'B')
{
grille[ligne][colone] = 'N';
}
break;
case 4:
if(grille[ligne][colone] == 'N')
{
grille[ligne][colone] = 'B';
}
break;
default:
break;
}

printf("%1c ", grille[ligne][colone]);
}

printf("\n");
}
system("PAUSE");

}while(numero_etape != nombre_etape_choisi);

printf("\n");
system("PAUSE");
}

/*--------------------------------------------------------------------------------------------- */
/* FONCTION CHANGEMENT SITUATION */
/*--------------------------------------------------------------------------------------------- */

tu pourra me le faire avan mardi stp fo ke je le rend jeudi mersi d'avance