C++ object as return value: copy or reference?

Question

I wanted to test how C++ behaves when the return value of a function is an object. I made this little example to watch how many bytes are allocated and determine whether the compiler makes a copy of object (like when object is passed as a parameter) or instead returns some kind of reference.

However, I couldn't run this very simple program and I have no idea why. Error says: "Debug assertion failed! Expression: BLOCK_TYPE_IS_INVALID" in some dbgdel.cpp file. Project is a win32 console application. But I'm pretty sure that there is something wrong with this code.

class Ctest1
{
public:
   Ctest1(void);
   ~Ctest1(void);

   char* classSpace;
};

Ctest1::Ctest1(void)
{
   classSpace = new char[100];
}

Ctest1::~Ctest1(void)
{
   delete [] classSpace;
}

Ctest1 Function(Ctest1* cPtr){
   return *cPtr;    
}

int _tmain(int argc, _TCHAR* argv[])
{
   Ctest1* cPtr;

   cPtr=new Ctest1();


   for(int i=1;i<10;i++)
      *cPtr = Function(cPtr);


   delete cPtr;

   return 0;
   }

Answer 1

Getting (finally) to what you originally intended to ask about, the short answer is that it's rarely a problem. The standard contains a clause that specifically exempts a compiler from having to actually use the copy constructor on a return value, even if the copy constructor has side effects, so the difference is externally visible.

Depending on whether you're returning a variable, or just a value, this is called either named return value optimization (NRVO) or just return value optimization (RVO). Most reasonably modern compilers implement both (some, such as g++ even do it when you turn off optimization).

To avoid copying the return value, what the compiler does is pass the address where the copy would go as a hidden parameter to the function. The function then constructs its return value in that place, so after the function returns, the value is already there without being copied.

This is common enough, and works well enough that Dave Abrahams (at the time a C++ standard committee member) wrote an article some years ago showing that with modern compilers, people's attempts at avoiding the extra copying often actually produce code that's slower than if you just write simple, obvious code.