Discussion :

[lilington]

bonjour tous le monde.

j'ai l'intention de me creer une petite biblioteque d'utilitaire donc un systeme de log.
je cherche a modifier mon anciens systeme de log qui permettait d'ecrire qu'un seul fichier a la fois. ce que je veux faire c'est quelque chose comme ceci:

fichier main:

Code :

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

1
2
3
4
5
6
7
8
9
 
  int sousSysteme1 = initLog("networklog");
  int sousSysteme2 = initLog("system");
 
  //code code code code code code.....
  closeLog(sousSysteme1);
  ...
  ...
  closeLog(sousSysteme2);

ma question c'est est la : voici le log.h

Code :

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

1
2
3
4
5
6
7
8
9
10
11
12
13
14
 
#ifndef _LOG_H_
#define _LOG_H_ 1
 
#include <stdio.h>
 
#define MAX_LOG 5
 
static FILE *tbLog[MAX_LOG] = {NULL};
 
extern int initLog(char filename[256]);
extern int closeLog(int logd);
 
#endif

donc chaque fois que j'appelle fopen le numero du fichier log est renvoyer pour fermeture .
jusque la pas vraiment de question.
l'implementation des fonction init et close me donne satisfaction dans le resultat mais je me demande sij'ai vraiment le droit de faire ce qui va suivre et que si ca marche c'est pas justement par chance:

log.c:

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
#include "log.h"
#include <string.h>
#include <stdlib.h>
 
extern int initLog(char filename[256])
{
	static int logd = -1;          //Log to open number value from 0 to MAX_LOG  
        FILE *rien=NULL;
 
	logd++;                       // new log number
 
	if ((rien = fopen(filename,"w")==NULL))   //record file Pointer *********
	{
               return -1; 
        }
        tbLog[logd] = rien;
	return logd;	              //return log number
}
 
extern int closeLog(int logd)
{
	if (tbLog[logd] == NULL)
	{
		printf("No log to close \n");
		return -1;
	}
	printf("Log %d value is %p",logd,tbLog[logd]);
	fclose(tbLog[logd]);
	printf("Closed\n");
	return 0;
}

donc je ne fait que creer et refermer des fichiers. la ligne avec les ****** et celle qui me semble suspecte. avant de me lancer dans la suite de cet outils j'aimerai savoir si le stockage et la lecture des FILE* sont "propres"
et que ca ne sera pas sujet a bug.

milles merci

ps: comme sur ce forum je sais qu'il y a des allergiques au mot 'extern', svp ignorez le. il est la parceque je l'aime bien.
ps2: commente en anglais car je suis en chine et ceux qui l'utiliseront avec moi parlent pas francais.

[Mac LAK]

A part le fait que tu devrais utiliser PATH_MAX (défini dans <limits.h>) pour la longueur maximale de tes fichiers au lieu de 256 "en dur", il n'y a rien de choquant.

Éventuellement, je retournerais -1 dans initLog si jamais l'ouverture a donné un fichier NULL, de façon à tester rapidement au niveau de l'appelant si une ouverture s'est correctement passé ou non : ce serait un peu plus clean que de retourner l'index brutalement même si l'ouverture a échoué.

[lilington]

c'est bon j'ai reedite et mis une petite gestion d'erreur.

[diogene]

1- Un .h ne devrait pas contenir de définitions de variables. Si tu as besoin que d'autres unités de compilation utlisent la globale tbLog, déclare la en extern (tu aimes bien ) dans le .h et place sa définition dans le .c

Code :

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

1
2
3
4
5
6
7
8
#ifndef _LOG_H_
#define _LOG_H_ 1
 
#define MAX_LOG 5
extern int initLog(char filename[256]);
extern int closeLog(int logd);
 
#endif

2- Je trouve qu'il y a une incohérence dans ta gestion de tbLog :
Quand tu appelles closeLog(), tu fermes un fichier (après avoir testé à différent de NULL), mais tu ne mets pas à NULL tbLog[logd].
Alors, si on appelle à nouveau cette fonction avec la même valeur de logd, on va planter.

Il me semble plus logique
- de créer tbLog et d'initialiser son contenu à NULL (ce que tu as fait)
- pour ouvrir un nouveau fichier, chercher une place à NULL dans tbLog et l'utiliser (Et la static logd est alors inutile).
- pour fermer un fichier, tester l'élément logd de tbLog à NULL. S'il est différent de NULL, fermer le fichier et placer l'élément à NULL.

commente en anglais car je suis en chine et ceux qui l'utiliseront avec moi parlent pas francais.

Nous sommes sur un forum francophone, et les questions/réponses doivent être faites en français.
Mais rien ne t'empêche de traduire en chinois.

[Mac LAK]

c'est bon j'ai reedite et mis une petite gestion d'erreur.

Mais tu n'utilises toujours pas PATH_MAX... Cela réduit la portabilité du code pour commencer, et pire : cela peut provoquer des erreurs avec des noms / chemins longs en fonction de l'OS.

[Médinoc]

Avec la fonction d'ouverture telle que tu l'as écrite, il y a des problèmes si on ouvre un log après en avoir fermé un autre.

