Re: enum in template memfun in class template - valid C++?
On Apr 17, 4:56 pm, Daveed <vandevoo...@gmail.com> wrote:
On Apr 16, 6:46 pm, Greg Herlihy <gre...@pacbell.net> wrote:
On 4/16/07 6:49 AM, in article
1176719276.514814.262...@n76g2000hsh.googlegroups.com,
"numerical.simulat...@web.de" <numerical.simulat...@web.de> wrote:
enum Outer { a, b };
template <class T>
class C
{
public:
enum Inner { c, d };
template<Inner I, int dummy> struct Dispatcher;
template<int dummy> struct Dispatcher<c, dummy>
{
static const Outer Show = a;
};
template<int dummy> struct Dispatcher<d, dummy>
{
static const Outer Show = b;
};
public:
template <Inner I> void DoSomething(int j)
{
typedef Dispatcher<I, 1> dispatcher_t;
static const Outer o = dispatcher_t::Show;
}
};
int main()
{
C<double> Test;
Test.DoSomething<C<double>::c>(1);
}
I have 4 questions:
- Is this code valid C++ and why?
No, the above code is not a valid C++ program. Essentially, a mistake in
how
each Dispatcher member template partial specializations is declared -
means
that neither one is instantiated as intended. So when the compiler looks
for
dispatcher_t::Show inside the C<T>::DoSomething() member function
template,
it tries to instantiate the (not defined) Dispatcher general template
instead of one of its partial specializations.
That may (or may not) be what is happening with the compilers that are
refusing the code, but that is not the behavior mandated by the
standard.
The Standard mandates no behavior because it is completely silent on
the question whether nested enumerated values are value-dependent or
not. Moreover the C++ working group has not reached any consensus on
this question. See:
http://www.open-std.org/jtc1/sc22/wg21/docs/cwg_active.html#502
The EDG compiler assumes that locally-declared enumerated values are
not value-dependent, whereas gcc takes the more conservative approach
that they are value dependent.
At any rate, qualifying the names satisfies both points of view
(despite claims to the contrary - both gcc 3.3 and 4.0.1 readily
compile the original program once the enumerated values are
appropriately qualified.). That solution leaves only the Microsoft
compiler unable to compile the original program. Since Microsoft
compiler (erroneously) rejects the qualified names as being dependent
on the current (inner) template instead of the enclosing template -
the only apparent workaround is to eliminate the value-dependency by
replacing the enums with nontype int parameters.
- If not, could you explain the reason or point to TRs and wordings
for this?
The reason is quite straightforward - and should be readily apparent to
any
C++ programmer after no more than a few hours of intense scrutiny :-).
The problem is that Dispatcher's "Inner" enum nontype parameter is
dependent
on the name of the enclosing C template class - which means that Inner's
enumerated values (c and d) are dependent on the enclosing C template
class
as well. Yet "c" and "d" as they appear in the Dispatcher partial
specialization does not use a type-dependent syntax - so the compiler
assumes that both are nondependent names of incomplete types.
No, names declared in a class template scope are nondependent within
the strict scope (they may become dependent in derived templates).
See e.g. the concepts of "current instantiation" and "unknown
specialization" in 14.6.2.1. In this example, c and d are members of
The names "c" and "d" as they appear in the partial specialization
should qualify as members of an "unknown specialization" since there
is no way of for the definition of a partial specialization to
determine the specialization of its enclosing template - in this case
- the C class template.
Greg
--
[ See http://www.gotw.ca/resources/clcm.htm for info about ]
[ comp.lang.c++.moderated. First time posters: Do this! ]