Problème lors du remplissage d'un tableau alloué dynamiquement

**yetimothee** · 28/05/2008, 20h34

Bonjour

Dans le cadre d'un petit jeu 2d que j'aimerais faire histoire de me remttre dans le bain de la prog, j'ai envie de créer un code qui :
-Ouvre un fichier.txt
-Lit les deux premières lignes du fichiers, qui servent à assigner le nombre de lignes et de colonnes qui serviront dans le niveau
-Alloue ensuite dynamiquement une "matrice"
-Remplie la matrice Matrice[i][j][l] = '0'
->C'est à cet endroit que cela pose problème : Mon programme se compile, mais dès qu'il s'allume, il coupe automatiquement...

Ca doit être une erreur du débutant toute bête, mais je n'arrive pas à la déceler

Voici le code :

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
#include <stdio.h>
#include <stdlib.h>
 
#define TAILLE_MAX 100
 
int main(int argc, char *argv[])
{
    /* Déclaration des variables */
    FILE* fichier = NULL; //On déclare le fichier
    char chaine_temp[TAILLE_MAX] = "" ;
    char carac_temp = '0' ;
    //Initialisateur de boucles
    int i = 0;
    int j = 0;
    int l = 0;
    //Taille du niveau
    int NbColonnes = 0;
    int NbLignes = 0;
    //Matrice du niveau
    char*** Matrice = {NULL} ;
 
 
    fichier = fopen("fichier.txt", "r+"); //On ouvre le fichier
    //Test de l'ouverture du fichier
    if(!fichier != NULL)
    {
        printf("erreur lors de l'ouverture du fichier !\n");
        system("PAUSE");
        return 1 ;
    }
 
    //On lit les deux premières lignes, puis on les écrits dans des variables
    for(i=0; i<2; i++)
    {
        fgets(chaine_temp, TAILLE_MAX, fichier);
        if(i == 0)
        {
            sscanf(chaine_temp, "%d", &NbColonnes); 
        }
        if(i == 1)
        {
            sscanf(chaine_temp, "%d", &NbLignes); 
        }
    }
 
    //On alloue dynamiquement le niveau
    Matrice = malloc(NbColonnes * sizeof(char));
    for(i=0; i<NbColonnes; i++)
    {
        Matrice[i] = malloc(NbLignes * sizeof(char));
    }
 
    for(i=0; i<NbColonnes; i++)
    {
        for(j=0; j<NbLignes; j++)
        {
            Matrice[i][j] = malloc(3 * sizeof(char));
        }
    }
 
    //On entre ensuite chaque valeur du fichier texte dans la Matrice
    for(j=0; j<NbLignes; j++)
    {
        for(i=0; i<NbColonnes; i++)
        {
            carac_temp = fgetc(fichier);
            if(carac_temp != ' ') //Si le caractère n'est pas un espace
            {
                for(l=0; l<3; l++)
                {   
                    //Alors on entre les 3 caractères dans le tableau
                    Matrice[i][j][l] = carac_temp ;
                }
            }
        }
    }
 
    //Vérification : on affiche le tableau !
    for(i=0; i<NbColonnes; i++)
    {
        for(j=0; j<NbLignes; j++)
        {
            for(l=0; l<3; l++)
            {
                printf("%c", Matrice[i][j][l]);
            }
        }
    }
 
 
    //On ferme le fichier
    fclose(fichier);
 
    system("PAUSE");
    return 0;
}

Voici ensuite la partie qui pose problème :

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
//On entre ensuite chaque valeur du fichier texte dans la Matrice
    for(j=0; j<NbLignes; j++)
    {
        for(i=0; i<NbColonnes; i++)
        {
            carac_temp = fgetc(fichier);
            if(carac_temp != ' ') //Si le caractère n'est pas un espace
            {
                for(l=0; l<3; l++)
                {   
                    //Alors on entre les 3 caractères dans le tableau
                    Matrice[i][j][l] = carac_temp ;
                }
            }
        }
    }

Et enfin le fichier texte :

Code :

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

