Singleton MFC extension DLL

dllmfcsingleton

I declare a singleton on a MFC extension DLL, like this:

//header file: SingleTon.h
class AFX_EXT_CLASS CMySingleton
{
public:
  static CMySingleton* Instance()
  {
    if(!singleton)
        singleton = new CMySingleton();
    return singleton;
  }

  int a;

// Other non-static member functions
private:
  CMySingleton() {};                                 // Private constructor
  CMySingleton(const CMySingleton&);                 // Prevent copy-construction
  CMySingleton& operator=(const CMySingleton&);      // Prevent assignment
  virtual ~CMySingleton() {};

  static CMySingleton* singleton;
};

And in a cpp file I code the following line:

CMySingleton* CMySingleton::singleton = NULL;

Code 2:

CMySingleton *a;

a = CMySingleton::Instance();

The problem is when I code "code 2" in a Regular Dll, all works fine, but when I code "code 2" in another MFC extension DLL gives an error:

unresolved external symbol "private: static class CMySingleton* CMySingleton::singleton" (?singleton@CMySingleton@@0PAV1@A)

I check correctly all the dependencies, via Project Dependencies.

Any idea?

Best Answer

The problem is in the AFX_EXT_CLASS macro.

#ifdef _AFXEXT
    #define AFX_EXT_CLASS       __declspec(dllexport)
#else
    #define AFX_EXT_CLASS       __declspec(dllimport)
#endif

Extension dll defines _AFXEXT and your class is exported, and main app (or a regular dll) doesn't define it so it's imported. But your second extension dll also defines _AFXEXT and your class declaration uses dllimport instead of dllexport and you get a linker error. The solution is to create your own macro for both dlls and use them instead of AFX_EXT_CLASS:

#ifdef EXTENSION_ONE
    #define EXT_CLASS_ONE       __declspec(dllexport)
#else
    #define EXT_CLASS_ONE       __declspec(dllimport)
#endif

Create EXTENSION_TWO and EXT_CLASS_TWO for your second dll. Define EXTENSION_ONE only in your first extension dll project, and EXTENSION_TWO only in your second extension dll project.

Related Solutions

Difference between static class and singleton pattern

What makes you say that either a singleton or a static method isn't thread-safe? Usually both should be implemented to be thread-safe.

The big difference between a singleton and a bunch of static methods is that singletons can implement interfaces (or derive from useful base classes, although that's less common, in my experience), so you can pass around the singleton as if it were "just another" implementation.

C++ Singleton design pattern

In 2008 I provided a C++98 implementation of the Singleton design pattern that is lazy-evaluated, guaranteed-destruction, not-technically-thread-safe:
Can any one provide me a sample of Singleton in c++?

Here is an updated C++11 implementation of the Singleton design pattern that is lazy-evaluated, correctly-destroyed, and thread-safe.

class S
{
    public:
        static S& getInstance()
        {
            static S    instance; // Guaranteed to be destroyed.
                                  // Instantiated on first use.
            return instance;
        }
    private:
        S() {}                    // Constructor? (the {} brackets) are needed here.

        // C++ 03
        // ========
        // Don't forget to declare these two. You want to make sure they
        // are inaccessible(especially from outside), otherwise, you may accidentally get copies of
        // your singleton appearing.
        S(S const&);              // Don't Implement
        void operator=(S const&); // Don't implement

        // C++ 11
        // =======
        // We can use the better technique of deleting the methods
        // we don't want.
    public:
        S(S const&)               = delete;
        void operator=(S const&)  = delete;

        // Note: Scott Meyers mentions in his Effective Modern
        //       C++ book, that deleted functions should generally
        //       be public as it results in better error messages
        //       due to the compilers behavior to check accessibility
        //       before deleted status
};

See this article about when to use a singleton: (not often)
Singleton: How should it be used

See this two article about initialization order and how to cope:
Static variables initialisation order
Finding C++ static initialization order problems

See this article describing lifetimes:
What is the lifetime of a static variable in a C++ function?

See this article that discusses some threading implications to singletons:
Singleton instance declared as static variable of GetInstance method, is it thread-safe?

See this article that explains why double checked locking will not work on C++:
What are all the common undefined behaviours that a C++ programmer should know about?
Dr Dobbs: C++ and The Perils of Double-Checked Locking: Part I

Related Topic