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.