Bonjours à tous !

Étant plus ou moins débutant en C++, et donc dans la POO, j'ai sûrement une lacune qui me bloque dans mon développement.
Donc dans mon projet, je suis entrain d'implémenter un objet pour générer des logs.
Donc j'ai fais une classe de gestion de fichier texte ( qui fonctionne très bien ).

Mon problème est le suivant : Comme j'instancie plusieurs instance de mon fichier texte, il arrive que mes objets qui désire écrire des logs viennent à écrire ensemble dans le fichier .. et donc .. tout plante.

Donc je me suis dis... Seule moyen, avoir 1 seule objet pour TOUT le projet et donc, il faut que chacun de mes objets qui vont vouloir écrire leurs logs, puissent accéder à cette objet de logs initialisé dans le main().

Synchronise (par mutex) l'accès à ta fonction interne d'écriture dans le fichier de logs.

Merci pour ta réponse.

Ok je veux bien, mais si j'instancie plusieurs objets TextFile, le mutex fonctionnera quand même entre chaques instances ??

Il faut que toutes les instances de ta classe d'interface pointent vers un même objet interne commun que tu lieras à ton fichier.

Ce genre de cas est en C, un des motifs d'utilisation de variable globale. En C++ on préfèrera un recourir à une classe singleton, c'est à dire une classe dont il n'existera qu'une seule instance dans l'unité de programme. Il existe plusieurs façons de faire un singleton, en fonction, des conditions, des raffinements souhaités, et de l'age du capitaine (paramètre capital quand on aime le beau code ).

Un exemple de singleton très simple,

class Log
{
private:
    Log(const std::string & filename = "log.log"){/* ouverture du fichier de log */}  
public:
    ~Log(){/* flush et fermeture du fichier de log */}
    friend Log & GetLog();
    void WriteLog(const std::string & data);
}

inline Log & GetLog(){static Log s_Log;return s_Log;}

Tu remarqueras que le constructeur est privé, ce qui interdit la création d'une instance de la classe de Log, en dehors de la fonction amie GetLog. L'avantage de cette méthode, sera de créer le log automatiquement, dés que le programme en aura besoin.

C'est vraiment du singleton basique, mais ça marche.

GetLog().WriteLog("Ma ligne de log");

Basiquement, avec ça tu devrais pouvoir faire une classe log, qui te donneras pleinement satisfaction sur un programme monothread. En multithreading, il faudra synchroniser tout ça, notamment en réalisant toutes les écritures dans le log en section critique. Je ne saurais pas te dire quelle est la meilleure tactique, en fait la réponse dépend de ce que tu veux faire et des contraintes que tu dois respecter.

Citation : int21h

En multithreading, il faudra synchroniser tout ça, notamment en réalisant toutes les écritures dans le log en section critique. Je ne saurais pas te dire quelle est la meilleure tactique, en fait la réponse dépend de ce que tu veux faire et des contraintes que tu dois respecter.

Ben ce que je veux faire, c'est que mes n threads écrivent dans un fichier de log ce qu'ils font ( si je le demande au démarrage du projet )...
Y a pas trop de trucs à respecter ... simplement faire des logs ...

Mais merci ! Je vais me renseigner à partir de tes explications !!!

Edit : Bon je vient d'essaier de faire la classe.. mais j'ai pas vraiment réussi...
J'ai donc fais une classe Log en singleton sans soucis.
Je l'importe dans le fichier du int main(), puis j'instancie et j'écris une ligne de log... ca va !

Mais, maintenant mes questions :







Voici ma classe Log :

#include "textfile.hpp"
#include <iostream>

//~ !! Singleton Class !!
class Log
{
	private:
		Log( const std::string & LogFilePath = "./logfile.log" )
		{
			std::cout << "Initializing log file..." << std::endl;
			
			//~ Initiaize text file
			TextFileForLogs = LogFilePath;
			
			std::cout << "Log file Initialized." << std::endl;
		}
		
		~Log()
		{
			std::cout << "Closing log file..." << std::endl;
			
			TextFileForLogs.CloseFile();
			
			std::cout << "Log file closed!" << std::endl;
		}
	
	public:
		//~ Function to write a line in the text file
		void WriteLog( const std::string LogMessageToAdd )
		{
			
			//~ Wait for the Text File to be Free
			while ( 1 )
			{
				
				if ( TextFileForLogs.IsFree() )
				{
					//~ File is free, write the log
					TextFileForLogs.OpenForOutput( false );
					TextFileForLogs.WriteLine( LogMessageToAdd );
					TextFileForLogs.CloseFile();
					
					break;
				}
			}
			
		}
		
		//~ Function to create the Singleton Class
		static Log *GetInstance ()
		{
			if (NULL == singleton)
			{
				
				std::cout << "creating singleton." << std::endl;
				singleton =  new Log;
				
			} else {
				
				std::cout << "singleton already created!" << std::endl;
				
			}
			
			return singleton;
		}
		
		//~ Function to distroy Singleton Class
		static void kill ()
		{
			if (NULL != singleton)
			{
				delete singleton;
				singleton = NULL;
			}
		}

	
	private:
		static Log 		*singleton;
		TextFile		TextFileForLogs;
};

Et pour l'initialiser, je fais donc :

Log		*LogFile;		//~ Initialize the Log Object ( SingleTon Class )
LogFile		= Log::GetInstance();

1) transforme tes tab en 4 espaces pour l'affichage

2) on ne fait pas de while(1) sans sleep et encore j'irais pour :

while( !TextFileForLogs.IsFree() )
    Sleep( 100 );

//...

3) Tu peux aussi utiliser un compteur d'accès que tu incrementera à chaque getInstance et que tu décrémentera à chaque Release ou Kill. Sinon tu permet de libérer le singleton même si d'autres thread en on encore besoin.

4) Ton constructeur prend un paramètre mais il n'y a aucune chance qu'il en reçoive un.

Aucun intérêt de s'embêter à faire que instance() génère un Log si aucun n'a été construit jusqu'à présent.
C'est compliqué, cela limite ta bibliothèque à un seul composant dans ton appli, et en plus ta contrainte multi-threads fait que tu n'es pas autorisé à faire de la construction paresseuse/implicite.

http://www.siteduzero.com/forum-83-179 [...] ingleton.html


@MatteX, il y a des recettes de spin mutex qui ne font justement aucun sleep().
Dans mes souvenirs, c'est un truc efficace quand il y a très peu d'accès bloqués, ou alors qu'ils ne durent pas. C'est aussi le truc que j'ai tendance à utiliser en dernier recours pour préférer les mutex plus classiques à la place.

Bonjour à tous !

Ce matin je me suis relancer dans cette histoire et j'ai réussi !!
Enffet y avait un manque de compréhension de ma part sur l'utilisation du Singleton.
Là où je faisais l'erreur c'est qu'a chaque ligne que je voulais écrire, juste derrière je cherchais à supprimer mon objet log.

Bref, maintenant ca marche impec !
Je vais pouvoir sortir ma premier release !!! Ouf !!


Merci à vous pour vos messages qui m'ont aider !