Impossible d'écrire dans un fichier

#include <fstream>

class Logger 
{};

class LogFile : public Logger
{
public:
	LogFile(const std::string& FileName="Log.txt");
	~LogFile(void);
private :
	virtual void Write(const std::string& Msg);
	std::ofstream oWrite;
};

#include "StdAfx.h"
#include "logger.h"
#include <string>

std::string GetDate() { return "15/07/1999" ; }
std::string GetTime() { return "16:52:32" ; }

LogFile::LogFile(const std::string& FileName)
{
	oWrite.open(FileName.c_str());
	if(!oWrite)
		MessageBox(NULL,"File not open","Angel",MB_OK);
	oWrite<<"|-----------------------\tAngel"<<GetDate()<<"\t"<<GetTime()<<"\t-----------------------|\n";
}
LogFile::~LogFile(void)
{
	oWrite<<"|-----------------------\tAF Corporation\t-----------------------|\n";
	oWrite.close() ;
}
void LogFile::Write(const std::string& Message)
{
	if(!oWrite.is_open())
		MessageBox(NULL,NULL,NULL,MB_OK);
	oWrite<<Message<<"\n";
} 

void CTestDlg::OnBnClickedButton1()
{
     LogFile log; 
}

#include <iostream>
#include <fstream>

class LogFile
{
public:
  LogFile(const std::string& FileName="Log.txt");
  ~LogFile();
  virtual void Write(const std::string& Msg);

private:
  std::ofstream oWrite;
};

LogFile::LogFile(const std::string& FileName)
{
  oWrite.open(FileName.c_str());
  if(!oWrite)
    std::cerr << "File not open Angel" << std::endl;
  oWrite << "|-----------------------\tAngel\t-----------------------|\n";
}

LogFile::~LogFile()
{
  oWrite << "|-----------------------\tAF Corporation\t-----------------------|\n";
  oWrite.close();
}

void LogFile::Write(const std::string& Message)
{
  if(!oWrite.is_open())
    std::cerr << "Not open" << std::endl;
  oWrite << Message << "\n";
}

int main()
{
  LogFile log("test.txt");

  log.Write("kikoo\n");
  log.Write("kikoo2\n");

  return 0;
}

class LoggerManager
{
static LoggerManager P_log;
virtual write(const char*);
  public:
   static void SetLog(LoggerManager* NewLog);
   static void Log(const char*); 
   static void Destroy();
};

LoggerManager* LoggerManager:: P_log = NULL;
void LoggerManager::SetLog(LoggerManager* NewLog)
{
    Destroy();
    P_log=NewLog;
}
void LoggerManager::Log(const char* LOG)
{
      if(!P_log)return;
      P_log->write(LOG);
}
void LoggerManager::Destroy()
{
   delete P_log;
   sizerof(P_log);
}

class LogFile
{ 
  FILE*m_File;
  void write(const char* texte)
  {
     fputs(texte,m_File);
  }
  public:
    LogFile(const char* Fname)
    {
        fopen(Fname,"w");
        fputs("---------------------*)(ANGEL)(*-------------------\n",m_File);
      }
     ~LogFile()
      {
         fputs("---------------------------------------------------",m_File);
         fclose(m_File);
       }
};
     

#ifndef SINGLETON_HH_
# define SINGLETON_HH_

template<typename T>
class Singleton
{
protected:
 Singleton();
 virtual ~Singleton();

public:
 static T&     getInstance();
};

# include "Singleton.hxx"

#endif /* !SINGLETON_HH_ */

/*!
** Construct the singleton.
*/
template<typename T>
Singleton<T>::Singleton()
{

}

/*!
** Destruct the singleton.
*/
template<typename T>
Singleton<T>::~Singleton()
{
}

/*!
** Get the instance of the singleton.
**
** @return Instance of the object
*/
template<typename T>
T&
Singleton<T>::getInstance()
{
 static T object;
 return object;
}

 class LogFile : public Singleton<LogFile>
 {
   friend class Singleton<LogFile>; // Simplifie l'appel

 private:
   LogFile();
   ~LogFile();
   std::ofstream m_File;
public:
   void open(const char* texte);
   void write();
   void close();
 };

void function()
{
  LogFile& log = LogFile::getInstance();
  log.write("Youpi");
}

int main()
{
  LogFile& log = LogFile::getInstance();
  log.open("file.txt"); // Dans le début du main par exemple
  log.write("Kikoo");
  function()
  log.close(); // A la fin du main par exemple.
}

class LogMsgBox
{ 
 
  void write(const char* texte)
  {
     MessageBox(NULL,texte,"-)(ANGEL)(-",MB_OK);
  }
  
};