On 24 February 2006 23:42, Perry Smith wrote:
> On Feb 24, 2006, at 8:55 AM, Richard Guenther wrote:
>>> The problem is this:
>>>
>>> struct foo {
>>> int a;
>>> int b;
>>> int c;
>>> };
>>>
>>> static const int foo::*j = &foo::c; // accepted
>>>
>>> class dog {
>>> static const int foo::*k = &foo::c; // error };
It has been illegal to initialise a static class member inside the class
definition since sometime back in the early 90s. You must provide a static
instantiation elsewhere and initialise that.
>>> 5.19 (constant expressions) paragraph 2, the last item in the 1998 C+
>>> + spec says " -- a pointer to member constant expression." That
>>> appears to be defined as: '&' qualified-id (5.19 paragraph 6).
Yes, the expression is a valid initialiser for the object, but the
initialiser is in a place where it is not allowed. BTW, please remember here
that you have identified the expression as being a pointer-to-member constant
expression, because later on you forget this fact and that's where your
confusion arises...
> But '&' can occur in a constant-expression and 'foo::c' is a unique-id
> which can also appear in a constant expression (see 5.19). And as
> far as the static const data member, 9.4.2 paragraph 4 says:
This clause does not apply to /all/ static const data members...
>
> If a static data member is of const integral or const enumeration
> type,
...only ones of integral or enumeral type. And k, the static data member in
question, is a constant pointer-to-int-member-of-foo.
> its declaration in the class definition can specify a
> constant-initializer which shall be an integral constant expression
> (5.19). In that case, the member can appear in integral constant
> expressions within its scope. The member shall still be defined in
> a namespace scope if it is used in the program and the namespace
> scope definition shall not con- tain an initializer.
>
> Note that 5.19 states that '&foo::c' is an integral constant
> expression.
It is no such thing, and 5.19 says no such thing, and this is the point at
which you've forgotten that you already identified it as being a
pointer-to-member constant expression as defined under the terms of 5.19.6. A
pointer-to-member is not any kind of integer. 5.19.2 states that it can be
considered as a /constant/ expression, "only for the purpose of non-local
static object initialization". It does not say it can be considered a
/constant integral/ expression.
And even if the initialiser expression was a constant integral expression,
and we were allowed to assign it to the member, that wouldn't change the type
of the member variable itself. The type of that variable is as you defined it
in the class definition: it is "const int (foo::*)", and it's the type of the
member variable that 9.4.2 is talking about when it says whether you can or
can't initialise it in the class definition, not the type of the value with
which you initialise it - closely related though those two things generally
are, they are nonetheless distinct concepts.
> So I draw the conclusion that k is a const integral
> type (but I have not seen a place in the spec that actually says
> that a pointer to member is an integral expression but what else
> could it be?
It is a unique type of it's own, called pointer-to-member. This is a
compound type, fundamentally different to integral types (and indeed to
non-member-pointer types.)
Ah. A thought has just occurred to me. You may have the misunderstanding
that the static class member variable 'foo::k' is const. It isn't; the int to
which it points is const. You can assign it to point to any other
int-member-of-foo at any time you like (and because it points to const
I-M-O-F, it's ok to assign it to point at a non-const I-M-O-F but you won't be
allowed to modify that int through it).
Is a mixup between "const int foo::*" and "int foo::* const" perhaps the
root cause of your confusion? If I read the standard correctly it should be
ok to initialise one of the latter in the class definition in the way you are
expecting for foo::k in your example.
cheers,
DaveK
--
Can't think of a witty .sigline today....
