Re: Defeating (N)RVO
Alberto Ganesh Barbati schrieb:
One solution I see is to rely on the "destructive copy" behavior of
std::auto_ptr, for example:
class ErrorCode
{
std::auto_ptr<ErrorInfo> error;
[...]
A plus of using std::auto_ptr is that you can nicely pack your error
info into a class.
Your idea is good, but it has a similar defect as my one. Consider the
following artificial, but legal situation (as you note, my reference
counting ansatz can currently be defeated by another, but similar
construction):
ErrorCode foo();
void test() {
ErrorCode res = foo(); // Lets assume, we encounter an error result.
ErrorCode other = res; // Programmer assumption: Equivalence exists
std::cout << res.ok() << std::endl; // Will always return OK!
} // boom!
The problem is, that the code was probably right (although not very
useful), before the programmer substituted his/her previous
non-checking version (which used probably a simple enum or such),
but fails after the substitution.
Don't understand me wrong, your approach is fine in itself. I' m just
the devils advocate, who considers the situation that one has a bunch
of error-code checking code, where this checker object should be
introduced to verify each result check, but no others transformations
are allowed. In this situation it is rather normal, that the old error
code type has usual, non-moving copy semantic, which is silently
changed by using the auto-ptr move semantic.
Greetings,
Daniel
--
[ See http://www.gotw.ca/resources/clcm.htm for info about ]
[ comp.lang.c++.moderated. First time posters: Do this! ]