specialization

I want to make this specialized w/o changing main. Is it possible to specialize something based on its base class? I hope so. -edit- I'll have several classes that inherit from SomeTag. I don't want to write the same specialization for each of them. class SomeTag {}; class InheritSomeTag : public SomeTag {}; template <class T, class Tag=T> struct MyClass { }; template <class T> struct MyClass<T, SomeTag> { typedef int isSpecialized; }; int main() { MyClass<SomeTag>::isSpecialized test1; //ok MyClass<InheritSomeTag>::isSpecialized test2; //how do i make this specialized w/o changing main()

Always considering that the following header, containing my templated class, is included in at least two .CPP files, this code compiles correctly: template <class T> class TClass { public: void doSomething(std::vector<T> * v); }; template <class T> void TClass<T>::doSomething(std::vector<T> * v) { // Do something with a vector of a generic T } template <> inline void TClass<int>::doSomething(std::vector<int> * v) { // Do something with a vector of int's } But note the inline in the specialization method. It is required to avoid a linker error (in VS2008 is LNK2005) due to the method being

I am trying to determine which version of a member function gets called based on the class template parameter. I have tried this: #include <iostream> #include <type_traits> template<typename T> struct Point { void MyFunction(typename std::enable_if<std::is_same<T, int>::value, T >::type* = 0) { std::cout << "T is int." << std::endl; } void MyFunction(typename std::enable_if<!std::is_same<T, int>::value, float >::type* = 0) { std::cout << "T is not int." << std::endl; } }; int main() { Point<int> intPoint; intPoint.MyFunction(); Point<float> floatPoint; floatPoint.MyFunction(); } which I

Is it possible to specialize particular members of a template class? Something like: template <typename T,bool B> struct X { void Specialized(); }; template <typename T> void X<T,true>::Specialized() { ... } template <typename T> void X<T,false>::Specialized() { ... } Ofcourse, this code isn't valid. You can only specialize it explicitly by providing all template arguments. No partial specialization for member functions of class templates is allowed. template <typename T,bool B> struct X { void Specialized(); }; // works template <> void X<int,true>::Specialized() { ... } A work around is to

This question already has an answer here: “invalid use of incomplete type” error with partial template specialization 3 answers I'm new to templates so maybe this is a trivial thing but I cannot get it to work. I'm trying to get partial specialization of a class member function. The shortest code would be: template <typename T, int nValue> class Object{ private: T m_t; Object(); public: Object(T t): m_t(t) {} T Get() { return m_t; } Object& Deform(){ m_t*=nValue; return *this; } }; template <typename T> Object<T,0>& Object<T,0>::Deform(){ this->m_t = -1; return *this; } int main(){ Object<int