469,117 Members | 1,347 Online
Bytes | Developer Community
New Post

Home Posts Topics Members FAQ

Post your question to a community of 469,117 developers. It's quick & easy.

Partial Implementation of templates

Hi,

I would like to specify behavior of a class member relatively to
template implemetation. It works in usual cases but it seems to fail
with to templates when one of the two is specified...

Exemple:

template <class T, int Num>
class A
{
void foo ();
}

// The generic implementation is:
template <class T, int Num>
void
A<T,Num>
::foo ()
{
// generic code
}

// I would like to add a specific code when Num equals 2 fior
instance:
template <class T>
void
A<T,2>
::foo()
{
// an other code...
}

// But g++ 3.2.3 (on Redhat Fedora 5) does not like it
Is there any solution, knowing that a complete non-genric code is
possible (i.e. defined a void A<int,2>::foo() directly)?

Any help is appreciated.
Greg

Aug 16 '07 #1
9 1636
On 16 Srp, 11:53, Greg <Gregoire.M.Merc...@gmail.comwrote:
Hi,

I would like to specify behavior of a class member relatively to
template implemetation. It works in usual cases but it seems to fail
with to templates when one of the two is specified...

Exemple:

template <class T, int Num>
class A
{
void foo ();

}

// The generic implementation is:
template <class T, int Num>
void
A<T,Num>
::foo ()
{
// generic code

}

// I would like to add a specific code when Num equals 2 fior
instance:
template <class T>
void
A<T,2>
::foo()
{
// an other code...

}

// But g++ 3.2.3 (on Redhat Fedora 5) does not like it
Is there any solution, knowing that a complete non-genric code is
possible (i.e. defined a void A<int,2>::foo() directly)?

Any help is appreciated.
Greg
Partial specialization works only for classes/structs:

template <class T, int Num>
class A
{
void foo ()
{
// generic code

}

}

template <class T>
class A<T, 2>
{
void foo ()
{
// specialized code

}

}

Aug 16 '07 #2
Hi!

Ondra Holub schrieb:
Partial specialization works only for classes/structs:
And for non-member functions and template functions of non-template
classes. Right?

They just don't work for partially specializing a templated member
function of a class template. Right?

Is there a link to read up on this issue?

Frank
Aug 16 '07 #3
On 16 Srp, 14:00, Frank Birbacher <bloodymir.c...@gmx.netwrote:
Hi!

Ondra Holub schrieb:
Partial specialization works only for classes/structs:

And for non-member functions and template functions of non-template
classes. Right?
I think it works only for classes (and structs, what is the same with
different default access type). You can as workaround create class
with static method and use partial specialization of this class.

AFAIK partial specialization of functions is considered in prepared
standard, but I am not sure.

Aug 16 '07 #4
Hi!

Ondra Holub schrieb:
AFAIK partial specialization of functions is considered in prepared
standard, but I am not sure.
No. The following already works (not with MSVC prior to 7.1, though):

//generic
template<typename T>
void process(T t) {}

//partial specialization
template<typename T>
void process(T* const t) {}

//full specialization
template<>
void process(void* const t) { throw "what is it?"; }

int main()
{
int i = 8;
process(i);
process(&i);
process( static_cast<void*>(&i) );
}

Frank
Aug 16 '07 #5
joe
This also seems to work in VC8 anyway and has the advantage of not
having to reimplement the whole of class A:

#include <iostream>

template <class T, int Num>
class A
{
public:
void foo()
{
foo_impl<Num>();
}

private:

template <int N>
void foo_impl()
{
std::cout << "Default Foo" << std::endl;
}
template <>
void foo_impl<2>()
{
std::cout << "Special Foo" << std::endl;
}
};
int main()
{
A<int, 0a0;
A<int, 2a2;

a0.foo();
a2.foo();
}

Hope that helps in some way.

joe

