template-specialization

template<typename T> struct A { A<T> operator%( const T& x); }; template<typename T> A<T> A<T>::operator%( const T& x ) { ... } How can I use enable_if to make the following specialization happen for any floating point type (is_floating_point)? template<> A<float> A<float>::operator%( const float& x ) { ... } EDIT: Here's an answer I came up which is different from the ones posted below... template<typename T> struct A { T x; A( const T& _x ) : x(_x) {} template<typename Q> typename std::enable_if<std::is_same<Q, T>::value && std::is_floating_point<Q>::value, A<T> >::type operator% ( const Q&

Why is the output of this code : #include <iostream> template<typename T> void f(T param) { std::cout << "General" << std::endl ; } template<> void f(int& param) { std::cout << "int&" << std::endl ; } int main() { float x ; f (x) ; int y ; f (y) ; int& z = y ; f (z) ; } is General General General The third one is surprizing because the function was specialized exactly for int& Edit : I know that overloading might be a proper solution. I just want to learn the logic behind it. The type of both the expression y and the expression z is int . A reference appearing in an expression won't keep

Is it possible to specialize a templatized method for enums? Something like (the invalid code below): template <typename T> void f(T value); template <> void f<enum T>(T value); In the case it's not possible, then supposing I have specializations for a number of types, like int , unsigned int , long long , unsigned long long , etc, then which of the specializations an enum value will use? James McNellis You can use std::enable_if with std::is_enum from <type_traits> to accomplish this. In an answer to one of my questions , litb posted a very detailed and well-written explanation of how this

Consider the following: struct A { typedef int foo; }; struct B {}; template<class T, bool has_foo = /* ??? */> struct C {}; I want to specialize C so that C<A> gets one specialization and C<B> gets the other, based on the presence or absence of typename T::foo. Is this possible using type traits or some other template magic? The problem is that everything I've tried produces a compile error when instantiating C<B> because B::foo doesn't exist. But that's what I want to test! Edit: I think ildjarn's answer is better, but I finally came up with the following C++11 solution. Man is it hacky, but

I have a template class that I declare in a header with one method and no definition of that method in the header. In a .cc file, I define specializations of that method without ever declaring them in the header . In a different .cc file, I call the method for different template parameters for which specializations exist. It looks like this: foo.h: template<typename T> class Foo { public: static int bar(); }; foo.cc: #include "foo.h" template<> int Foo<int>::bar() { return 1; } template<> int Foo<double>::bar() { return 2; } main.cc: #include <iostream> #include "foo.h" int main(int argc, char