class MySingleton
{
public:
	MySingleton * GetInstance()
				{
				if(pInstance) return pInstance;
// If already declared, return existing reference
				else return (pInstance = new MySingleton);
// Otherwise, make a new one
				}
	Do() { cout << "Did something" << endl; }
private:
	MySingleton(){}; // Make Constructor private so it can only be
accessed via GetInstance()
	static MySingleton * pInstance;
}; 

...
static MySingleton * MySingleton::pInstance = NULL;
... 

#include "MySingleton.h"

void main(void)
{
	MySingleton::GetInstance()-Do();
	//or
	MySingleton * pSing = MySingleton::GetInstance();
	pSing-Do(); // Uses exact same instance as the first line
} 

#ifndef _F__TRACE_H_
#define _F__TRACE_H_

#include <stdio.h>
#include <stdlib.h>
#include <io.h>
#include <assert.h>
//#include <iostream>
#include <fstream>
#include <windows.h> // Required before including winbase :(
#include <winbase.h> // For SYSTEMTIME

#include "file/file.h"
#define LOGFILENAME ".\\log.txt"


//////////////////////////////////////////////////////////////
#ifndef NOTRACE
	#define PUSHSTACK(x)			StackTrace st(x,__FILE__,__LINE__);
	#define TRACE(x)				FTrace::GetInstance()->Log(x);
#define STOP_TRACE() 		delete FTrace::GetInstance();
#else
	#define PUSHSTACK(x)	
	#define TRACE(x)		
#endif
//////////////////////////////////////////////////////////////

using namespace std;

class FTrace
{
public:

	static FTrace * GetInstance();

	static void IncrementStackDepth() { m_nCurStackDepth++; }
	static void DecrementStackDepth() { m_nCurStackDepth--; }
	static int  GetStackDepth()		  { return m_nCurStackDepth; }
	
	void Log(const char*);
	
	~FTrace();

private:
	FTrace();
	File * logFile;
	static FTrace * pivInstance;

	static int m_nCurStackDepth;
	
	void GetDateString(char * destString);

};

class StackTrace
{
public:
	StackTrace(const char*,const char* szFileName="unknown", int nLine = 42);

	~StackTrace();

private:
	char m_szFuncName[100];
	SYSTEMTIME m_StartTime;
};


#endif 

#include "Debug/FTrace.h"


// ******************************************************************************
// **					FTrace: Log to file singleton class
// ******************************************************************************

FTrace * FTrace::pivInstance;
int FTrace::m_nCurStackDepth;


FTrace::FTrace()
{
	pivInstance = 0;
	m_nCurStackDepth = 0;
	
	logFile = new File;
	logFile->Open(LOGFILENAME,FILE_TEXTREADWRITE);
	Log("****** Started ******");
}

FTrace::~FTrace()
{
	m_nCurStackDepth =0;
	Log("****** Ended ******");
	delete logFile;

}


FTrace * FTrace::GetInstance()
{
	if(pivInstance != 0)
		return pivInstance;
	return FTrace::pivInstance = new FTrace;
}


// Dest must already be allocated
void FTrace::GetDateString(char * dest)
{
	dest[0] = 0;
	char lpTempBuf[255]; lpTempBuf[0];
	SYSTEMTIME  sysTime;
	GetLocalTime(&sysTime);
	GetDateFormat(LOCALE_SYSTEM_DEFAULT,
					DATE_SHORTDATE,
					&sysTime,
					NULL,
					lpTempBuf,
					250);
	sprintf(dest,"%s %d:%d %d:%d",lpTempBuf,sysTime.wHour,
									sysTime.wMinute,sysTime.wSecond,sysTime.wMilliseconds);
}

void FTrace::Log(const char * logString)
{
	assert(logString != NULL);
	
		char * curDate; curDate = new char[255];
		GetDateString(curDate);
		for(int i = 0 ; i < m_nCurStackDepth;i++)
			logFile->WriteChar(' ');

		logFile->WriteChar('[');
		char hack[10]; hack[0] = 0;
		sprintf(hack,"%d",m_nCurStackDepth);
		logFile->WriteString(hack);
		
		logFile->WriteChar(']');
		logFile->WriteChar(' ');
		logFile->WriteString(curDate);
		logFile->WriteChar(' ');
		logFile->WriteString(logString);
		logFile->WriteChar('\n');
		delete curDate;
}



// ******************************************************************************
// **					StackTrace: Stack based logging routine
// **						has dependancies on FTrace
// ******************************************************************************

// *********************************
// StackTrace is a helper class to FTrace that autoterminates on function termination
// Using contructor and destructor to generate start/stop logs, as well as recording
// the current depth of the trace

StackTrace::StackTrace(const char * szFuncName,const char* szFileName,int nLine)
{
	FTrace * ft = FTrace::GetInstance();
	
	ft->IncrementStackDepth();

	m_szFuncName[0] = NULL;
	
	strcpy(m_szFuncName,szFuncName);

	char debugString[256];
	debugString[0] = 0;

	strcpy(debugString,"[START]\tEntered function: ");
	strcat(debugString,m_szFuncName);
	sprintf(debugString,"%s in %s on line %d",debugString,szFileName,nLine);

	ft->Log(debugString);
	GetLocalTime(&m_StartTime);
}

StackTrace::~StackTrace()
{
	FTrace * ft = FTrace::GetInstance();

	WORD totalTime;

	SYSTEMTIME elapsedTime;
	GetLocalTime(&elapsedTime);

	totalTime = ((elapsedTime.wSecond - m_StartTime.wSecond) * 1000) + (elapsedTime.wMilliseconds - m_StartTime.wMilliseconds);
	char debugString[256];
	debugString[0] = 0;
	sprintf(debugString,"[STOP] (%d ms)\tExiting function: ",totalTime);

	if(m_szFuncName != NULL)
	{
		strcat(debugString,m_szFuncName);
		ft->Log(debugString);

	}

	ft->DecrementStackDepth();
}