Discussion :

[INSPIRATION]

Salut,j'essaie de copier un tableau d'entier dans fichier,mais Je n'arrive pas a le faire.Voici ce que j'ai essayé mais ca ne fonctionne pas.Pouvez vous m'aidez a trouver la faille dans ce bout de 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
 
void CopiTabFichier(FILE **Fp,int Tab[1000][1000],int Nb){
 
	int i,j;
	*Fp=fopen("\\Lyon\\Tab\\Fich.dat","w");
	if(!*Fp)
		printf("\nChemain de fichier faux");
	else
	{
	for(i=0;i<Nb;i++){
		fprintf(*Fp,"\nSeq%d",i);
 
		for(j=0;j<Nb;j++)
			fprintf(*Fp,"\t%d",Tab[i][j]);
 
		fprintf(*Fp,"\n");
	}
 
	}
}

Merci d'avance.

[plxpy]

Bonjour,

À première vue, et sans tester (pas de compilo car tablette), tu oublies tout simplement de fermer ton fichier.

Autre chose : passer Fp dans les arguments comme tu le fais n'a aucun sens. Fais en (Fp, type FILE *) une variable locale et, si tu veux pouvoir choisir le fichier cible, passe un chemin en paramètre à la place.

[Bktero]

Voici ce que j'ai essayé mais ca ne fonctionne pas

Ce n'est pas un constat acceptable pour nous : on ne peut pas t'aider si tu ne nous en dit pas plus

Il faut dire ce qui ne marche pas : erreur de compilation, crash à l'exécution, message d'erreur issu d'un de tes printf(), fichier ne contenant rien ou pas les données attendues,... ?

Remarques :
1) le chemin de fichier est-il relatif ou as-tu oublié la lettre du lecteur ?
2) si Nb est supérieur à 1000......

[darkwall_37]

Salut,j'essaie de copier un tableau d'entier dans fichier,mais Je n'arrive pas a le faire.Voici ce que j'ai essayé mais ca ne fonctionne pas.Pouvez vous m'aidez a trouver la faille dans ce bout de 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
 
void CopiTabFichier(FILE **Fp,int Tab[1000][1000],int Nb)
{
 
	int i,j;
	*Fp=fopen("\\Lyon\\Tab\\Fich.dat","w");
	if(!*Fp)
		printf("\nChemain de fichier faux");
	else
	{
	for(i=0;i<Nb;i++){
		fprintf(*Fp,"\nSeq%d",i);
 
		for(j=0;j<Nb;j++)
			fprintf(*Fp,"\t%d",Tab[i][j]);
 
		fprintf(*Fp,"\n");
	}
 
	}
}

Merci d'avance.

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
 
FILE *copiTabFichier(int tab[1000][1000], size_t Nb)
{	
 
	FILE *file=fopen("\\Lyon\\Tab\\Fich.dat","w");
 
        if(!*file)
        {
		printf("\nChemain de fichier faux");
        }
 
        else
	{
                size_t i,j;
	        for(i=0 ; i<Nb ; i++)
                {
		      fprintf(file, "\nSeq%d", i);
                }
 
		for (j=0 ; j<Nb ; j++)
                {
		      fprintf(file,"\t%d",Tab[i][j]);
                }
 
		fprintf(file,"\n");
	}
 
        fclose(file);
        return file;
}

Cela devrait marcher. Je ne pense pas qu'il soit nécessaire de passer en double pointeur de FILE le fichier. Tu peux le créer directement dans la fonction et le renvoyer. Cela limite le champs des erreurs possibles.

Cordialement.

[plxpy]

Je ne pense pas qu'il soit nécessaire de passer en double pointeur de FILE le fichier. Tu peux le créer directement dans la fonction ...

évoqué il y a 9 jours

De plus, dans ton code, retourner la variable file est aberrant, voire pire que la version originale (variable de type FILE *, fichier ouvert ET refermé ... avant return)

[koala01]

Salut,

Il faudrait déjà savoir si le tableau que INSPIRATION est la seule chose qu'il veut écrire dans le tableau ou si cela fait partie d'un ensemble plus complexe et donc si l'écriture du tableau n'est "qu'une étape parmi d'autres"...

Dans le premier cas, le fichier peut très bien rester variable locale à la fonction et le retrour peut indiquer une réussite ou un échec.

Le code pourrait alors ressembler à quelque chose comme

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
 /* j'ai horreur des arbitraire */
