Discussion :

[karto]

Bonjour

J'ai récupéré une classe permettant d'écrire une log.

Le membre central de cette classe est un objet ostream.

Code :

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

1
2
3
4
5
6
7
8
9
10
11
12
13
14
class TraceLog
{
private:

	//! true if stream is valid, false otherwise 
	bool _valid_stream;

	//! output stream
	ostream* _logstream;

	//! singleton of TraceLog
	static TraceLog* _single_instance;
}

Je ne comprend pas très bien l'utilisation des flux mais voici ce que je pense avoir compris ;

- ostream est objet assez générique qui peut pointer vers plusieurs support : fichier, sortie standard, string...
- Ce choix offre donc une plus grande souplesse.

Question :

- Moi je veux y brancher un fichier, comment faire pour récupérer les fonctions permettant de manipuler un fichier (notamment close( )), sachant que rdbuf( ) renvoi un streambuf et qu'il faudrait un filebuf.
- j'ai bien essayé de caster le streambuf mais j'ai alors une erreur de compile

[Laurent Gomila]

Pourquoi as-tu besoin de récupérer le flux par la suite ? Normalement tu le crées, tu le passes au logger, et puis tu ne t'en occupes plus. Si tu as des opérations spécifiques à faire dessus alors stocke le séparément sous forme de ofstream.

[karto]

L'utilisateur peut changer le nom du fichier de log via l'IHM de l'appli.

J'aimerai donc pouvoir fermer le premier fichier Log avant d'en ouvrir un autre

[Laurent Gomila]

Qui doit gérer la durée de vie du flux de log, le logger ou toi ? En d'autre termes est-ce que le logger ne fait que pointer vers un flux, ou bien c'est lui qui crée / détruit le flux ?

[karto]

En fait je créé un objet Log, puis appel une fonction init(..) qui passe le pointeur de flux à l'objet Log.
Donc c'est moi qui ai créé le flux.
En l'occurence je créé un ofstream casté en ostream

[Laurent Gomila]

Donc tu stockes de toute façon l'instance de ofstream en dehors du logger. Donc elle devrait être accessible au moment où tu veux ouvrir un autre fichier non ?

[karto]

Et non !
Une fois que j'ai casté mon instance d'ofstream en ostream je perd toute référence sur l'ofstream.
Mais ta remarque éclaire mon problèmes sous un autre jour. Je vais voir en réorganisant tout ça, en attendant merci pour tes remarques

[Laurent Gomila]

Et non !
Une fois que j'ai casté mon instance d'ofstream en ostream je perd toute référence sur l'ofstream.

Ca me paraît bizarre, je soupçonne une erreur dans ton programme. Tu peux montrer le code correspondant ?

[karto]

Voici le code qui appel l'initialisation de la log

Code :

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

1
2
3
4
5
6
bool VectorData::InitLog(char* logPathName, short iTraceLevel)
{
	ofstream* logstream = new ofstream (logPathName, ios_base::app);
	ostream* log = (ostream*)logstream;
	return  InitLog(log, iTraceLevel);
}

Et voici la fonction de la classe TraceLog qui réalise l'init

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
bool TraceLog::InitLog(ostream*& logstream, short iTraceLevel)
{
	bool ret = false;
 
	_logstream = logstream;
	if (*_logstream && !(_logstream->fail()))
	{
		*_logstream << endl << "**********************************************************" << endl;
		_valid_stream = true;
		WriteTimeStampedMessage("Log Info - New execution of program",0);
 
		ret = true;
	}
	else
	{
		ret = false;
	}
 
	traceLevel = iTraceLevel;
 
	return ret;
}

Précisons que ma classe TraceLog est un singleton je n'ai donc qu'une seule instance.

Je pense que la solution consiste effectivement à stocker l'ofstream. Je suis simplement étonné qu'il n'y ai pas de passerelle entre un objet générique vers un objet plus spécialisé : soit de passer de ostream ==> ofstream

[Laurent Gomila]

Il y a effectivement une erreur dans ton programme : une fuite mémoire (qui va détruire le flux ?).

Il faut que celui qui crée le flux s'occupe également de le détruire, et pour ça il faut bien le stocker en dehors du logger. Et déléguer la destruction au logger serait une mauvaise idée, si ce n'est pas lui qui le crée (on peut très bien passer un flux qui n'aura pas été alloué avec new).

Un détail : pourquoi passes-tu une référence vers un pointeur d'ostream pour initialiser ton logger ? S'il n'est pas modifié par la fonction, la référence ne sert à rien.

Autre détail : l'up-casting (conversion derivée vers base) est implicite, pas besoin de créer une nouvelle variable pour ça

Encore une chose : généralement si on ne veut que changer la cible du log, c'est le streambuf du flux qu'il faut changer ; mais il n'y a pas besoin d'un nouveau flux. Pour clarifier les choses, disons que le flux réalise le formattage, et qu'il envoie le résultat à son streambuf pour écriture vers sa cible.

[karto]

Le passage par référence, c'est parceque j'ai récupéré la classe TraceLog telle qu'elle. Je vais corriger.

J'ai stocké le ofstream dans la méthode appellante, je pourrai ainsi modifier son buffer et le déleter en fin de traitement.

Merci pour ton aide