Aug 16 '07 #6
On 16 Srp, 14:48, Frank Birbacher <bloodymir.c...@gmx.netwrote:
Hi!

Ondra Holub schrieb:
AFAIK partial specialization of functions is considered in prepared
standard, but I am not sure.

No. The following already works (not with MSVC prior to 7.1, though):

//generic
template<typename T>
void process(T t) {}

//partial specialization
template<typename T>
void process(T* const t) {}

//full specialization
template<>
void process(void* const t) { throw "what is it?"; }

int main()
{
int i = 8;
process(i);
process(&i);
process( static_cast<void*>(&i) );

}

Frank
Yes. it works. But it is full specialization, not partial
specialization. Try following:

template<typename T, int N>
void Func()
{
}

template<typename T>
void Func<T, 10>()
{
}

On gcc you'll get error: partial specialization `Func<T, 10>' of
function template, on Visual C++ .net 2003 you'll get error C2768:
'Func' : illegal use of explicit template arguments (the same on
Visual C++ 2005).

Aug 16 '07 #7
>
Hi!
Ondra Holub schrieb:
AFAIK partial specialization of functions is considered in prepared
standard, but I am not sure.
No. The following already works (not with MSVC prior to 7.1, though):
//generic
template<typename T>
void process(T t) {}
//partial specialization
template<typename T>
void process(T* const t) {}
//full specialization
template<>
void process(void* const t) { throw "what is it?"; }
int main()
{
int i = 8;
process(i);
process(&i);
process( static_cast<void*>(&i) );
}
Frank

Yes. it works. But it is full specialization, not partial
specialization. Try following:
No it's just a overloaded template function.the last one is a full
specialization though

Aug 16 '07 #8
Hi!

Ondra Holub schrieb:
On 16 Srp, 14:48, Frank Birbacher <bloodymir.c...@gmx.netwrote:
> //generic
template<typename T>
void process(T t) {}

//partial specialization
template<typename T>
void process(T* const t) {}
Is the above really a "full specialization"? o_O
Yes. it works. But it is full specialization, not partial
specialization. Try following:

template<typename T, int N>
void Func()
{
}

template<typename T>
void Func<T, 10>()
{
}
-.- ok, fails. But why? I don't understand this restriction, especially
because classes can be partially specialized.

Frank
Aug 16 '07 #9
On 16 Srp, 16:04, Frank Birbacher <bloodymir.c...@gmx.netwrote:
Hi!

Ondra Holub schrieb:
On 16 Srp, 14:48, Frank Birbacher <bloodymir.c...@gmx.netwrote:
//generic
template<typename T>
void process(T t) {}
//partial specialization
template<typename T>
void process(T* const t) {}

Is the above really a "full specialization"? o_O
Well, you're right, I missed this one in the middle :-)
>
Yes. it works. But it is full specialization, not partial
specialization. Try following:
template<typename T, int N>
void Func()
{
}
template<typename T>
void Func<T, 10>()
{
}

-.- ok, fails. But why? I don't understand this restriction, especially
because classes can be partially specialized.

Frank
I do not understand it too, but this is current situation :-( I
usually use workaround with static class member which works, although
it looks not as good as simple function:

template<typename T, int N>
class X
{
static void Func() { }
};

template<typename T>
class X<T, 10>
{
void Func<T, 10>() { }
};

Maybe we'll have to wait for a new standard... And then it will depend
on supplier of our compiler :-)

Aug 16 '07 #10

This discussion thread is closed

Replies have been disabled for this discussion.

Similar topics

17 posts views Thread by Paul MG | last post: by
7 posts views Thread by Lionel B | last post: by
9 posts views Thread by Gomaw Beoyr | last post: by
4 posts views Thread by wakun | last post: by
6 posts views Thread by wkaras | last post: by
1 post views Thread by CARIGAR | last post: by
reply views Thread by zhoujie | last post: by
By using this site, you agree to our Privacy Policy and Terms of Use.