1
2
3
4
5
6
7
8
9
10
11
12
10
8
000 000 000 000 000 000 000 000 000 000
000 000 000 000 000 000 000 000 000 000
000 000 000 000 000 000 000 000 000 000
000 000 000 000 000 000 000 000 000 000
000 000 000 000 000 000 000 000 000 000
000 000 000 000 000 000 000 000 000 000
000 000 000 000 000 000 000 000 000 000
000 000 000 000 000 000 000 000 000 000
000 000 000 000 000 000 000 000 000 000
000 000 000 000 000 000 000 000 000 000

Je suis prêt à donner plus de renseignement.

Merci de votre aide

**yetimothee** · 28/05/2008, 21h55

Alors, j'ai corrigé le bug, mais j'ai un autre problème, qui est lui similaire :
Lorsque je rempli mon fichier texte de "111" au lieu de "000", ça bug de nouveau...
J'ai aucunes idées là ?

EDIT : Bon, j'avais oublié de mettre "carac_temp = fgetc(fichier) ;"

Mais maintenant, il m'affiche un résultat comme celui ci :

000 x00 0
0 00?

Sachant que mon fichier texte est celui ci :

2
2
000 000
000 000

EDIT 2 : (ou chapitre 2)

Nouvel élément :
J'ai remarqué que le

Code :

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

if(carac_temp != ' ')

Ne fonctionnait pas, j'ai donc opté pour un

Code :

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

1
2
3
4
5
6
7
8
 
if(carac_temp != '<')
{
    if(carac_temp != '>')
    {
         //code
    }
}

Note :

Code :

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

if(carac_temp != '<' || carac_temp != '>')

ne fonctionne pas ? Ais-je oublié mes bases ? :p

Jusque là tout fonctionne, mais le résultat est à revoir :

000*☻000☻?000? 000
☻000☻?000? 000 0000↑
?000? 000 ð000©☺000☺

Avec un fichier composé de :

4
4
<000><000><000><000>
<000><000><000><000>
<000><000><000><000>
<000><000><000><000>

Je pense à une erreur d'allocation, mais où se trouverait elle ?

Le code actuel :

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
#include <stdio.h>
#include <stdlib.h>
 
#define TAILLE_MAX 1000
 
int main(int argc, char *argv[])
{
    /* Déclaration des variables */
    FILE* fichier = NULL; //On déclare le fichier
    char chaine_temp[TAILLE_MAX] = "" ;
    char carac_temp = '0' ;
    //Initialisateur de boucles
    int i = 0;
    int j = 0;
    int l = 0;
    //Taille du niveau
    int NbColonnes = 0;
    int NbLignes = 0;
    //Matrice du niveau
    char*** Matrice = {NULL} ;
 
 
    fichier = fopen("fichier.txt", "r+"); //On ouvre le fichier
    //Test de l'ouverture du fichier
    if(!fichier != NULL)
    {
        printf("erreur lors de l'ouverture du fichier !\n");
        system("PAUSE");
        return 1 ;
    }
 
    //On lit les deux premières lignes, puis on les écrits dans des variables
    for(i=0; i<2; i++)
    {
        fgets(chaine_temp, TAILLE_MAX, fichier);
        if(i == 0)
        {
            sscanf(chaine_temp, "%d", &NbColonnes); 
        }
        if(i == 1)
        {
            sscanf(chaine_temp, "%d", &NbLignes); 
        }
    }
 
    //On alloue dynamiquement le niveau
    Matrice = malloc(NbColonnes * sizeof(char));
    for(i=0; i<NbColonnes; i++)
    {
        Matrice[i] = malloc(NbLignes * sizeof(char));
    }
    for(i=0; i<NbColonnes; i++)
    {
        for(j=0; j<NbLignes; j++)
        {
            Matrice[i][j] = malloc(3 * sizeof(char));
        }
    }
 
    //On entre ensuite chaque valeur du fichier texte dans la Matrice
    for(j=0; j<NbLignes; j++)
    {
        for(i=0; i<NbColonnes; i++)
        {
                    for(l=0; l<4; l++)
                    {
                        carac_temp = fgetc(fichier);
                        if(carac_temp != '<')
                        {
                            if(carac_temp != '>')
                            {   
                            //Alors on entre les 3 caractères dans le tableau
                            Matrice[j][i][l] = carac_temp ;
                            }
                        }
                    }
        }
    }
 
 
    //On affiche le fichier à titre préventif
 
    for(i=0; i<NbLignes; i++)
    {
        for(j=0; j<NbColonnes; j++)
        {
            for(l=0; l<4; l++)
            {
                printf("%c", Matrice[i][j][l]);
            }
        }
    }
 
 
 
    //On ferme le fichier
    fclose(fichier);
 
    system("PAUSE");
    return 0;
}

