C++: duplicated static member?

Question

I have a class which needs to be a singleton. It implemented using a static member pointer:

class MySinglton
{
public:
    static MySinglton& instance() { ... }
private:
    static MySinglton* m_inst;
};

This class is compiled into a .lib which is used in multiple dlls in the same application. The problem is that each dll sees a different m_inst. since it is compiled and linked separatly.

What is simple way to solve this problem?

Separating the .lib to its own dll is not an option. it must be a .lib.

Answer 1

I don't know if you consider this simple, but you'll need to allocate a "master instance" (on the heap, say) and then let all your MySingleton instances refer to the "master instance".

Answer 2

C++ has no built-in mechanism for sharing variables in the way you seem to want. The only solution is to pass the single instance as a function parameter, using a pointer or reference.

Answer 3

One way solving the problem is that creating a shared memory, and creating the object in the shared memory. The two modules still have two copies of the pointers, but they point to the same location i.e. same instance of an object.

Answer 4

I would use the shared memory mechanism provided by your os, MapViewOfFile or shmem. This might go:

class MySinglton
{
    public:
        static MySinglton& instance() {
            static MySinglton* m_inst = get_shared();
            return *m_inst;
        }
    private:
        static MySinglton * get_shared()
        {
            //1. Try to open shared memory, handle = OpenFileMapping.
            //2. If successful, return MapViewOfFile(handle).
            //3. Else, allocate enough space using CreateFileMapping, sizeof(MySingleton).
            //4. Initialise MapViewOfFile(handle), return MapViewOfFile(handle).
        }

        void Initialise()
        {
            // Stuff you would normally do in operator new here.
        }

};

Answer 5

A solution could be transferring the instantiation to the application, and the DLLs will get reference to it during initialization. It may not be as elegant as you'd like, but it would do it.

Need to know what's the REAL problem behind your question. The answer may not be in the form you expect it. ;)

Answer 6

There is no simple solution to your problem. Questions: If there is no solution shoosh what are you going to do? Abandon the project? Or re-structure it so the 'must be a .lib' constraint is removed? If this problem concerns a commercial project what are you going to say to the project manager, stakeholders, etc?