Why export templates would be useful

  Many people argue that there is *no* advantage in using export
templates other than the questionable advantage of being able to
separate the declaration from the implementation (which these people
seem to argue is only a purely cosmetic feature).

  However, I have *never* seen discussed the absolutely *major*
advantage of export templates: That they have their own compilation
unit, which means that they have access to their own file-local scope
(which in turn can be used to increase the modularity of the program).
This is something which is just not possible with regular templates.

  For that reason I have argued that template classes and functions
are actually *inferior* to regular classes and functions because the
former cannot have file-local scope while the latter can. Export
templates would solve this deficiency.

  I have been thinking about what would be the simplest example which
is implementable with export templates and which isn't with regular
templates (at least not without global namespace contamination). How
about this:

//---------------------------------------------------
// MyClass.hh
export template<typename T>
class MyClass
{
 public:
    MyClass();
    // other member functions here...
};
//---------------------------------------------------

//---------------------------------------------------
// MyClass.cc
namespace
{
    unsigned constructorCallCounter = 0;
}

template<typename T>
MyClass<T>::MyClass()
{
    ++constructorCallCounter;
}
//---------------------------------------------------

  You *could* achieve the same effect with regular templates, but
it would require adding a new name to global scope (accessible from
anywhere). This may not be a very viable solution if the amount of
stuff inside the nameless namespace above is large, nor is it very
good design.

  (And no, making 'constructorCallCounter' a static member of
MyClass is *not* the same thing because it would mean that every
distinct template instantiation would have its own separate
'constructorCallCounter', rather than it being shared among all
of them.)

  Can anyone come up with some objections to the example above?
(Note that the example is not intended to be an example of actual
usage, but instead the simplest possible example that demonstrates
the issue.)