Re: Template conversion and default copy constructor
Jiang wrote:
James Kanze wrote:
Jiang wrote:
All the compilers I tested produced from the following
code executables that printed "2". Shouldn't the
implicitly defined copy constructor be called?
Yes, template constructor is constructor, but it will
never be used as copy constructor, since we need
consistent copy semantics in every TUs.
Correct, but the key to understanding what is occuring here
is to realize that there is no "copying", in the sense of
the standard. So normal function overloading takes place,
and the instantiation of the template is a better match.
(But I'll admit that I had to reread the relevant passages
in the standard several times myself before I came to this
conclusion. Overload resolution is all to often a guessing
game, in which you try to guess what the compiler will do
this time.)
I reread 8.5 and your previous posts and I must say this is
maybe the source of the inconsistent behaviors.
The source of the inconsistent behaviors is probably simply that
even the best compiler writers can't think of everything,
everywhere.
However, even we stay in the above context, for OP's example,
will the compiler generated default copy constructor be
applicable or not? It seems that some compilers just do not
generate the default copy constructor and the template one is
the only choice, or the overload resolution is wrong.
I've seen no evidence of this. I suspect that all of the
compilers probably generate the default copy constructor. I
suspect, equally, that most of them get the overload resolution
right when they apply it (but this may not be the case with some
older compilers). I suspect that the difference is whether the
compiler treats the case in question as a "copy" or not.
[...]
One of the subtilities of operator overloading and template
type deduction. Template type deduction generates the
constructor Test::Test(Test&) in the original code, which is
a better match than the default Test::Test(Test const&).
With the above modification, it generates Test::Test(Test
const&), which is an equal match with the compiler generated
default (which is always present), and in case of an
otherwise equal match, the non template compiler generated
default gets the nod.
It is true. However it seems that the above reasoning does not
describe what is happened here exactly.
To prove it, I changed the OP's example to following one. (I
need such change, because I am not sure whether default copy
constructor for built-in types have parameter of "T const &"
or not, I will start a new thread for this issue.)
The signature of the compiler generated copy constructor here
will be Test( Test const& ). But you're right that ?12.8/5
could express it clearer. But I don't think that there's any
question about it. The signature will be Test( Test const& )
unless at least one base class or member of class type has a
copy constructor whose signature does not take the const.
Basically, if you consider the two bullets in ?12.8/5, there are
no direct or virtual base classes, so all of the direct or
virtual base classes have the required copy constructor, and
there are no members of class type, so all of the members of
class type have the required copy constructor.
Obviously, this would be a lot clearer if the authors' of this
passage had used the more usual form of expression, using
"unless" instead of if, and something along the lines of "there
existes ... which doesn't have...". But in formal logic, if
there are no X, then all X have property Y. For all possible
property Y, of course.
[example]
$ cat test.cpp
#include <iostream>
class Test{
public:
Test(){}
template <typename T> Test(T& test){
std::cout<< "template non-const param\n";
}
};
int main(int argc, char* argv[])
{
Test t1;
Test t2(t1);
}
$ como --A test.cpp
Comeau C/C++ 4.3.3 (Jan 13 2004 11:29:09) for MS_WINDOWS_x86
Copyright 1988-2003 Comeau Computing. All rights reserved.
MODE:strict errors C++
$ ./aout
template non-const param
[end example]
Here, I removed the member "data", and according to 12.8/p5,
the compiler will generate the default constructor using the
following form (non-const version):
Test::Test(Test &);
Not at all. Try this simple test:
class Test { } ;
int
main()
{
Test const t1 ;
Test t2( t1 ) ;
}
The only possible constructor the compiler could use here is the
compiler generated copy constructor. And unless its signature
is: Test::Test( Test const& ), the code won't compile. (And I'd
be very surprised if you find a compiler where it doesn't
compile.)
I can not understand the output of the program, because:
1. If this copy constructor is really generated by the
compiler, then for sure it will win in the overload
resolution, and the program should log nothing,
instead of the above message.
2. If there is just no such a copy constructor, then
the something must be wrong, because the standard
says a template constructor is never a copy
constructor and the presence of such a template
does not suppress the implicit declaration of a
copy constructor.
Did I miss anything important?
That the signature of the compiler generated copy constructor is
Test( Test const&) here, and that as in the initial case,
overload resolution choses the template.
--
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! ]