Re: Assignment operator=/copy constructor/temporaries, BROKEN!
On Sep 21, 8:41 am, Bart van Ingen Schenau <b...@ingen.ddns.info>
wrote:
On Sep 17, 8:32 pm, Fabrizio J Bonsignore <synto...@gmail.com> wrote:
I want this to be compilable and working AS IS:
Sorry, but you are out of luck here. The C++ language does not allow
it.
Yeah, but a compiler is not the language nor viceversa.
The const-qualification may be optional to be able to create a well-
formed copy-constructor, but that does not mean the const is optional
for all usage patterns of the copy-constructor.
When the source of the copy is a temporary (such as the return value
from a function call), then the const-qualification is most definitely
NOT optional.
It sounds like lazy compiling. const means a contract between the
class designer and its users that X object in the language will not
change its state by a call and/or will not generate side effects. The
way you justify it it means that const has the additional meaning of
remembering the compiler that such objects memory must not be garbaged
away in the middle of the current function call! It does seem like an
onerous way to control a _possible_ optimization _flag_. Unfortunately
asking for no optimizations did not send the error away. In my
problematic implementation const declarations right away flagged
method 'bool HasMsg()' as needing const to compile too in one
compilation. It is a simple inline boolean logic method deciding on
the contents of an anonymous union, but I still remember the 'cannot
call const X method on non const object' error popping everywhere
once...
class AO
{
public:
int i;
void Aha();// {i=1;}
AO &operator=(AO &x);// {i=x.i; return *this;}//should not matter if
inline or not
AO();// : i(0) {}
AO(AO &x);// {i=x.i;}
virtual ~AO();// {}
};
(snip)
class BO
{
AO a;
public:
AO Retit();// {++a.i; return a;}
AO Retut();// {AO z; z.i = 10; return z;}
BO();
};
BO::BO() {
AO b;
b = a;
This statement is typical, assigning to a new object from a member and
viceversa within a call. b and a are defined in different scopes. It
hides this temporary-copy constructor problem if you use this idiom
exclusively.
Is your compiler choosing AO::AO(AO &) or AO::AO(const AO &) here? See
below.
(snip)
AO p = n;
AO q = o;
AO f;
AO g = Retut();
Error: No suitable constructor for constructing m from a temporary.
Available, but rejected constructors are:
A0::A0(void)
A0::A0(A0&)
Minimal required, but missing constructor is 'A0::A0(const A0&)'
Another compiler. I got differential error messages whether the
returned object was an in-function temporary or a member object!
Minimal required, but missing constructor is 'A0::A0(const A0&)'
Does it mean it requires all three constructors to be present? In my
case, omitting the assignment operator= and const in the copy
constructor fails statements:
AO m = Retit(); //no matching function for call to `AO::AO(AO)'
AO o( Retit() ); //returns a class member
AO f;
f = Retit();
but accepts
AO g = Retut();//!!! returns a temporary built in the stack
It seems that g++ takes member 'AO a' as being inherently const! So AO
g = Retut() takes AO::AO(AO &) as if it was AO::AO(AO const &);
because 'a' is const-ant and will not go away in the middle of the
computation. But f = Retit() where an in-function temporary is
returned failed. This seems to be related to the other failed
compilation where
AO g = Retut();
FAILS, but then
AO j = g;
passes! This statement should fail with a message like 'no variable g
defined' or similar, but it _temporarily_ accepts g as being well
built! This can be explained if the schizophrenic compiler managed to
build g with given constructors, then complains because it could not
build g with a _preferred_ constructor somebody told it should be The
Option, then finds the object built and uses it, then... Does GNU have
a regression tool? Something that would save together code and
compilation results automatically? Like in, for every Compile & Run
call the tool saves the code beign compiled, then the compilation
results and stores both under a name different from the next
compilation command... it would be useful to catch spureous error
messages and order dependencies and... etc.
There are three kinds of people in this world: those I care for, those
who know me who dislike me, and those who dont belong to these
categories. Who would be responsible for this problem? If there is
anyone from the first two categories as responsible, it is a personal
problem! In 2004 after my computer was stolen, if I had had access to
a new computer I would have tried compiling my backups with g++...
only to find several well tested sources not compiling for sure.
Failing to compile would have been _proof_ that I was not the author
of my own code! **He cannot even compile it, he does not know how to
program, it is not his code...**, would have sound like a true
statement, but the fault would have been the different compiler! This
reminds me of the case with Plauger, published in CUJ, where he
decided on the authorship of some code based on hidden space
characters at the end of lines. Those spaces are spureous, they depend
on your fingers habits and some editor flags and not everybody would
be aware they could be exposed; I already lost the typing mania of
deleting them... But it was the deciding factor in that case! I can
see the scenario: have somebody make a small change in the widely
acclaimed, open source available, public GNU g++ compiler of choice,
knowing it would brake some _specific_ code, ignore bug reports for a
while, engage in a new version, add complex features, ignore some more
bug reports, shield on the standard, blame new features, recommend
next version just about to be released before accepting anything, and
by the time the problem is finally recognized somebody already lost
its _competitive_ _advantage_, code has to be rewritten, released
accusations of you do not know how to program, CTOs involved, time
wasted, money spent...
For several circumstances I did not notice the theft immediately nor
got access to a computer in the meanwhile, but it could have even
landed me in jail at the time!!! Try explaining why you cannot compile
your own sources and that your computer was stolen to a policeman or
an unconvinced lawyer during the emergency, when somebody else has
your code compiling and even here some people do not admit that the
widely acclaimed, open source available, public GNU g++ compiler of
choice is complaining about 'Retut()()' [note double parenthesis]!! It
is a really erred error message. At least it would have given the
people who have my code time to learn how to use it but they could
have achieved some really unfair advantage. This code I am writing is
new so there is no chance of something like that happening... maybe,
but I expected to have three classes ready in less than four hours...
two weeks ago. Things change, though, if somebody who knows me is
involved! If it was somebody I care for, it is a double trap and a
responsible is behind the scenes; if it is somebody who knows me and
dislikes me, it is criminal sabotage! If neither, it is still open to
liabilities because of criminal intent, and I would still expect a
very simple set intersection to be NULL too. But if besides THIS case
is the excuse... proven.
It is obvious the language needs a copy contructor and because of
singletons (static variables) it needs to do without const copy
contructors legally and without trouble, at will, which besides is
recognized by the standard it pretends to support.
Danilo J Bonsignore