**orfix** · 28/05/2008, 22h24

Salut,

Code :

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

1
2
3
4
5
6
7
 
if(!fichier != NULL)
{
        printf("erreur lors de l'ouverture du fichier !\n");
        system("PAUSE");
        return 1 ;
}

...Correction

Code :

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

1
2
3
4
5
6
7
 
if(fichier == NULL)
{
        printf("erreur lors de l'ouverture du fichier !\n");
        system("PAUSE");
        return 1 ;
}

Sinon tes allocations sont toutes fausses

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
 
//On alloue dynamiquement le niveau
    Matrice = malloc(NbColonnes * sizeof(char));
    for(i=0; i<NbColonnes; i++)
    {
        Matrice[i] = malloc(NbLignes * sizeof(char));
    }
 
    for(i=0; i<NbColonnes; i++)
    {
        for(j=0; j<NbLignes; j++)
        {
            Matrice[i][j] = malloc(3 * sizeof(char));
        }
    }

Un tableau de trois dimensions je vois ça comme sa :

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
 
//On alloue dynamiquement le niveau
    Matrice = malloc(NbColonnes * sizeof(char**));
    for(i=0; i<NbColonnes; i++)
    {
        Matrice[i] = malloc(NbLignes * sizeof(char*));
    }
 
    for(i=0; i<NbColonnes; i++)
    {
        for(j=0; j<NbLignes; j++)
        {
            Matrice[i][j] = malloc(3 * sizeof(char));
        }
    }

D'après ton fichier faut peut être Changé NbLignes par NbColonnes et vice versa ...

Autre chose lors de la lecture faut prendre en compte le caractère de fin de ligne ( LF/CR ) un truc du genre :

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
 
    //On entre ensuite chaque valeur du fichier texte dans la Matrice
    for(i=0; i<NbLignes; i++)
    {
        for(j=0; j<NbColonnes; j++)
        {
                for(l=0; l<3; l++)
                {   
			carac_temp = fgetc(fichier);
            		if(carac_temp != ' ' ) //Si le caractère n'est pas un espace
			{
                    		//Alors on entre les 3 caractères dans le tableau
                    		Matrice[i][j][l] = carac_temp ;
			}
                }
		fgetc(fichier); /* Consomme le caractere de fin de ligne */
        }
    }

Euhh... à part ça ton affichage et pas terrible ...faut rajouter des espaces puis retour à la ligne ..enfin je te laisse faire

@++

**yetimothee** · 28/05/2008, 22h33

Ok, merci

Je suis peu habitué à l'allocation dynamique sur une tableau "a 3 dimensions", j'étais perdu

Merci pour ta correction

**Médinoc** · 29/05/2008, 11h19

Moi, je vois l'allocation comme ça:

Code C :

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
typedef char ElemType;
 
