Discussion :

[jul0101]

Bonsoir,

J'ai actuellement un projet qui nécessite la création d'un fichier .CSV à partir de mon code.
A partir d'un premier fichier .CSV je récupère des données auxquelles j'applique des opérations. Une fois ces opérations effectuées je souhaite inscrire le résultat dans un fichier .CSV générer par mon code. Je m'explique, initialement dans le dossier d'enregistrement se trouve uniquement mon fichier de données et après l'exécution de mon programme un second fichier .CSV se trouve dans le dossier avec le résultat des opérations à l'intérieur.

Mon problème se trouve dans la partie création du fichier .CSV, j'ai vu dans divers cours que le mode d'ouverture ("a" ou "w") pouvait servir à créer un fichier en partant de rien mais dans le dossier final je n'ai que le fichier de données après exécution du programme.

Pour info je code avec Code::Blocks 16.01 sous windows 10.

J'ai donc réalisé le code suivant (je suis conscient que je n'écris qu'une seule donnée dans la case 1.1 du fichier .CSV mais c'est un exemple pour illustrer mes propos):

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
 
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <ctype.h>
#include <math.h>
 
typedef struct
{
    char *delim;
    unsigned int lignes;
    unsigned int colonnes;
    char **table;
}CSV;
 
int suppr_csv(CSV * csv) {
	if (csv == NULL) { return 0; }
	if (csv->table != NULL) { free(csv->table); }
	if (csv->delim != NULL) { free(csv->delim); }
	free(csv);
	return 0;
}
 
CSV* csv_esp_mem(unsigned int colonnes, unsigned int lignes)
{
    CSV*csv;
    csv=malloc(sizeof(CSV));
    csv->lignes=lignes;
    csv->colonnes=colonnes;
    csv->delim=strdup(";");
    csv->table=malloc(sizeof(char*)*colonnes*lignes);
    if(csv->table==NULL){goto erreur;}
    memset(csv->table,0,sizeof(char *)*colonnes*lignes);
    return csv;
 
    erreur:
        suppr_csv(csv);
        return NULL;
}
 
int csv_ecriture_seule(CSV* csv,char *Nom_Fichier)
{
   FILE*fichier;
    fichier=fopen(Nom_Fichier,"r");
    if (fichier==NULL){goto erreur;}
 
    return 0;
    erreur:
        fclose(fichier);
        printf("Impossible a ouvrir");
        return -1;
}
 
void ecrire_in_fichier_CSV(FILE* fichier,int donnees)
{
    fprintf(fichier,"%d",donnees);
    fclose(fichier);
}
 
int main()
{
    CSV *nouveaucsv;
    nouveaucsv=csv_esp_mem(20,100);
    char fichier_name="rapport_1.csv";
    csv_ecriture_seule(nouveaucsv,fichier_name);
 
    int donnees;
    printf("entrez donnees:\n");
    scanf("%d",&donnees);
    ecrire_in_fichier_CSV(fichier,donnees);
    return 0;
}

Est-ce que mon programme possède une erreur qui m'aurait échappée ?
Merci d'avance pour l'intérêt que vous porterez à mon post.
Jul0101

[Médinoc]

