Original Post
Say that I need only one instance of a certain class: for example, I cound have a CLogFile class, and I only want one logfile to be in the application plus I want it to be globally accessible. I don't need class inheritance. There are several solutions to this problem.. I could create a global instance of the class, and I could solve the problem of undefined order of creation/destruction of globals by using my own Init() and Term() functions: Another possibility is to use some variant of the singleton pattern. With it we can ensure there is only one instance of the class, it is globally accessible and it is created when requested, and we could add a static function to destroy the instance to be called at the end of the program.. My point is that there is a much simpler solution: the LogFile doesn't need to be a class. Its functions could just go in a namespace, including Init() and Term(). The code, in my opinion, is more clean, and encapsulation is better because all the private members of CLogFile are hidden in LogFile.cpp. There are less #include files in the header, resulting in faster compile times and less dependencies. The problem is that, seeing other people's code, this solution is seldom used, and people tend to use classes just about anywhere. I was pretty shocked when I saw code like this in some open source engine:
//---------------------------------------------------------------
// LogFile.h
//---------------------------------------------------------------
#include <cstdio>
class CLogFile
{
public:
CLogFile() { }
~CLogFile() { }
void Init();
void Term();
void Print( char* );
private:
FILE* m_File;
};
extern CLogFile g_Log;
//---------------------------------------------------------------
// LogFile.cpp
//---------------------------------------------------------------
#include "LogFile.h"
CLogFile g_Log;
void CLogFile::Init()
{
// init
}
void CLogFile::Term()
{
// terminate
}
void CLogFile::Print( char* )
{
// do stuff
}
//---------------------------------------------------------------
// Main.cpp:
//---------------------------------------------------------------
g_Log.Init();
g_Log.Print( "Hello, world!" );
g_Log.Term();
//---------------------------------------------------------------
// LogFile.h
//---------------------------------------------------------------
#include <cstdio>
class CLogFile
{
CLogFile();
public:
~CLogFile();
void Print( char* );
static CLogFile* GetInstance();
static void DestroyInstance();
private:
static CLogFile* m_Instance;
FILE* m_File;
};
//---------------------------------------------------------------
// LogFile.cpp
//---------------------------------------------------------------
CLogFile* CLogFile::m_Instance = NULL;
CLogFile* CLogFile::GetInstance()
{
if( !m_Instance )
{
m_Instance = new CLogFile();
}
return m_Instance;
}
void CLogFile::DestroyInstance()
{
delete m_Instance;
m_Instance = NULL;
}
void CLogFile::Print( char* )
{
// do stuff
}
//---------------------------------------------------------------
// Main.cpp:
//---------------------------------------------------------------
CLogFile::GetInstance()->Print( "Hello, world!" );
CLogFile::DestroyInstance();
//---------------------------------------------------------------
// LogFile.h
//---------------------------------------------------------------
namespace LogFile
{
void Init();
voit Term();
void Print( char* );
};
//---------------------------------------------------------------
// LogFile.cpp
//---------------------------------------------------------------
#include "LogFile.h"
#include <stdio.h>
namespace LogFile
{
FILE* m_File;
void Init()
{
// init
}
void Term()
{
// terminate
}
void Print( char* )
{
// do stuff
}
}
//---------------------------------------------------------------
// Main.cpp:
//---------------------------------------------------------------
LogFile::Init();
LogFile::Print( "hello, world!" );
LogFile::Term();
class Collision
{
static void PointSphere( Vec3& v, Sphere& s );
static void SphereSphere( Sphere& s1, Sphere& s2 );
}
