templates - nontype parameters - specialization

[esrever]

Can I create a specialization of a single nontype parameter of a templated function of a non-templated class?? For example :

class A
{
...

template <int i> Handle( void * p) {}
template <> Handle<4>( void * p)
{ ... }

}

Correct me if I'm wrong with the syntax, but I've yet to find a good reference for this, and the compiler always throws at me useless template errors

[weaknessforcats]

int i is not a tyoe so you can't use it ro specialize a template. Neither is 4. SO these lines are just wrong:

template <int i> Handle( void * p) {}
template <> Handle<4>( void * p)
{ ... }

plus there is no object name.

Your class A has a Handle as a member. If it is a Handle<int>, then say so:

class A
{
    Handle<int> v1;
};
 

If the Handle has a constructor, it will be called when an object of A is created. That will require a constructor on A to call the constructor on the Handle.

LIke this:

class Handle
{
   public:
      Handle(void*) {}
 
};
 
class A
{
//...
    void* p;
public:
    A() : v1(p) {}
 
Handle<int>  v1;
 
};
int main()
{
 
    A obj;
 
}
 

Finally, if this handle is for what I think it is, then there is one already set uop for you in the C/C++ HowTos in an article about Handle classes. Just copy out the template and off you go.

[esrever]

Thanks for your reply, but I think you totally misunderstood me. Handle is a member function of A, while the templated parameter I need it to be a non-type parameter. All the examples I've seen so far,have also a type, like the usual :

template <class T, int Size = 100>
class Stack
{
...
}

But I wanted to ask :

Can I have a *sigle non-type* parameter in a *member function* of a *non-templated* class, *and* to be able to specialize it by overloading the nontype parameter?? I want alpha.Handle<1>(data) to do sth with the data, while alpha.Handle<2>(data) to do sth different with the data.

Also I'm worried a bit for my overloading syntax, since I've not seen any example about this.

[weaknessforcats]

A far as I know, you have to specify a type. The only time you can use soemthing like Handle<1> or Handle<2> is when Handle is a class template and the 1 and 2 are specifed as long or size_t. Like you showed wioth your Stack example.

[esrever]

Oh well I have to compromise then. :( Thanks again!

[fual]

I think that you can do this, presumably you need a pretty new compiler (works on gcc 4.1.2), but the syntax is a little unexpected: http://publib.boulder.ibm.com/infoce...ialization.htm

Take a look at the very bottom of the page, the section entitled "Explicit specialization of members of class templates" The member function needs to be specialised OUTSIDE of the class definition, so your code becomes:

class A
{
template <int i> void Handle( void * p) { }
};
 
template <> void A::Handle<4>( void * p){ }
 
 

[weaknessforcats]

"Explicit specialization of members of class templates" The member function needs to be specialised OUTSIDE of the class definition, so your code becomes:

Please read up on bound vs unbound template specializations.

[fual]

Please read up on bound vs unbound template specializations.

Perhaps you have a good link and could summarise? Are you just talking about this: http://www.glenmccl.com/tip_027.htm