works on old cpp standard.

Author: xhawk18

include/singleton-cpp/singleton.h

@@ -2,6 +2,7 @@
 #ifndef INC_SINGLETON_H_
 #define INC_SINGLETON_H_
 
+#include <cstdlib>
 #include <mutex>
 #include <typeindex>
 #include <memory>
@@ -44,15 +45,15 @@ class Singleton {
 private:
     // Get the single instance
     static T *getInstancePrivate() {
-        static T *instance = nullptr;
-        if (instance != nullptr)
+        static T *instance = NULL;
+        if (instance != NULL)
             return instance;
 
-        SingleTonHolder *singleTonHolder = nullptr;
+        SingleTonHolder *singleTonHolder = NULL;
         {
             // Locks and get the global mutex
             std::lock_guard<std::mutex> myLock(getSingleTonMutex());
-            if (instance != nullptr)
+            if (instance != NULL)
                 return instance;
 
             singleTonHolder = getSingleTonType(std::type_index(typeid(T)));
@@ -72,7 +73,7 @@ class Singleton {
     static T *createInstanceFromHolder(SingleTonHolder *singleTonHolder) {
         // Locks class T and make sure to call construction only once
         std::lock_guard<std::mutex> myLock(*singleTonHolder->mutex_);
-        if (singleTonHolder->object_ == nullptr) {
+        if (singleTonHolder->object_ == NULL) {
             // construct the instance with static funciton
             singleTonHolder->object_ = reinterpret_cast<void *>(getStaticInstance());
         }

src/singleton.cpp

@@ -15,15 +15,19 @@ SINGLETON_API SingleTonHolder *getSingleTonType(const std::type_index &typeIndex
     static std::unordered_map<std::type_index, SingleTonHolder> s_singleObjects;
 
     // Check the old value
-    auto itr = s_singleObjects.find(typeIndex);
+    std::unordered_map<std::type_index, SingleTonHolder>::iterator itr = s_singleObjects.find(typeIndex);
     if (itr != s_singleObjects.end())
         return &itr->second;
 
     // Create new one if no old value
-    std::pair<std::type_index, SingleTonHolder> singleHolder {
+    std::pair<std::type_index, SingleTonHolder> singleHolder( 
         typeIndex,
-        SingleTonHolder{nullptr, std::shared_ptr<std::mutex>(new std::mutex())}
-    };
+        SingleTonHolder()
+    );
     itr = s_singleObjects.insert(singleHolder).first;
-    return &itr->second;
+    SingleTonHolder &singleTonHolder = itr->second;
+    singleTonHolder.object_ = NULL;
+    singleTonHolder.mutex_ = std::shared_ptr<std::mutex>(new std::mutex());
+
+    return &singleTonHolder;
 }