code duplication in template specialization

[Christof Warlich]

Hi,

I just need a specialization for only one member function of a template
class with _many_ members. Do I really have to duplicate the source code
for all the members, i.e. for those that do not need to be specialized?

E.g. in the example below, I'd like to avoid to redefine member B::g():

#include <stdio.h>
template<int x, typename T, short yclass B {
public:
void f(void) {printf("generi c f()\n");}
void g(void) {printf("generi c g()\n");}
};
// specialization for T == float
template<int x, short yclass B<x, float, y{
public:
void f(void) {printf("specia lized f()\n");}
void g(void) {printf("generi c g()\n");}
};
int main(void) {
B<1, int, 2b;
b.f();
b.g();
B<1, float, 2s;
s.f();
s.g();
}

Thanks for any suggestions,

Christof

[Victor Bazarov]

Christof Warlich wrote:

Hi,

I just need a specialization for only one member function of a
template class with _many_ members. Do I really have to duplicate the
source code for all the members, i.e. for those that do not need to
be specialized?
E.g. in the example below, I'd like to avoid to redefine member
B::g():
#include <stdio.h>
template<int x, typename T, short yclass B {
public:
void f(void) {printf("generi c f()\n");}
void g(void) {printf("generi c g()\n");}
};
// specialization for T == float
template<int x, short yclass B<x, float, y{
public:
void f(void) {printf("specia lized f()\n");}
void g(void) {printf("generi c g()\n");}
};
int main(void) {
B<1, int, 2b;
b.f();
b.g();
B<1, float, 2s;
s.f();
s.g();
}

Since you're defining a partial specialisation, you cannot avoid
completely redefining the contents of the class template. You can
split the original template in two and only redefine the class
that contains the member you need ot specialise:

#include <stdio.h>
template<typena me Tstruct Bf {
void f() {printf("generi c f()\n");}
};

template<int x, typename T, short yclass B : public Bf<T{
public:
void g() {printf("generi c g()\n");}
};

// specialization for T == float, but of 'Bf', not 'B'
template<struct Bf<float{
void f() {printf("specia lized f()\n");}
};

int main() {
B<1, int, 2b;
b.f();
b.g();
B<1, float, 2s;
s.f();
s.g();
}

Or you could simply define B<float>::f, and not specialise it:

// replace the Bf<floatspecial isation with
template<void Bf<float>::f() {printf("specia lized f()\n");}

since it's now a _full_ specialisation. ..

(and do drop the habit of putting 'void' inside parentheses, it's
a leftover from C, and isn't needed in C++).

V
--
Please remove capital 'A's when replying by e-mail
I do not respond to top-posted replies, please don't ask

[Alan Woodland]

Christof Warlich wrote:

Hi,

I just need a specialization for only one member function of a template
class with _many_ members. Do I really have to duplicate the source code
for all the members, i.e. for those that do not need to be specialized?

E.g. in the example below, I'd like to avoid to redefine member B::g():

#include <stdio.h>

I'd use cstdio instead of stdio.h. Actually, I'd use iostreams instead
of printf, but...

template<int x, typename T, short yclass B {
public:
void f(void) {printf("generi c f()\n");}
void g(void) {printf("generi c g()\n");}
};
// specialization for T == float
template<int x, short yclass B<x, float, y{
public:
void f(void) {printf("specia lized f()\n");}
void g(void) {printf("generi c g()\n");}
};

I'd use inheritance to work around this I think:

//is saying short legal here? I'm not sure...
template <int x, typename T, short yclass Base {
public:
void g() { printf("generic g()\n"); }
};

template <int x, typename T, short yclass B : public Base<x,T,y{
public:
void f() {printf("generi c f()\n");}
};

template <int x, short yclass B<x, float, y: public Base<x, float, y{
public:
void f() {printf("specia lized f()\n");}
};

Quite where you choose to specialise, and where you chose to inherit
depends a bit on the actual problem in hand though obviously.

int main(void) {
B<1, int, 2b;
b.f();
b.g();
B<1, float, 2s;
s.f();
s.g();
}

Alan

[Christof Warlich]

thanks to all, yes, amazingly easy, inheritance does the trick ....
It's obviously been too late for me today already ;-)