Re: new foo::foo() erroneous, ugly, or OK?
johnchx2@yahoo.com wrote:
Victor Bazarov wrote:
usenet@schweikhardt.net wrote:
int main (void)
{
foo *myfoo = new foo::foo();
delete myfoo;
return 0;
}
It is perfectly fine. 'foo' _class_ owns the name 'foo' as
its own type. 'foo::foo' is just as good as a *type-id* as,
for example 'foo::foo::foo::foo::foo::foo'. There should be
no error report.
I don't think this is correct. There is specific language
(5.1/7) that makes foo::foo refer to the constructor, not to
the class name.
The sure hid it. Note that this section only applies to
expressions, however: foo::foo names the constructor in an
expression, but is simply another name for foo elsewhere.
In the new draft, there's additional language that inhibits
this in the context of an elaborated type specifier, so
struct foo::foo
is a type name, even though
foo::foo
is not. See:
http://www2.open-std.org/jtc1/sc22/wg21/docs/cwg_defects.html#318
It looks like Comeau online already implements this behavior.
It also looks like the text has changed several times. But as I
understand it, the new draft actually allows the use of foo::for
in many more contexts: the new wording (according to the defect
report you cite) says that the name will only be considered a
constructor in a context where the name of a constructor would
be "an acceptable lookup result". I'm not too sure what the
quoted phrase is supposed to mean: acceptable by what criteria?
(And how can the name of a constructor ever be the result of a
lookup, given ?12.1/1 "Constructors do not have names." I don't
think we've heard the last of this.) In the initial example, for
example, a constructor is not acceptable in a new expression, so
the initial example would be legal. As I read it:
-- According the 1998 edition of the C++ standard, the initial
posting is illegal, because of 5.1/7. Anywhere outside of
an expression, however, foo::foo (or foo::foo::foo...) is a
legal synonym for foo.
-- According to TC1 (and thus C++ 2003, I think), foo::foo
always means the constructor, and things like foo::foo...
are illegal pretty much everywhere. (I'm not sure if this
holds for things like foo::foo::bar; lookup of names before
a :: follows somewhat different rules, and function names
are ignored. So... do we ignore the constructor, as a
function, or do we consider that having found the class, its
name is forced to be that of a constructor in this context.)
-- According to the latest working draft (supposing the actual
text is that of the DR you cited), the initial posting is
legal (depending a bit on the meaning of "acceptable lookup
result"---a constructor is certainly not acceptable here,
but is it unacceptable as a lookup result, or for other
reasons?). As is foo::foo::foo... Or perhaps 5.1/7 still
stands, and in an expression...
I'll admit that I'm still having trouble getting my head around
the idea that (?12.1/1) constructors do not have names, and name
lookup finds the name of a constructor.
--
James Kanze GABI Software
Conseils en informatique orient?e objet/
Beratung in objektorientierter Datenverarbeitung
9 place S?mard, 78210 St.-Cyr-l'?cole, France, +33 (0)1 30 23 00 34
[ See http://www.gotw.ca/resources/clcm.htm for info about ]
[ comp.lang.c++.moderated. First time posters: Do this! ]