En dehors des autres problèmes (comme le fait d'appeler ta structure in-memory CSV alors que Comma-Separated Values est purement un format de sauvegarde, ou une gestion parfois douteuse des allocations), tu as deux problèmes dans csv_ecriture_seule:

1. Tu ouvres le fichier en lecture
2. http://emmanuel-delahaye.developpez....e=page_3#LXIII

[jul0101]

Oups désolé en effet je n'avais pas fait attention que j'avais mis "r" et non "w" dans la fonction ...
Pour toi, le second problème vient du fait que j'ai mal déclaré le type de csv_ecriture_seule ?
J'avoue ne pas comprendre pourquoi ?
Ma fonction retourne un valeur entière, soit 0 en cas de fonctionnement ou -1 en cas d'erreur et dans cette fonction je créé un fichier .CSV.
Le problème ne viendrait-il pas du fait que le fichier est créé en interne dans la fonction et disparaît lorsque celle-ci n'est plus appelée ?

[Bktero]

Ca, ça me donne envie de mettre des *ifles

Code :

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

1
2
3
4
5
6
7
8
9
10
11
12
int csv_ecriture_seule(CSV* csv,char *Nom_Fichier)
{
   FILE*fichier;
    fichier=fopen(Nom_Fichier,"r");
    if (fichier==NULL){goto erreur;}
 
    return 0;
    erreur:
        fclose(fichier);
        printf("Impossible a ouvrir");
        return -1;
}

Pourquoi goto ? POURQUOI ???

Plus sérieusement : moins tu utiliseras de goto, mieux tu te porteras. goto peut être utile dans quelques cas mais clairement, ici, non !

Ne trouves-tu pas le code suivant plus simple ?

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
int csv_ecriture_seule(CSV* csv,char *Nom_Fichier)
{
    FILE* fichier = fopen(Nom_Fichier,"r");
    if (fichier == NULL)
    {
        // Erreur
        fclose(fichier);
        printf("Impossible a ouvrir");
        return -1;
    }
    else
    {
        // Succes
        return 0;
    }
}

Je ne suis d'ailleurs pas certain que le fclose() soit nécessaire, puisque tu n'as pas réussi à ouvrir ton fichier.

[Médinoc]

Je ne suis d'ailleurs pas certain que le fclose() soit nécessaire, puisque tu n'as pas réussi à ouvrir ton fichier.

Il est même dangereux: Contrairement à free(NULL) qui est défini comme no-op, fclose(NULL) est un comportement indéfini (absurda lex sed lex).

Ce qu'il faut, c'est un truc de ce genre:

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
int csv_ecrire_fichierOuvert(CSV const * csv, FILE* fichier)
{
	/*Mettre le code d'écriture ici*/
	return 0;
}
 
int csv_ecriture_fichier(CSV const * csv, char const *nomFichier)
{
	FILE* fichier = fopen(nomFichier,"w");
	if (fichier == NULL)
	{
		// Erreur
		printf("Impossible a ouvrir: Erreur %d\n", errno);
		return -1;
	}
	else
	{
		// Succes
		int ret = csv_ecrire_fichierOuvert(csv, fichier);
		fclose(fichier);
		return ret;
	}
}

[Pyramidev]

Bonjour,

Concernant goto, en langage C, il peut être bien pour gérer la libération des ressources en cas d'erreur :

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
ErrCode GetEmployeeDescription(const Employee* employee, MyString* out, ErrInfos* errInfos)
{
	ErrCode errCode = 0;
 
	// Rq: My code has double parenthesis. Otherwise, GCC prints a warning:
	// "warning: suggest parentheses around assignment used as truth value [-Wparentheses]"
 
	if((errCode = Employee_GetName(employee, out, errInfos)))
		goto end;
 
	if((errCode = MyString_Append_CString(out, " [company : ", errInfos)))
		goto cleanup_out_if_error;
 
	MyString companyName;
	if((errCode = Employee_GetCompanyName(employee, &companyName, errInfos)))
		goto cleanup_out_if_error;
 
	if((errCode = MyString_Append_MyString(out, &companyName, errInfos)))
		goto cleanup_companyName;
 
	errCode = MyString_Append_CString(out, "]", errInfos);
 
cleanup_companyName:
	MyString_Destructor(&companyName);
 
cleanup_out_if_error:
	if(errCode)
		MyString_Destructor(out);
 
end:
	if(errCode)
		ErrInfos_AddInfoCString(errInfos, "Error when getting an employee description.");
 
	return errCode;
}

Dans mon exemple, le même code sans goto, sous une forme classique, sera une pyramide qui obligera à lire le code de travers :

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
ErrCode GetEmployeeDescription_2(const Employee* employee, MyString* out, ErrInfos* errInfos)
{
	ErrCode errCode = 0;
 
	errCode = Employee_GetName(employee, out, errInfos);
	if(errCode == 0) {
 
		errCode = MyString_Append_CString(out, " [company : ", errInfos);
		if(errCode == 0) {
 
			MyString companyName;
			errCode = Employee_GetCompanyName(employee, &companyName, errInfos);
			if(errCode == 0) {
 
				errCode = MyString_Append_MyString(out, &companyName, errInfos);
				if(errCode == 0) {
 
					errCode = MyString_Append_CString(out, "]", errInfos);
				}
				MyString_Destructor(&companyName);
			}
		}
		if(errCode != 0)
			MyString_Destructor(out);
	}
	if(errCode)
		ErrInfos_AddInfoCString(errInfos, "Error when getting an employee description.");
	return errCode;
}

Par contre, dans le cas d'une toute petite fonction avec une seule opération qui peut échouer suivie d'une seule deuxième opération si la première a réussie, if-else sera plus lisible que goto.

[Bktero]

C'est pour moi l'exemple typique où goto est un vraiment plus !

[Sve@r]

Bonjour

Ne trouves-tu pas le code suivant plus simple ?

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
int csv_ecriture_seule(CSV* csv,char *Nom_Fichier)
{
    FILE* fichier = fopen(Nom_Fichier,"r");
    if (fichier == NULL)
    {
        // Erreur
        printf("Impossible a ouvrir");
        return -1;
    }
    else
    {
        // Succes
        return 0;
    }
}

Moi je serais même allé plus loin dans l'audace en ne mettant même pas de "else"... (wahou , mais qui est donc ce Sve@r dont les réformes osées révolutionnent tous nos standards de développement ??? )

Je ne suis d'ailleurs pas certain que le fclose() soit nécessaire, puisque tu n'as pas réussi à ouvrir ton fichier.

Cela allait sans dire

Par contre, dans le cas d'une toute petite fonction avec une seule opération qui peut échouer suivie d'une seule deuxième opération si la première a réussie, if-else sera plus lisible que goto.

Ca se discute. Eventuellement, dans le cadre d'une évolution toujours possible (aujourd'hui une opération mais demain peut-être deux, trois, ..., trente) alors le goto peut peut-être éventuellement avec prudence et circonspection s'envisager...