class MY_API CLog : public Singleton<CLog>
{
public: 
	CLog();		// use default log file (log.txt)

	CLog(String FileName);

	~CLog()		{ Close(); }
		
	void Message(String Message);

	finline void SetForceFlush(const bool v)	{ m_ForeFlush = v; }
	finline bool GetForceFlush() const			{ return m_ForeFlush; }

	// nice operator :)

	template<class T> CLog &operator<<(const T& output)
	{
		Guard(template<class T> CLog &operator<<(const T& output))

		m_LogStream << output;
		if (m_ForeFlush) m_LogStream.flush();
		return *this;

		Unguard();
	}
		
private:
	std::ofstream	m_LogStream;
	bool			m_LogOpen;
	bool			m_ForeFlush;

	inline void Open(String Filename);	// with this function we open our logfile

	inline void Close();				// with this function we close our logfile

	};

template<typename Type>
class Singleton
{
protected:
	Singleton()		{}
	virtual ~Singleton()	
	{ 
		if (ms_pGlobalInstance) 
		{ 
			delete ms_pGlobalInstance; 
			ms_pGlobalInstance = 0;
		} 
		else
		{}
	}
	
private:
	static Type* ms_pGlobalInstance;
	
public:
	inline static Type* GetInstance()
	{
		if (!ms_pGlobalInstance)
		{
			ms_pGlobalInstance = new Type();
		}
	
		return ms_pGlobalInstance;
	}
};
	
template <typename Type>
Type* Singleton<Type>::ms_pGlobalInstance = 0;

inline void CLog::Close(){	Guard(CLog::Close);	if (m_LogOpen)	{		m_LogStream << "-------------------------------------" << std::endl;		// get time again		struct tm *pTime;		time_t ctTime; 		time(&ctTime);		pTime = gmtime(&ctTime);		m_LogStream << "Logfile closed at " << pTime->tm_hour << ":" << pTime->tm_min << ":" << pTime->tm_sec << std::endl;		// close file now		m_LogStream.flush();		m_LogStream.close();		m_LogOpen = false;	}	Unguard();}

quote:Original post by Magmai Kai Holmlor
destructor not "deconstructor".

quote:
So is it talking about any derived class or just pure virtual classes?

You have to know what you''re doing. If a class has any virtual methods (pure or not), it probably ought to have a virtual dtor.

What matters is what creates the class, and what destroys it. If the destroyer knows the exact type, the dtor doesn''t need to be virtual. But if we do thing like:

Base* new_object = CreateMeAnObject(some_id);delete new_object;   

We need a virtual dtor, because we destroy the object from a base class pointer.

RealClass* obj = new RealClass;delete obj;   

No virtual dtor required (still works if it has one).


[edited by - Magmai Kai Holmlor on September 1, 2003 8:58:59 PM]