This article describes a neat trick: http://www.gotw.ca/publications/mxc++-item-4.htm Here’s the basic idea. You first need an IsDerivedFrom class (this provides runtime and compile-time checking): template<typename D, typename B> class IsDerivedFrom { class No { }; class Yes { No no[3]; }; static Yes Test( B* ); // not defined static No Test( … ); // not … Read more
It sounds like you want to change: friend ostream& operator << (ostream& out, const Base<T>& e); To: template<class T> friend ostream& operator << (ostream& out, const Base<T>& e);
The default argument applies to the specialization — and, in fact, a specialization must accept (so to speak) the base template’s default argument(s). Attempting to specify a default in the specialization: template<class A = int, class B=double> class Base {}; template<class B=char> // … …is an error. Likewise, if we change the specialization so that … Read more
I think it is possible to specialize traits for lambdas and do pattern matching on the signature of the unnamed functor. Here is the code that works on g++ 4.5. Although it works, the pattern matching on lambda appears to be working contrary to the intuition. I’ve comments inline. struct X { float operator () … Read more
The type of both the expression y and the expression z is int. A reference appearing in an expression won’t keep reference type. Instead, the type of the expression will be the referenced type, with the expression being an lvalue. So in both cases, T is deduced to int, and thus the explicit specialization is … Read more
The default argument applies to the specialization — and, in fact, a specialization must accept (so to speak) the base template’s default argument(s). Attempting to specify a default in the specialization: template<class A = int, class B=double> class Base {}; template<class B=char> // … …is an error. Likewise, if we change the specialization so that … Read more
For static member specializations, if you don’t initialize the member, it is taken as a specialization declaration, that just says “Oh, don’t instantiate the member from the primary template, because there is a specialized definition somewhere else”. It should be mentioned that the definition should appear in a .cpp file (otherwise, you will earn the … Read more
As with simple functions you can use declaration and implementation. Put in your header declaration: template <> void TClass<int>::doSomething(std::vector<int> * v); and put implementation into one of your cpp-files: template <> void TClass<int>::doSomething(std::vector<int> * v) { // Do somtehing with a vector of int’s } Don’t forget to remove inline (I forgot and thought this … Read more
enable_if works because the substitution of a template argument resulted in an error, and so that substitution is dropped from the overload resolution set and only other viable overloads are considered by the compiler. In your example, there is no substitution occurring when instantiating the member functions because the template argument T is already known … Read more
You cannot partially specialize only a single member function, you must partially specialize the whole class. Hence you’ll need something like: template <typename T> class Object<T, 0> { private: T m_t; Object(); public: Object(T t): m_t(t) {} T Get() { return m_t; } Object& Deform() { std::cout << “Spec\n”; m_t = -1; return *this; } … Read more