专门化成员函数，但不是整个类

Question

I have a template the works with enums

template<typename T> class Enumuzaorous : public someclass<T>
{
public:
virtual ~Enumuzaorous() { } ;
virtual void do_this() { ... }
virtual void take_that() { ... }
virtual bool check_something() { return false; } 
T m_value;
}

I have many Enums that use this class and one more enum :

enum myLovelyEnum
{
today,tomorrow
}

For this enum I would like that check_something won't return false but do the following :

bool check_something() { return m_value == today; } 

I can specialize the entire class for the enum, but I would need to copy&paste the implementation of: void do_this() { ... } void take_that() { ... }

Is it possible to specialize only one member function ? I guess not.

Maybe I should Inherit and then specialize ?

What is the correct approach. Maybe I can call from the specialized do_this, take_that to the generic ones ?

Thanks.

Answer 1

Member functions of class template are themselves function templates and can be explicitly specialized:

template <>
bool Enumuzaorous<myLovelyEnum>::check_something()
{
     return m_value == today;
}

Answer 2

Another solution can be to use a traits class

template <typename T> struct DefaultEnumuzaorousTraits
{
  constexpr static bool check_something_impl(T&) { return false; }
};

template<typename T, class Traits = DefaultEnumuzaorousTraits<T>>
class Enumuzaorous : public someclass<T>
{
   // stuff omitted for brevity
   bool check_something() { return Traits::check_something_impl(m_value); }
};

struct DefaultEnumuzaorousTraits<myLovelyEnum>
{
  constexpr static bool check_something_impl(myLovelyEnum e) 
  { return e == myLovelyEnum::today; }
}