Re: Assignment operator=/copy constructor/temporaries, BROKEN!
On Sep 21, 1:51 pm, Fabrizio J Bonsignore <synto...@gmail.com> wrote:
On Sep 20, 5:41 pm, Joshua Maurice <joshuamaur...@gmail.com> wrote:
Then, note that:
T foo();
T x = foo();
does not call T::operator=. It in fact calls T's copy constructor.
This is very much unlike:
T x;
x = foo();
That calls T's default constructor, and then it calls T::operator= on
that default constructed object.
What is assumed is that
AO Function() {return AO();}
AO x = Function();
is equivalent to, or _after optimization_ becomes equivalent to:
AO *pFunction() {return new AO;}
AO &x = *pFunction();
//this is unavoidable but system generated
Remember_System_ToCallDeleteOnThisParticularReferenceObjectsMemory(x);
but is treated as if it was:
T x = foo();
My problem _includes_ pass by value from a function. In the actual
working code I unearthed this bug problem, currently it even seems
there is an EXTRA call to a destructor that is generated by this
temporary optimization, but AFTER the system exits, that may be
matching the spureous message:
no match for 'operator=' in 'f = BO::Retit()()',
after adding const solved the compiling problem (at the expense of
threatening to dichotomize the rest of the library with calls to const
and const_casts).
Once you get that, read:http://www.parashift.com/c++-faq-lite/ctors.htm=
l#faq-10.9
which explains that the extra copy is likely optimized away, so T's
copy constructor is likely not called either, which results in very
efficient, readable, and maintainable code.
My point is still that the compiler implementation is confused by the
temporary (optimization) and ends up looking and asking an illegal
constructor signature and/or posts other ambiguous error messages, and
this error was found when using an initialization idiom.
What you describe is horribly broken.
Let's take the example:
T foo()
{ T y;
//do stuff
return y;
}
int main()
{ T x = foo();
}
A good compiler will transform the previous code into the following
(pseudo-)code:
void foo(T * retval)
{ new (retval) T;
//do stuff
}
int main()
{ //use compiler magic to not invoke constructor here.
T x;
//instead, the constructor will be invoked inside foo
foo( & x );
}
Voila. No additional dynamic memory allocation is done.
Your understanding of (named) return value optimization and copy
constructor elision is horribly flawed, and your compiler may also be
horribly broken. What compiler are you using? Move to a non-broken
compiler.