Re: Nested template specialization?
stephen.diverdi@gmail.com wrote:
If I have to guess, it's the word "specialisation" that confuses you.
A partial specialisation is effectively a *different* template, and
the only thing that ties them together is the name, which can be used
elsewhere by somebody who doesn't want to concern himself with how
many different "specialisations" the compiler knows about.
Please explain to me then what is the advantage of creating a partial
specialization versus creating an entirely separate template class
then?
WTF do you mean? A separate class template cannot have the same name,
so if your class template is used somewhere and referred by its name,
having a separate class template is non-sensical. So, the advantage is
that you can accomplish something with a template specialisation which
you can't accomplish with ANYTHING ELSE.
You could not use inheritance
to, e.g., implement a class (or set of classes) that mimiced the API
behavior of STL's vector.
I am not sure how this is relevant here.
I was replying to your statement in a previous post that "you can
accomplish the same thing with inheritance", which you seem to be
making again in this post. This is categorically false.
Again, I have no idea what you mean and thus I don't see any relevance.
No, but that's the purpose of the inheritance mechanism. Why have
two mechanisms that have exactly the same effect in the language?
That's what I mean by the freedom. The more mechanisms with
different effects you have, the more choices you have when trying to
accomplish your goal.
Templates provide a way to parameterize aspects your class definition,
while inheritance provides a way for objects to assume the properties
of many different related types at run time. The way templates and
inheritance differ is separate from the way partial specialization is
handled, as compared to subclassing. Even if partial specialization
of templates propogated APIs the same way inheritance does, they would
still be fundamentally different constructs and would still serve
fundamentally different purposes.
I am now not sure you understood my initial suggestion, or perhaps its
meaning has mutated in your mind since we started this debate, but it
seems that you just don't [want to] see what I was suggesting and why
I was suggesting it. Too bad.
The effect you want is attainable using inheritance. Partial
template specialisation is *not* going to help. Why do you keep
expressing the desire to use partial specialisation to do what
inheritance is designed to do?
Please propose a way create a set of vector classes using
inheritance. I would like one class for each combination of
{int,float,double} and {2,3,4}-dimensions. They should all have the
same API, though the implementations for the different dimensions will
differ (for performance reasons). I would also like compile-time
typechecking and conversion for operations among these types.
Do your own development, will you? I am not going to solve all the
problems you have, but in the example that started this discussion
you _can_ put the *common* functionality in a base class and put the
*different* functionality in each of the specialisations *without*
requiring that specialisation mechanism provides *inheritance* of
the behaviour you don't want to change.
I don't know what you're talking about, and am not going to guess.
You seem to be suggesting that people regularly use partial
I am not suggesting what "people regularly use" any C++ mechanisms
for. I can only attest to what *I* use them for. I can *suggest*
what others *might what to consider* using some C++ mechanisms for.
What everybody does in their development it's up to them.
specialization to do something along these lines:
template < int N, typename T >
class MyClass {
T vals[ N ];
T func () const;
};
template < typename T >
class MyClass< 4, T > {
T vals[ 4 ];
T different_func () const;
};
That looks like a pretty bad design to me - a user would have no
reason to expect that the set of member functions in MyClass< 4, float
would be totally different from the set in MyClass< 3, double >,
without exhaustively searching through all the headers to make sure
they've found all the possible specializations.
You're twisting my arguments and pulling your examples "by the ears"
to suit your point of view. I never suggested that a specialisation
*should* have a different interface. It is entirely up to you, the
interface designer.
What I do suggest is, if you have to have a common _interface_ in
all specialisations of your template, plus you need some different
behaviour, instead of *requesting* the language to change to suit
your needs you use the mechanism provided. Here is the example:
template<class T> class Foo {
void dosomething() {}
static std::size_t get_id() { return glb_reg(Foo); }
};
template<class T> class Foo<T*> { // partial specialisation
void dosomething() {}
static std::size_t get_id() { return ptr_reg(Foo); }
};
According to you, the partial specialisation should allow one to
omit defining 'dosomething' in the second 'Foo' template:
template<class T> class Foo {
void dosomething() {}
static std::size_t get_id() { return glb_reg(Foo); }
};
template<class T> class Foo<T*> { // partial specialisation
// void dosomething() {} "inherited"
static std::size_t get_id() { return ptr_reg(Foo); }
};
What I am saying is that it shouldn't since a solution is available
using the inheritance mechanism:
template<class T> class Foo_Base {
void dosomething() {}
};
template<class T> class Foo : Foo_Base<T> {
// void dosomething() {} inherited here
static std::size_t get_id() { return glb_reg(Foo); }
};
template<class T> class Foo<T*> : Foo_Base<T*> { // partial
specialisation
// void dosomething() {} inherited here as well
static std::size_t get_id() { return ptr_reg(Foo); }
};
Do you get it now?
V
--
Please remove capital 'A's when replying by e-mail
I do not respond to top-posted replies, please don't ask