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;
}

**Médinoc** · 29/05/2008, 14h36

@Nicolas: Je ne pense pas que ça puisse marcher avec ton code. Tu crées un pointeur de pointeur de pointeur, mais tu n'alloues qu'un seul niveau d'indirection, bien que tu l'utilises comme s'il y en avait trois...

La syntaxe "[x][y]" fait toujours deux niveaux d'indirection quand il est question de pointeurs. Elle ne fait qu'un seul niveau d'indirection quand il s'agit d'un tableau dont la seconde dimension est fixe.

Ainsi, pour avoir [x][y][z], en une fois, il faudrait que Matrice soit déclaré ainsi:

Code :

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

char (*matrice)[dimension[COL]][3];

Edit: Le code modifié devrait marcher.

**nicolas.sitbon** · 29/05/2008, 15h02

Envoyé par Médinoc

@Nicolas: Je ne pense pas que ça puisse marcher avec ton code. Tu crées un pointeur de pointeur de pointeur, mais tu n'alloues qu'un seul niveau d'indirection, bien que tu l'utilises comme s'il y en avait trois...

La syntaxe "[x][y]" fait toujours deux niveaux d'indirection quand il est question de pointeurs. Elle ne fait qu'un seul niveau d'indirection quand il s'agit d'un tableau dont la seconde dimension est fixe.

Ainsi, pour avoir [x][y][z], en une fois, il faudrait que Matrice soit déclaré ainsi:

Code :

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

char (*matrice)[dimension[COL]][3];

Arf,
heureusement que tu es là Médinoc, j'ai modifié mon code (simple erreur d'inattention).
Merci beaucoup.

**yetimothee** · 29/05/2008, 17h23

je ne comprends pas cette ligne :

Code :

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

char (*matrice)[dimension[COL]][3];

Ca consiste en quoi ?

**nicolas.sitbon** · 29/05/2008, 19h36

littéralement ça se lit :

Matrice est un pointeur sur un tableau de dimension[COL] tableaux de 3 caractères

**orfix** · 29/05/2008, 22h35

Salut,
@Médinoc : J'ai essayé de comprendre votre exemple et je pense qu'il y a des variables dont le nom doit être changé...enfin désolé si je me trompe

Code Médinoc :

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
 
ElemType *** AllocTable3D(size_t sizeX, size_t sizeY, size_t sizeZ)
{
    size_t const sizeXY = sizeX * sizeY;
    size_t const sizeXYZ = sizeXY * sizeZ;
    ElemType *** pppMatX = NULL;
    ElemType **  ppMatXY = NULL;
    ElemType *   pMatXYZ = NULL;
 
    /* On vérifie qu'il n'y a pas d'overflow */
    if(sizeXY / sizeX != sizeY)
        return NULL;
    if(sizeXYZ / sizeXY != sizeZ)
        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;
}

Sinon je n'ai pas non plus compris ceci :

Code :

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

1
2
3
4
5
6
/* On vérifie qu'il n'y a pas d'overflow */
    if(sizeYZ / sizeZ != sizeY)
        return NULL;
    if(sizeXYZ / sizeYZ != sizeX)
        return NULL;

si je passe à la fonction un 'sizeZ' nul je me retrouve avec une division par zéro...non ??

Merci
@++

**Médinoc** · 29/05/2008, 23h36

Hum... En effet, je me suis trompé. On dirait que j'ai changé d'avis en cours de route... Tu as raison, c'est bien sizeXY.

Le coup de la vérification est en fait assez simple: J'ai multiplié deux size_t, donc il est possible que le résultat ne tienne pas vraiment dans un size_t. Je fais donc le calcul inverse (division) pour être sûr que je retrouve bien mes petits...

Mais tu as raison sur un point, j'aurais dû commencer par un test pour refuser toute taille nulle.

**orfix** · 29/05/2008, 23h48

Envoyé par Médinoc

Le coup de la vérification est en fait assez simple: J'ai multiplié deux size_t, donc il est possible que le résultat ne tienne pas vraiment dans un size_t. Je fais donc le calcul inverse (division) pour être sûr que je retrouve bien mes petits...

Je vois ...merci pour l'éclaircissement !

**yetimothee** · 30/05/2008, 18h18

Au fait, je suis vraiment stupide.
Au lieu d'utiliser un type char, qui m'oblige à avoir une matrice tri-dimensionnelle, si j'utilise un tableau de short ou int, j'aurais seulement besoin d'une matrice bi-dimensionelle, ce qui va faciliter le travail. Bon, il va falloir faire du sprintf par contre, je pense :p

Eh bien merci à vous tout de même, j'ai quand même appris un peu plus