Tu devrais faire une recherche linéaire d'un emplacement vide (un bète for qui s'arrête quand le FILE* est nul, quoi) plutôt que te baser sur ta variable statique...

[lilington]

donc j'ai essayer de satifaire tout le monde. vous avez tous jeter votre devolu sur moi
snif snif mais honetement c'est ce que je voulais. merci donc et voici la correction je suppose que personne n'aura plus rien a rajouter.

fichier main:

Code :

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

1
2
3
4
5
6
7
8
9
 
  int sousSysteme1 = initLog("networklog");
  int sousSysteme2 = initLog("system");
 
  //code code code code code code.....
  closeLog(sousSysteme1);
  ...
  ...
  closeLog(sousSysteme2);

donc le table sur les structure FILE* a bouge.

Code :

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

1
2
3
4
5
6
7
8
9
10
11
12
 
#ifndef _LOG_H_
#define _LOG_H_ 1
 
#include <stdio.h>
 
#define MAX_LOG 5  //nombre max de fichier log ouvert simultanement.
 
extern int initLog(char filename[PATH_MAX]);  
extern int closeLog(int logd);
 
#endif

oui c'est vrai j'ecris en fancais les commentaires. de toute facons si j'ai le temps de modifier le code j'ai aussi le temps de le Molieriser.

la recherche du NULL est effectivement mieux pense. en plus j'avais meme pas fais de test avec ma variable static. si le nombre de log etait trop grand j'aurai eu des pepins. merci donc

log.c:

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
#include "log.h"
#include <string.h>
#include <stdlib.h>
#include <limit.h>
 
static FILE *tbLog[MAX_LOG] = {NULL};
 
extern int initLog(char filename[PATH_MAX])
{
	int indice;  
        FILE *rien=NULL;    //varirable provisoire pour tester l'ouverture du fichier
 
	if ((rien = fopen(filename,"w")==NULL))   
	{
               return -1; 
        }
 
        for (indice = 0 ; indice < MAX_LOG; indice++) //bouche cherchant un emplacement libre pour stoker le FILE*
        {
              if(tblLog[indice]==NULL)
              {
                    tblLog[indice] = rien;
                    break;
              }
        }
        if(indice >= MAX_LOG)
        {
             return -1;
             fclose(rien);
        }
	return indice;	              //return log number
}
 
extern int closeLog(int logd)
{
	if (tbLog[logd] == NULL)
	{
		printf("No log to close \n");
		return -1;
	}
	fclose(tbLog[logd]);
	tblog[logd] = NULL;
        return 0;
}

donc pour monsieur et ca portabilite il est aussi servie je pense que c'est effectivement une habitude que je devrais prendre meme si ce code est destine a un groupe limite de personnes. et oui j'aime le mot extern
encore merci.

donc il n'y a aucun probleme avec cette histoire de stoker les FILE* a l'interrieurs d'un fonction? pas de problemes dans la memoire ou autres?

Pour vos interventions, le probleme c'est que c'est frustrant que les gens vous disent ce que vous etes deja sense savoir.
merci quand meme d'avoir pris le temps de me dire des choses triviales j'essairai de reflechir plus la prochaine fois afin que vous puissier rencontrer des problemes qui vaille la peine que vous ecrivier.
Merci encore

[diogene]

1-

Code :

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

1
2
3
4
5
6
7
8
9
10
#ifndef _LOG_H_1
#define _LOG_H_ 1
 
#include <stdio.h>  // inutile ici
 
#define MAX_LOG 5  //nombre max de fichier log ouvert simultanement.
 
extern int initLog(char filename[]);  // PATH_MAX est inutile et parfaitement ignoré par le compilateurextern int closeLog(int logd);
 
#endif

- une faute de frappe sur #ifndef
- Le #include <stdio.h> est inutile ici. Il devrait être dans le .c (qui lui en a besoin pour FILE, fopen, fclose)
- Indiquer PATH_MAX est inutile et parfaitement ignoré par le compilateur.

2-

Code :

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

1
2
3
4
5
 if(indice >= MAX_LOG)
        {
             return -1;
             fclose(rien);
        }

le fclose ne sera jamais exécuté.

Code :

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

1
2
3
4
5
6
7
8
9
10
11
12
13
14
extern int initLog(char filename[])
{
    int indice;  
    for (indice = 0 ; indice < MAX_LOG; indice++) //bouche cherchant un emplacement libre pour stoker le FILE*
    {
        if(tblLog[indice]==NULL)
        {                   
              tblLog[indice] = fopen(filename,"w");
              break;
         }
    }
    if(indice >= MAX_LOG || tblLog[indice] == NULL ) return -1;
    return indice;	        //return log number
}

[lilington]

oups, le fclose vient avant le return -1. cependant je tiens a l'ajouter car le fichier reste ouvert et ne sera jamais ferme etant donne que la valeur de "rien" n'est pa null et qu'il n'y a plus de place dans le tableau.

[Médinoc]

Il faut chercher une place AVANT de tenter d'ouvrir le fichier.