C / C++ / MFC

static T* GetInstance()
{
    if( ! m_pInstance )
    {
        m_pInstance = new T;
    }
    TRACE( "CSingleton::GetInstance() returning %p\n", m_pInstance );
    return m_pInstance;
}

CMyClass * p = NULL;
p = CreateMyClass();
if( p )
{
    TRACE( "CMyClass instance 1 is %p\n", p );
}
p = CreateMyClass();
if( p )
{
    TRACE( "CMyClass instance 2 is %p\n", p );
}

CMyClass::Destroy();

#ifdef DLL_EXPORTS
#define DLL_API __declspec(dllexport)
#else
#define DLL_API __declspec(dllimport)
#endif // DLL_EXPORT

DLL_API CMyClass* CreateClass();
DLL_API void DestroyClass();

Cedric Moonen wrote:

Any idea of what's happening here and how to solve the problem ?

led mike wrote:

My question is based on the assumption that the singleton design does NOT produce this problem when contained in a single executable project correct?

led mike wrote:

Why do you need this design? Why do you need a singleton class to reside in a DLL? DLL's are supposed to be libraries. The requirement for the Singleton should be at the application level rather than at the library level so I am not seeing the benefit in this layout.

Cedric Moonen wrote:

Does that make sense ?

led mike wrote:

You are designing a render engine into a DLL library to be used by different applications?

led mike wrote:

This would simplify the engine design as well as provide a more flexible use model.

led mike wrote:

Then the application is responsible for these assignments. Responsibility == Flexibility.

// logger.h
<class t=""><class t=""><T>template <class T> class singleton{
protected:
	static T* _pinstance;

	singleton(){}
	virtual ~singleton(){}

public:
	static T& getInstance(){
		if( !_pinstance)
			_pinstance = new T();
		return *_pinstance;
	}

	static void release(){
		delete _pinstance;
		_pinstance = NULL;
	}
};

template<class T> T* singleton<T>::_pinstance = NULL;

class LOGLIBSINGLETON_API Logger : public singleton< Logger>
{
public:
	Logger(void);

	bool log( LPTSTR eventSource, DWORD dwEventID, WORD wCategory, LPCTSTR message);

public:
	~Logger(void);
};

</T></class></class>

Logger::getInstance().log( msg, 0, 1, msg);
Logger::release();

DLL_API CEngine* CreateEngine(....)
{
   CEngine* pEngine = CEngine::GetInstance();
   pEngine->....;
   return pEngine;
}

DLL_API void ReleaseEngine()
{
   CEngine::release();
}

// logger.h
LOGLIBSINGLETON_API Logger& GetLogger();

// logger.cpp
LOGLIBSINGLETON_API Logger& GetLogger()
{
	return Logger::getInstance();
}

// application code
Logger& logger = GetLogger();
logger.log( msg, 0, 1, msg);
Logger::release();

led mike wrote:

Well I added that new twist of the exported function but I still cannot reproduce your problem

led mike wrote:

I don't understand why you need an exported function that just returns a pointer to an instance but that's just me.

Cedric Moonen wrote:

What IDE are you using ? I'm working with VC2005 Express.

Cedric Moonen wrote:

If I use several public function to do that it is not clean:

Cedric Moonen wrote:

but I don't know if it can export classes.

Cedric Moonen wrote:

So, being able to use this dll in other language will require only to rewrite the interfaces.

led mike wrote:

That is confusing since the "interfaces" you mention must be exported from your library correct?