Static member variable in template, with multiple dlls

Question

My code is built to multiple .dll files, and I have a template class that has a static member variable.

I want the same instance of this static member variable to be

Answer 1

There appears to be a way to do this with fewer limitations for the code that uses the template class.

Make the static member a pointer. Create a global map which has fixed known type and can be exported from the DLL. The map uses the typeid() of the class as key and the address of the "global variable per class" as value. Initialise the static member through a function that tests whether the class already exists in the map and if so forces the second version of the class (in the second DLL) to point to the static variable of the first version of the class.

In this way every DLL has a distinct static object, but every DLL also has a pointer and all the pointers point to the same one of the static objects.

Here's some pseudo-code, assuming the static's type is the same as the template parameter (but should be easily adapted for other cases).

map<string,void*> dllexport the_map;  // instantiate this once in a single DLL

T *set_the_global(T *candidate) {
  map<string,void*>::iterator r = the_map.find(string(typeid(the_class<T>).name()));
  if(r == the_map.end()) {
    the_map[string(typeid(the_class<T>).name())] = (void*)candidate;
    return candidate;  // new class: use it as global storage location
  } else {
    return (T*)(r->second);  // class already has global storage location
  }
}

template <class T> class the_class {
  virtual void something();  // so RTTI exists
  static T *the_global;  // use this! always points to the same object
  static T one_per_dll;  // only used in initialisation
};
template<class T> the_class<T>::one_per_dll;
template<class T> the_class<T>::the_global = set_the_global(&the_class<T>::one_per_dll)

Answer 2

There are two fixes for this problem which I can see.

First is that you use another class, one that is not a template, to hold this static value - or make it a global? - and export that out of the dll.

The other is slightly mor complicated in that you instantiate the template in the code and export that instantiated templated value(s). So to give an example say I had a special kind of linked list templated class and needed to have a static value shared across the DLL's. I wrote the code to be templated but it is only really used for some small number of types. I would instantiate the classes as such:

template <class T> class Foo;
template<> class Foo<int> {};

Then you could export the static variables contained within.

__declspec(dllexport) int Foo<int>::StaticMember = 0;

(Or something like that, I'm a bit rusty with doing dll export/import.)

Though the real question is why would you want to do this, as technically a DLL can be used across processes with only one copy stored in memory. Do you really want there to only be one version of the static for all processes, or one per process?

Answer 3

The problem is that each different template instantiation is a different type with its own static variable that is not shared with other instances that have different template parameters. You could provide a non-template base class that contains the static variable.

Answer 4

There exists the following solution, as well:

• in the library: explicitly instantiate some template specialization and share them with dllexport
• in the main program:
  • if the specialization is available it will be used from the library
  • if the specialization is not available it is compiled in the main program

The desciption in detail how you can do this:

Anteru's blog Explicit template instantiation

Answer 5

Prior to extern template instantiations being accepted into the draft standard it appears Microsoft implemented an extension for the VC++ compiler.

The VC++ compiler will generate a warning if the non-standard extension is used; VS.NET (2003) and above refer to this warning description for details. This warning is also listed against VS 6.0.

I personally have never attempted to use this extension so I'm unable to vouch for this suggestion. Obviously I'm restricting this answer to Microsoft Visual Studio (I saw a comment from you regarding Unix) but I post in the hope that it may prove useful.

Answer 6

Create template specialization and then export the static members of the specialization.