**yetimothee** · 01/06/2008, 19h39

Bon, voilà ce que ça donne avec une matrice int :

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
int main(void)
{
    //Initialisation des fichiers textes
    FILE* fichier = fopen("data/level/l01/l01.txt", "r");
 
 
    //declaration des variables
    int i = 0, j = 0 ;
    int k = 0 ;
    char string_temp[255] = "" ;
    char char_temp = ' ' ;
    int nbLignes = 0, nbColonnes = 0;
    char** Matrice ;
 
    //On lit le nombre de lignes du fichier
    //Puis on assigne nbLignes et nbColonnes
    //nbLignes
    fgets(string_temp, 4, fichier);
    sscanf(string_temp, "%d", &nbLignes);
    //nbColonnes
    fgets(string_temp, 4, fichier);
    sscanf(string_temp, "%d", &nbColonnes);
 
 
 
    //On va allocationner les Matrice grâce aux résultats
    Matrice = malloc(nbColonnes * sizeof(int*));
    for(i=0; i< nbColonnes; i++)
    {
        Matrice[i] = malloc(nbLignes * sizeof(int));
    }
 
 
    //Initialisation des matrices
    for(i=0; i< nbColonnes; i++)
    {
        for(j=0; j< nbLignes; j++)
        {
            Matrice[i][j] = 0 ;
        }
    }
 
 
    //On remplit Matrice
    for(j=0; j< nbLignes; j++)
    {
        for(i=0; i< nbColonnes; i++)
        {
            k = 0 ;
            while(1)
            {
                char_temp = fgetc(fichier);
                if(char_temp = ' ')
                {
                    break;
                }
                string_temp[k] = char_temp;
                k++ ;
            }
            sscanf(string_temp, "%d", &Matrice[i][j]);
 
        }
    }
 
    //On affiche Matrice
    for(j=0; j< nbLignes; j++)
    {
        for(i=0; i< nbColonnes; i++)
        {
            printf("%d\n", Matrice[i][j]); 
        }
    }
 
    //On ferme les fichiers
    fclose(fichier);
 
    system("pause");
    return 0;
}

Mais le code a un problème ici :

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
//On remplit Matrice
    for(j=0; j< nbLignes; j++)
    {
        for(i=0; i< nbColonnes; i++)
        {
            k = 0 ;
            while(1)
            {
                char_temp = fgetc(fichier);
                if(char_temp = ' ')
                {
                    break;
                }
                string_temp[k] = char_temp;
                k++ ;
            }
            sscanf(string_temp, "%d", &Matrice[i][j]);
 
        }
    }

Il me rapporte une violation de mémoire, ou un truc comme ça, et il n'écrit pas dans le matrice

Merci pour votre aide

**diogene** · 01/06/2008, 19h55

Probablement, une erreur ici :

Code :

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

if(char_temp == ' ')

**yetimothee** · 01/06/2008, 20h01

Ah oui, y a de ça, mais d'après windows, la mémoire ne peut pas être "written" à l'emplacement x... Toujours le même problème quoi

EDIT :
J'y suis presque !

il semblerais que j'ai perdu momentanément ma logique :p
Voici mon 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
//On remplit Matrice
    for(j=0; j< nbLignes; j++)
    {
        for(i=0; i< nbColonnes; i++)
        {
            k = 0 ;
            do
            {
                char_temp = fgetc(fichier);
                string_temp[k] = char_temp;
                k++ ;
            }while(char_temp != ' ' || char_temp != '\n');
            sscanf(string_temp, "%d", &Matrice[i][j]);
 
        }
    }

Le résultat de l'affichage est bon, mais le Matrice[0][0] est bizarrement égale à 15 ?

Enfin, ca doit pas être bien compliqué

EDIT2 : Au fait, je me suis salement planté

J'ai mit == au lieu de != dans mon do...while

Donc en fin de compte j'ai toujours l'erreure d'écriture...

EDIT3 : Pfiou, j'ai enfin résolu mon problème ! Je parcourais la boucle d'assignement du mauvais sens :p
Viens après deux trois bricoles et on obtient ça :

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
for(i=0; i< nbColonnes; i++)
    {
        for(j=0; j< nbLignes; j++)
        {
            for(k=0; k< 255; k++)
            {
                string_temp[k] = ' ';
            }
            k = 0 ;
            while(1)
            {
                char_temp = fgetc(fichier);
                if(char_temp == ' ' || char_temp == '\n')
                {
                    break;
                }
 
                string_temp[k] = char_temp;
                k++ ;
            }
            sscanf(string_temp, "%d", &Matrice[i][j]);
        }
    }

Et voilà

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

C

Discussions similaires

Partager

Partager