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

Version imprimable

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:

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:

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:

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 :)

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) ;" :roll:

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

000 x00 0
0 00?

Sachant que mon fichier texte est celui ci :

Citation:

2
2
000 000
000 000

EDIT 2 : (ou chapitre 2)

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

Code:

if(carac_temp != ' ')

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

Code:

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

Note :

Code:

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

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

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

Citation:

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

Avec un fichier composé de :

Citation:

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:

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

Salut,

Code:

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:

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:

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:

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:

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 ;)
@++

28/05/2008, 22h33
yetimothee

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

Merci pour ta correction :)

Moi, je vois l'allocation comme ça:

Code:

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

Code:

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

29/05/2008, 14h36
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:

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

Edit: Le code modifié devrait marcher.
29/05/2008, 15h02
nicolas.sitbon

Citation:

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:

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

Arf,
heureusement que tu es là Médinoc, j'ai modifié mon code (simple erreur d'inattention).
Merci beaucoup.
29/05/2008, 17h23
yetimothee

je ne comprends pas cette ligne :

Code:

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

Ca consiste en quoi ?
29/05/2008, 19h36
nicolas.sitbon

littéralement ça se lit :

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

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 :oops:

Code:

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:

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
@++

29/05/2008, 23h36
Médinoc

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.
29/05/2008, 23h48
orfix

Citation:

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 !
30/05/2008, 18h18
yetimothee

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 :D

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

Code:

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:

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 :)

01/06/2008, 19h55
diogene

Probablement, une erreur ici :

Code:

if(char_temp == ' ')

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:

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 :oops:
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:

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à :)