I always wondered about the following restriction
differences between explicit and partial specialisations
of member templates of class templates.

Consider the following snippets and ignore for a
while that not all of them are currently valid C++

(A) Explicit specialization of member template:

template<class T> class A1 {
  template<class U> class B1;
};

template<class T>
template<>          // ERROR!
class A1<T>::B1<float>{};

(B) Partial specialization of member template:

template<class T> class A2 {
  template<class U> class B2;
};

template<class T>
template<class U>
class A2<T>::B2<U*>{}; // OK

The rules which forbid (A) but allow (B) are
specified by

1) Explicit specialization:
14.7.3/18:

"In an explicit specialization declaration for a
member of a class template or a member template
that appears in namespace scope, the member
template and some of its enclosing class templates
may remain unspecialized, except that the
declaration shall not explicitly specialize a class
member template if its enclosing class templates
are not explicitly specialized as well.[..]"

2) Partial specialization:
14.5.4.3/2:

"If a member template of a class template is partially
specialized, the member template partial
specializations are member templates of the enclosing
class template;[..]"

-------------------------------------------------------------------

The point I want to discuss is: How come that we
have more restrictions here for explicit specializations
compared to partial specialization?
I would understand that partial specializations of
member templates of class templates are *not*
allowed, because even explicit specializations of
such beasts are *not* allowed. But why vice versa?

I always thought that partial specialization is a more
tricky issue for a compiler than explicit specialization,
simply because I compared it with a method of pattern
matching: It's quite easy to find a special character X
lets say in a string, but more complicated to find those
characters belonging to a set which fulfills special
constraints.
This pictorial explanation was my reasoning why I
accepted that now old compilers (e.g. VC6) could
easily handle an explicit specialization, but refused to
handle a partial specialization of a class template.

1) Is this estimation of complexitity differences between
explicit and partial specialization reasonable or not?
2) If reasonable: How come that the seemingly
"inverse specialization restrictions" are ruled this way in
the Standard? Do I have a wrong view on this or is this
an oversight in the specs?

According to my expectations it's very much simpler
to find a workaround for the current restriction on
explicit specializations (see e.g. my answer in the
thread http://tinyurl.com/38jnbo) than another one
for the hypothetical situation of stronger limitations of
partial specialization. Although I could view at the
current state of affairs from a positive angle, it really
looks so unreasonable (it "sucks") that I tend to think
that this is actual a defect (modulo the conclusion that
my reasoning is simply wrong).

I would appreciate any light (even a small candle ;-)
on this issue.

Thanks and Greetings from Bremen,

Daniel Kr   gler


---
[ comp.std.c++ is moderated.  To submit articles, try just posting with ]
[ your news-reader.  If that fails, use mailto:std-c++@ncar.ucar.edu    ]
[              --- Please see the FAQ before posting. ---               ]
[ FAQ: http://www.comeaucomputing.com/csc/faq.html                      ]