ElemType *** AllocTable3D(size_t sizeX, size_t sizeY, size_t sizeZ)
{
	size_t const sizeYZ = sizeY * sizeZ;
	size_t const sizeXYZ = sizeX * sizeYZ;
	ElemType *** pppMatX = NULL;
	ElemType **  ppMatXY = NULL;
	ElemType *   pMatXYZ = NULL;
 
	/* On vérifie qu'il n'y a pas d'overflow */
	if(sizeYZ / sizeZ != sizeY)
		return NULL;
	if(sizeXYZ / sizeYZ != sizeX)
		return NULL;
 
	/* Une allocation par dimension */
	pppMatX = calloc(sizeof *pppMatX, sizeX); /* Tableau de pointeurs de pointeurs */
	ppMatXY = calloc(sizeof *ppMatXY, sizeXY); /* Tableau 2D de pointeurs */
	pMatXYZ = calloc(sizeof *pMatXYZ, sizeXYZ); /* Tableau 3D de ElemType */
 
	if(pppMatX != NULL && ppMatXY != NULL && pMatXYZ != NULL)
	{
		/* On affecte les pointeurs */
		size_t x;
		for(x=0 ; x<sizeX ; x++)
		{
			size_t y;
			pppMatX[x] = &ppMatXY[x*sizeY];
			for(y=0 ; y<sizeY ; y++)
			{
				ppMatXY[x*sizeY + y] = &pMatXYZ[(x*sizeY+y)*sizeZ];
			}
		}
	}
	else
	{
		/* Au moins une alloc a échoué: On libère celles qui ont réussi */
		free(pppMatX), pppMatX=NULL;
		free(ppMatXY), ppMatXY=NULL;
		free(pMatXYZ), pMatXYZ=NULL;
	}
	return pppMatX;
}
 
void FreeTable3D(ElemType ***pppMatDel)
{
	if(pppMatDel != NULL)
	{
		if(pppMatDel[0] != NULL)
		{
			free(pppMatDel[0][0]), pppMatDel[0][0]=NULL;
			free(pppMatDel[0]), pppMatDel[0]=NULL;
		}
		free(pppMatDel);
	}
}

**nicolas.sitbon** · 29/05/2008, 14h27

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
#include <stdio.h>
#include <stdlib.h>
 
#define TAILLE_MAX 1000
#define FICHIER "fichier.txt"
#define COL 0
#define ROW 1
#define NB_DIM 2
 
int main (void)
{
   int ret = 0;
   size_t init = 1;
   FILE* fichier = fopen (FICHIER, "r+");
 
   if(fichier != NULL)
   {
      size_t i = 0;
      size_t dimension[NB_DIM] = {0};
 
      for (i = 0; i < NB_DIM; i++)
      {
         char chaine_temp[TAILLE_MAX];              
 
         if (fgets(chaine_temp, TAILLE_MAX, fichier) != NULL)
         {
            int ret_sscanf = sscanf(chaine_temp, "%u", dimension + i);
 
            if (ret_sscanf == 0  ||  dimension[i] == 0)
            {
               init = 0;
               break;
            }
         }
         else
         {
            init = 0;
            break;
         }
      }
 
      if (init != 0)
      {
         char *Matrice = malloc (dimension[ROW] * dimension[COL] * 3);
 
         if (Matrice != NULL)
         {   
            /* --je n'ai pas vérifier cette partie-- */
            for (i = 0; i < dimension[COL]; i++)
            {
               size_t j;
               for (j = 0; j < dimension[ROW]; j++)
               {
                  size_t k;
                  for (k = 0; k < 4; k++)
                  {
                     int carac_temp = fgetc (fichier);
                     if (carac_temp != '<'  &&  carac_temp != '>')
                     {   
                        //Akors on entre kes 3 caractères dans ke tabkeau
                        Matrice[i * dimension[COL] + j * dimension[ROW] + k] = (char)carac_temp ;
                     }
                  }
               }
            }
 
            //On affiche le fichier à titre préventif
            for (i = 0; i < dimension[COL]; i++)
            {
               size_t j;
               for (j = 0; j < dimension[ROW]; j++)
               {
                  size_t k;
                  for (k = 0; k < 4; k++)
                  {
                     printf ("%c", Matrice[i * dimension[COL] + j * dimension[ROW] + k]);
                  }
               }
            } 
            /* -- -- */
 
            free (Matrice), Matrice = NULL;
         }
         else
         {
            perror ("malloc");
            ret = EXIT_FAILURE;
         }
      }
      fclose (fichier), fichier = NULL;
   }
   else
   {
      perror ("erreur lors de l'ouverture du fichier");
      ret = EXIT_FAILURE;
   }
 
   getchar ();
   return ret;
}

Problème lors du remplissage d'un tableau alloué dynamiquement

C

Vue hybride

Discussions similaires

Partager

Partager