How to prevent specialization of a C++ template?

Question

The compiler doesn't complain when I do this ;-)

// Myfile.h
#include <iostream>
#include <vector>

namespace std
{

template<> class vector<int>
{
public:
    vector ()
    {
        std::cout << "Happy Halloween !!!\n";
    }
};

}

Is there any way to prevent this kind of undesirable specialization of a class/function template?

--EDIT--

I just used std:: as an example. What I'm looking for is a way to prevent this from happening to any template class.

Answer 1

No, the C++ language does not provide a general mechanism by which you can say "don't allow specializations of this template".

But it may not matter. For any instantiation that your code uses already, a user provided specialization will violate the one definition rule and their program may blow up in a fireball.

If you aren't using the instantiation in your library then what they do doesn't matter.

This is one of the cases where in C++ you simply can't prevent your user from shooting themself in the foot and if they choose to do so the responsibility is on them.

Answer 2

What you do is specialize a standard library type inside a standard namespace.

Except for a few documented customization points (std::swap, std::hash<>) or specificly constrained specializations for User Defined Types (e.g. MySmartPtr<T>) this is against the specification and the result is undefined behaviour.

---

Edit: There is no mandatory diagnostic for this kind of rule violation.

To make it marginally harder for clients of your library to mess things up, you can do this trick:

namespace Public {


    namespace Hidden { // DON'T TOUCH THESE!
        template <typename> struct MyType { };
    }

    using Hidden::MyType;

}

Now, attempting to specialize MyType<> in namespace Hidden will fail.