Templates and implicit conversion prevention on constructor - c++

Question

I have a templated class Foo, which is of type T. When I create an instance of T I want to ensure the constructor is passed the same type.
The compiler ensures this, except for the small detail of implicit conversion. I want to prevent these and I can't figure out if there is a good way to do so. Compiler flags are not a option here.
I'm actually trying to prevent implicit conversions from double to float as my Foo class is doing some interesting magic that blows up on said cast. Any suggestions?
template <typename T>
class Foo {
public:
explicit Foo(const T& x) {kBitCount = sizeof(T); }
size_t kBitCount;
size_t mySize(){ return kBitCount; } // Size used to demonstrate
};
int main(int argc, char *argv[])
{
short sh = 5;
Foo<int> foo_int_from_short(sh); // I want this to fail
std::cout << "size:" << foo_int_from_short.mySize() << std::endl; // prints 4
Foo<short> foo_sh((unsigned int)5); // I want this to fail
std::cout << "size:" << foo_sh.mySize() << std::endl; // Prints 2
return 0;
}
Updated with solutions, C++11 allows for compile time checks
#include <limits>
#include <typeinfo>
#if __cplusplus > 199711L // If C++11 or greater
#include <type_traits>
#endif
template <typename T>
class Foo {
public:
#if __cplusplus > 199711L
// Prevent implict type conversions at compile time
template<
typename U,
typename = typename std::enable_if< std::is_same<U, T >::value >::type
>
explicit Foo(const U& x)
{
#else
template< typename U >
explicit Foo(const U& x)
{
// Assert on implict type conversions, run time
if(typeid(U).name() != typeid(T).name())
{
std::cerr << "You're doing an implicit conversion with Foo, Don't" << std::endl;
assert(typeid(U).name() == typeid(T).name()); // Or throw
}
#endif
}

Answer 1

How about adding an extra templated constructor to gather the less specialized calls:
template <typename T>
class Foo {
public:
template<typename U>
explicit Foo(const U& x); // Undefined reference error at link time
explicit Foo(const T& x) { kBitCount = sizeof(T); }
// ...
};
If you're using C++11, you don't have to create ugly undefined external errors either -- you can just use = delete:
template<typename U>
explicit Foo(const U& x) = delete;

Answer 2

This alternative to Cameron's solution has a single constructor that fails at compile time if an incorrect type is used:
template <typename T>
class Foo {
public:
template<
typename U,
typename = typename std::enable_if<std::is_same<U, T>{}>::type
>
explicit Foo(const U& x) { ... }
};
and could be made shorter with a couple of standard aliases.