int copiTabFichier(int **tab , size_t col, size_t row, char *filename)
{	
        /* attention, filename doit comporter le '\0' ;) */
	FILE *file=fopen(filename);
 
        if(!*file)
        {
		printf("\nChemain de fichier faux");
                return 0;
        }
 
        else
	{
                size_t i,j;
	        for(i=0 ; i<rox ; i++)
                {
                      /* toute écriture est susceptible de foirer */
		      if(fprintf(file, "\nSeq%d", i) == 0)
                      {
                          return 0;
                      }
 
		      for (j=0 ; j<col ; j++)
                      {
		          if(fprintf(file,"\t%d",Tab[i][j]) == 0)
                          {
                              return 0;
                          }
                }
 
		if(fprintf(file,"\n") == 0)
                {
                    return 0;
                }
	}
 
        fclose(file);
        return 1;
}

Dans le second cas, la règle de la responsabilité unique m'inciterait franchement à faire en sorte que, même si le tableau est la première chose à écrire dans le fichier, la fonction n'ait pas à s'occuper de l'ouverture (ni de la fermeture d'ailleurs) du fichier.

Les arguments transmis à la fonction seraient

• le fichier
• un pointeur sur le début du tableau (pointeur de pointeur si tableau à deux dimensions)
• le nombre de colonnes à écrire
• (le nombre de ligne à écrire si tableau à deux dimensions)

La valeur de retour étant, de nouveau, un entier représentant la réussite (!=0 ) ou l'échec ( == 0 ) de l'écriture

La fonction serait appelée par une fonction qui

1. ouvre le fichier grace à un nom qui lui est transmis (renvoie 0 si le fichier n'est pas ouvert)
2. appelle chaque fonction écrivant une partie du fichier en lui passant le fichier + les données à écrire (renvoie 0 si la fonction échoue)
3. ferme le fichier
4. renvoie 1 pour indiquer que tout s'est bien passé

et qui serait elle-même appelée par une fonction qui... connait (d'une manière ou d'une autre) le nom du fichier ainsi que les données à écrire

[Bktero]

Le soucis de ton code est que tu passes un int** et non un int[][] ou encore un int(*)[]. 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
int copiTabFichier(int **tab , size_t col, size_t row, char *filename)
{
    int i, j;
    for(i=0 ; i<row ; i++)
    {
        for (j=0 ; j<col ; j++)
        {
            printf("%d\t",tab[i][j]);
        }
        printf("\n");
    }
    return 0;
}
 
int main(void)
{
    int tab[4][5] = { {15, 1, 12, 8, 56}, {1, 1, 2, 8, 6}, {515, 31, 142, 28, 526}, {135, 21, 132, 833, 563} };
    copiTabFichier(tab, 5, 4, NULL );
    return 0;
}

Génère le warning suivant :

d:\...\Untitled1.c|20|warning: passing argument 1 of 'copiTabFichier' from incompatible pointer type|

Je lance et il plante.

Un argument de type int** implique que le tableau tab du main est déclaré comme un tableau de pointeurs, et non comme un tableau de tableaux avec [][].

Un programme 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
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
#include <stdlib.h>
#include <stdio.h>
 
int copie_originale(int **tab , size_t col, size_t row)
{
    size_t i, j;
 
    for(i=0 ; i<row ; i++)
    {
        for (j=0 ; j<col ; j++)
        {
            printf("%d\t", tab[i][j]);
        }
        printf("\n");
    }
    return 0;
}
 
int copie_alternative(int (*tab)[] , size_t col, size_t row)
{
    size_t i, j;
    for(i=0 ; i<row ; i++)
    {
        for (j=0 ; j<col ; j++)
        {
            printf("%d\t", (*tab+i*col)[j]);
        }
        printf("\n");
    }
    return 0;
}
 
int main(void)
{
    int tabtab[4][5] = { {15, 1, 12, 8, 56}, {1, 1, 2, 8, 6}, {515, 31, 142, 28, 526}, {135, 21, 132, 833, 563} };
 
    int * tabpt[5];
    tabpt[0] = (int*) tabtab[0]; // j'explicite le cast implicite
    tabpt[1] = tabtab[1];
    tabpt[2] = tabtab[2];
    tabpt[3] = tabtab[3];
    tabpt[4] = tabtab[4];
 
    /********************************/
    puts("copie_originale OK : ");
    copie_originale(tabpt, 5, 4);
 
    puts("\ncopie_alternative OK : ");
    copie_alternative(tabtab, 5, 4);
 
    /********************************/
    puts("copie_originale KO ! : ");
    //copie_originale(tabtab, 5, 4); // warning pour des types incompatibles
                                    // plante le programme
 
    puts("\ncopie_alternative KO ! : ");
    copie_alternative(tabpt, 5, 4); // warning idem , affiche n'importe quoi
 
    return 0;
}

On ne peut pas préjuger de la manière dont INSPIRATION a déclaré le tableau qui sera passé en paramètre, mais l'écriture tab[1000][1000] laisse penser que c'est un tableau de tableaux et non un tableaux de pointeurs.

[koala01]

j'avouerai à ma grande honte que je n'avais pas testé mon code (et que je travaille pour l'instant beaucoup plus avec C++ et donc à coup de std::vector, par exemple )

Mais, même si le problème que tu mets en évidence reste tout à fait juste, le fond de mon intervention reste valable:

Soit la fonction ouvre et ferme le fichier en local, pour n'écrire que le tableau dedans

Soit la fonction utilise un fichier ouvert passé sous la forme d'un paramètre.

Mais, dans tous les cas, le retour de fonction doit plus renvoyer une valeur de réussite que n'importe quoi d'autre