Re: Does binding to const-reference outperform copy-initialization from returned value?

Igor Tandetnik wrote:


Thanks, Igor. So "in principle", it would be preferable to bind the returned
value to a const-reference, but in practice (at least for VC++),
copy-initialization performs equally well, right?

 I did some tests, but I couldn't find any difference in behavior, between
the two ways to retrieve the return value. Here's my test program:

    //////////////////////////////////////////////////
    class Foo
    {
    public:
        unsigned copyCount;

        Foo(void)
        :
        copyCount(0)
        {
        }

        Foo(const Foo& arg)
        :
        copyCount(arg.copyCount + 1)
        {
        }

        Foo& operator=(const Foo& arg)
        {
            copyCount = arg.copyCount + 1;
            return *this;
        }
    };

    Foo GetFoo()
    {
        // Hoping for Named Return Value Optimization (NRVO).
        Foo returnValue;
        return returnValue;
    }

    int main(void)
    {
      const Foo& constReference = GetFoo();
      const Foo constValue = GetFoo();
      return constReference.copyCount + (constValue.copyCount << 2);
    }

    //////////////////////////////////////////////////

Indeed, in Release mode, the test returns zero, indicating that none of the
Foo's has been copied. In Debug mode, the test returns 5, indicating that a
Foo is copied once in both cases. BTW, I still wonder if it wouldn't be
preferable to skip the copying in Debug mode as well. I do appreciate being
able to step into every line of source code, while debugging. But it doesn't
seem very useful to me to step into a copy-constructor, if that function is
being skipped when the application is released. What do you think?

Kind regards, Niels