Allow DLLs to access a Singleton

Hi,

Currently I have a main application that loads DLLs. The main application
has a factory, that is a singleton. How do I allow the DLLs to access that
singleton?

I have made the singleton pretty basic for brevity, and MyClass is not much
of a factory, but it illustrates the problem.

Currently I have something like:

Test.hpp:
----
#include <iostream>

class MyClass {
   int val_;
public:
   MyClass() : val_(0) {
      std::cout << "MyClass()" << std::endl;
   }
   void value(int val) { val_ = val; }
   int value() { return val_; }
};

template<class T>
class Singleton {
private:
   static T* t_;
   Singleton();
public:
   static T& Instance() {
      if (!t_) {
         t_ = new T;
      }
      return *t_;
   }
};

typedef Singleton<MyClass> MySingleton;

Test.cpp
----
#include "test.hpp"

template<class T>
T* Singleton<T>::t_ = 0;

TestDll.cpp
----
#include "..\test\test.hpp"
//#include <windows.h>
_declspec(dllexport) void Register(MySingleton& mine) {
mine.Instance().value(9);
}

Main.cpp
----
#include "test.cpp"
#include <iostream>
#include <windows.h>

int main() {
   MyClass& mine = MySingleton::Instance();
   std::cout << mine.value();
   mine.value(5);
   std::cout << mine.value();
   typedef void(*FunctionRegister)(MySingleton&);

   HMODULE mod = LoadLibrary("TestDll.dll");
   if (!mod) {
      std::cout << "Libray Failed to Load" << std::endl;
      return 1;
   }
   FunctionRegister reg = (FunctionRegister)GetProcAddress(mod, "Register");
   if (!reg) {
      std::cout << "Failed to Find Function \"Register\"" << std::endl;
      return 2;
   }
   reg(/* what goes here? */);
}

Since MyClass is never instantiated, I can't really pass them around. I
need for the DLL to know about the Singleton in the main application without
creating it's own instance, completely defeating the point. At the moment,
the static MyClass* is an unresolved external for the DLL.

Thanks for any pointers (pun not intended)!

Ben Pope
--
I'm not just a number. To many, I'm known as a string...