Re: Template member function cast bug in VC80SP1 (and more...)
"Mycroft Holmes" wrote:
[...]
(problem 1: less important)
if we write
typedef MAP::iterator
(MAP::*pointer_to_erase_t)(MAP::iterator);
pointer_to_erase_t p = &MAP::erase
every compiler we tried (vc8, gcc4, intel10) says that
'erase' is inaccessible (in a private base), despite the
fact that the member is... public, due to the using
declaration.
actually we had a quick look in the standard, and
surprisingly, it just says 'if the member is in a private
base, the conversion (of the pointer) fails.
is this an omission?
No, it is not an omission. Using-declaration brings in a
name only for the purpose of overload resolution. The type
of the name remains the same. Here's the quote:
<quote>
7.3.3/13 The `using' declaration.
For the purpose of overload resolution, the functions which
are introduced by a `using-declaration' into a derived class
will be treated as though they were members of the derived
class. In particular, the implicit `this' parameter shall be
treated as if it were a pointer to the derived class rather
than to the base class. This has no effect on the type of
the function, and in all other respects the function remains
a member of the base class.
</quote>
So, an attemp to convert `&VECTOR::erase' to `&MAP::erase'
fall into "all other respects" category, since it requires
an access to [inaccessible] `VECTOR' base class.
(problem 2: very important)
is there some way to test if a class has ANY member/member
function named -let's say- swap?
we just need to know if the expression "&T::swap" is legal
or not.
first, we tried the following but it seems that it's
illegal:
[...]
Why do you think it's illegal? It compiles both by VC++2005
and Comeau online compiler wihtout any warning.
the following variant works well in gcc4 and intel10 (and
according to the SFINAE principle, it should work!!!)
but does not compile in vc8 (it says something like:
overloaded function, illegal sizeof operand):
template <size_t N> class yes { char dummy[2]; };
template <typename T>
static yes<sizeof(&T::swap)> test(T*);
I personally think it's an artificial limitation in VC.
There was a topic about the same problem a couple of days
ago:
"Some issues with using sizeof() in template definitions"
http://groups.google.com/group/microsoft.public.vc.language/msg/4c1dac7ab6ee73ef
I think it's a bug in VC++2005.
Alternatively, you can use `__if_exists' compiler intrinsic:
template <typename T>
bool has_something_named_swap(const T&)
{
bool b = false;
__if_exists(T::swap) { b = true };
return b;
}
However, it's VC++ specific and unportable.
(problem 3: very important)
it looks like VC8 is unable to resolve a
pointer-to-overloaded-member-function when some of the
overloads are in VECTOR and some are in MAP_BASE.
Here's a minimal sample that shows the problem: both
intel10 and gcc4 do compile it correctly.
[...]
template <typename container_t, typename iterator_t,
typename base_t>
inline void erase_gap2(container_t& c, iterator_t& i,
iterator_t (base_t::*)(iterator_t))
{
i = c.erase(i);
}
template <typename container_t, typename iterator_t,
typename base_t>
inline void erase_gap2(container_t& c, iterator_t& i, void
(base_t::*)(iterator_t))
{
c.erase(i++);
}
[Did you mean (c.*memptr)(...), where `memptr' is third
parameter?]
The error is misleading. The real problem is again
inaccessibility of `VECTOR::erase' due to private
inheritance. Comeau online reports correct error about it.
Once appropriate `MAP_BASE::erase' is available both Comeau
and VC++ compile the code without any problem.
Alex