copie d'un tableau dans un fichier

Version imprimable

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:

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.

20/08/2012, 16h26
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.
20/08/2012, 16h51
Bktero

Citation:

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......

Citation:

Envoyé par 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:

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:

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.

29/08/2012, 14h44
plxpy

Citation:

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)

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:

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

ouvre le fichier grace à un nom qui lui est transmis (renvoie 0 si le fichier n'est pas ouvert)
appelle chaque fonction écrivant une partie du fichier en lui passant le fichier + les données à écrire (renvoie 0 si la fonction échoue)
ferme le fichier
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

Le soucis de ton code est que tu passes un int** et non un int[][] ou encore un int(*)[]. Exemple :

Code:

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 :

Citation:

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:

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.

30/08/2012, 11h41
koala01

j'avouerai à ma grande honte que je n'avais pas testé mon code :aie: (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 ;)
30/08/2012, 11h53
Bktero

Je suis tout à fait d'accord sur le fond, je parlais juste de la forme ;)

A quand les magnifiques std::vector en C ? :lol:
30/08/2012, 13h49
koala01

Citation:

Envoyé par Bktero

Je suis tout à fait d'accord sur le fond, je parlais juste de la forme ;)

A quand les magnifiques std::vector en C ? :lol:

Le problème, c'est que ce sont des classes, template qui plus est, et que C ne peut au mieux qu'émuler ce genre de concept...

mais il est vrai qu'une encapsulation du principe de tableau s'avérerait vouvent utile.

Après tout, on a bien encapsulé FILE :D