Re: Direct initialization or copied default ctor
Patrick Kowalzick wrote:
I need some clarification.
In 12.3.1p2 I find an example, with some interessting comments:
Z a; // OK: default-initialization performed
Z a3 = Z(1); // OK: direct-initialization syntax used
Z a2(1); // OK: direct-initialization syntax used
Z a4 = (Z)1; // OK: explicit cast used
IMO, these comments are not easy to read.
I agree. They don't always apply to the entire statement, and
it's not always clear what part they do apply to.
My reading would be:
1.) Z a; // OK: default-initialization performed
Thats just a default initialization
2.) Z a3 = Z(1); // OK: direct-initialization syntax used
Z(1) is direct-initialization syntax, but Z a3 = Z(1) would be
copy-initialization.
Exactly. This section is concerned with the effects of
explicit, and the examples are there to comment the constructors
which are declared explicit. The variable a3 is initialized
using copy-initialization -- but since the type of the
initializing expression is the same as the type of the variable,
it falls into the special case where there is no difference
between the two. (I think that the reason behind the special
wording is that otherwise, you could interpret the standard to
say that the copy constructor was called twice: once to convert
Z(1) to a Z, and the second time for copy initialization.)
3.) Z a2(1); // OK: direct-initialization syntax used
Thats just a direct initialization
4.) Z a4 = (Z)1; // OK: explicit cast used
(Z)1 is an explicit cast, but Z a4 = (Z)1 would be copy-
initialization.
So, IMO changing the comments to
Z a; // OK: default-initialization performed
Z a3 = Z(1); // OK: copy-initialization performed; direct-
initialization
syntax used
Z a2(1); // OK: direct-initialization performed
Z a4 = (Z)1; // OK: copy-initialization performed; explicit cast
used
would be a little bit clearer. Am I up a blind alley?
Not really. I think it should be made clearer that the comments
apply to the use of constructors which were declared explicit.
Thus:
Z a3 = Z(1); // OK: explicit conversion (functional syntax) used
Note that the same thing applies to:
Z* p = new Z(1); // OK: direct initialization syntax used
The comment is 1) false with regards to p, and 2) irrelevant to
the point at hand, if it applies to the initialization of p.
I think part of the problem comes from the use of the word
"syntax" here -- initialization "syntax" is part of the
declaration syntax, at least in my mind. It might be better to
dropt the word "syntax", and explicitly state what is being
initialized using direct-initialization or copy-initialization,
e.g.:
Z a3 = Z(1); // OK: direct-initialization of temporary.
Z* p = new Z(1); // OK: new uses direct-initialization.
--
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! ]