Re: Class template specialization with template parameter
On May 14, 3:28 pm, Victor Bazarov <v.Abaza...@comAcast.net> wrote:
Greg Herlihy wrote:
The answer depends on how many template parameters "std::map"
requires. The usual number is two - the two specified by the C++
Standard. An implementation however is allowed to require additional
temmplate type parameters for a std::map. So, assuming that std::map
requires only two type parameters, then the answer is "yes".
I don't think it has anything to do with the number of arguments the
template takes/has. The specialisation is not a template with a
template template argument (I believe that's what you're thinking of...)
For instance,
template<class T, class U = int> class TwoArgs {};
template<class T> struct Foo { enum {a=0}; };
template<class T> struct Foo<TwoArgs<T> > { enum {a=1}; };
int main() {
char should_complain[Foo<char>::a];
char dont_know[Foo<TwoArgs<int,char> >::a];
char should_be_OK[Foo<TwoArgs<double> >::a];
}
The declaration of 'should_complain' instantiates the regular 'Foo'
because it's not the specialisation on 'TwoArgs'. The declaration of
'should_be_OK' is the specialisation which has 'a == 1'. Now, since=
'dont_know' uses the 'Foo' instantiated for 'TwoArgs', yet the second
argument of 'TwoArgs' is not the default (int), I am not sure. The
Comeau online test drive does not like 'dont_know', most likely because
it uses the 'TwoArgs' in a way different from the specialisation's, and
as the result 'a' is 0. Tricky...
I agree with Comeau compiler that TwoArgs<int,char> will not match the
provided "TwoArgs" specialization, since "char" is not default
argument type for TwoArg<>'s second type parameter.
Anyway, as James points out a std::map actually accepts (at least)
four template type parameters. Now, since the original program
specified only two of those four type parameters, the two unspecified
type parameters assume their default type arguments.
So, if the program instantiates the Foo template with a std::map class
that was in turn instantiated with a non-default Allocator class -
then the std::map specialization will not be selected. Therefore, to
ensure that any and all std::map classes (no matter their template
type arguments) always use Foo<>'s std::map specialization, the
declaration of the Foo template must provide as many type arguments
for the std::map specialization as a std::map accepts. For example,
assuming the required four arguments, the declaration of Foo<> should
look more like this:
template<class T1, class T2, class T3, class T4>
class Foo<std::map<T1, T2, T3, T4> >
{
// ...
};
In that way, std::map's instantiated with non-default template type
arguments - will still select Foo's partial specialization for
std::maps.
Greg