How can one avoid duplicating class template specification for each member function?

Question

If I have a template class specification like so,

template <typename T>
class MyClass {
public:
    void fun1();
    // ...
    void funN();
};

template <typename T>
void MyClass<T>::fun1() {
    // definition
}

// ...

template <typename T>
void MyClass<T>::funN() {
    // definition
}

If I change the class template to something else, say I add an extra parameter:

template <typename T, typename U>
class MyClass {
    // ...
};

Then I have to change each function definition (fun1, ..., funN) to agree with the class template specification:

template <typename T, typename U>
void MyClass<T,U>::fun1() { //... }

Are there any strategies for avoiding this? Could I use macros e.g.

#define DFLT_TEMPLATE template<typename T, typename U>
#define DFLT_CLASS  class<T,U>

DFLT_TEMPLATE
void DFLT_CLASS::fun1() { // ... }

Or is this considered bad practice?

Answer 1

To me, the benefits of using a macro here are far overshadowed by the drawbacks. Yes, if you use a macro then if you ever need to add an additional template parameter, you'll only need to make a single modification. But anyone else reading your code is probably going to vomit.

I mean, are you going to do this for every template you have? Your code will become infested with ugly macros.

Answer 2

How many member functions do you have that this is an issue?

I think either they are small enough to be defined within the class template or the adaption of their algorithms to an additional template parameter would by far outweigh the replacement of those function headers.

Also, your editor ought to do this for you in no time anyway.

Answer 3

yes you could but don't forget to use "#undef DFLT_TEMPLATE" and "#undef DFLT_CLASS" at the end of file to avoid compiler warnings if your project have several templates with same macros definitions

Answer 4

Inheritation is better than macro.

If you want to change only a few functions and variables, make the specialized class inherit a common class that provides common functions/variables.