C / C++ / MFC

void test()
{
foo();
}

void test()
{
  Myclass* p = foo();

do something with "p" then

  delete p;
}

paolosh wrote:

I've debugged the presented code step by step and witnessed that the compiler deletes p itself on exit from test() !

class MyTest
{
public:

   MyTest() { cout << "Creating MyTest " << this << endl; }
   MyTest(MyTest const & rhs) { cout << "Copy-Construct MyTest " << this << " from " << &rhs << endl; }
   MyTest& operator=(MyTest const & rhs) { cout << "Assign MyTest " << this << " from " << &rhs << endl; }
   ~MyTest() { cout << "Destroying " << this; }
}

MyClass * p1 = new MyClass;
MyClass temp = *p1;

MyClass * Get()
{
   MyClass * p = new MyClass;
   return p;
}

MyClass Get()
{
   MyClass * p = new MyClass;
   return *p;
}

void foo(MyClass*& p)
{
   p = new MyClass();
}

void test()
{
   MyClass* p
   foo(p);
   // Use the class using p->
   delete p;
}

void main()
{
   test();
}

void test()
{ foo(); }

• a space wide enough to store a MyClass is leaved on the stack (That's what Myclass foo() means to the compiler)
• the actual code address is pushed on stack, than
• a jump to the beginning of foo is executed.
at thet point

• a space wide enough to store a pointer is leaved on stack. (That's what MyClass* p requires)


• new MyClass() is executed, that means:
  
  
  
  • a bunch of bytes enouh to store MyClass are taken from the heap
  • The MyClass::Myclass() constructor is called
  • The address of the allocated memory is copied to p
  
  
• now, we are at return *p that means:
• a copy of the value pointed by p (that's what *p means) is copied into the space previously left on the stack by calling MyClass(const MyClass&). That's what return If you did not declare it that's not important, the compiler generates it implicitly.

• the p pointer is destroyed by unrolling the stack. The value it store (the address of the heap containing the first Myclass) is lost forever, but the object is still there (hence the leak)
• a jump is executed to the address stored in the stack, thus causing the execution to return after the call.
Now we are back to test().

• No actions are required on the return value, hence it is destroyed and the stack unrolled

Now you have destroyed the temporary copy. The original object is still there.

In general every time you call new, you've to guess where and when there is a corresponding delete that will be called.

if you want to prperly debug all this, yu have to explicitly declare all what the compiler will elsewhere do implicitly: that is



class MyClass
{
public:
  MyClass() {} ///< default constructor
  MyClass(const MyClass&) {} ///< copy contructor
  MyClass& operator=(const MyClass&) { return *this; } ///< assignment
  ~MyClass() {} ///< destructor
};


Now set a breakpoint at all of those functions, and try to debug, and you'll see funny things.



2 bugs found.
> recompile ...
65534 bugs found.

paolosh wrote:

The intention is to create a MyClass instance in foo, and return it without onvoking the constructor on exit.

return *p;

return p;

std::auto_ptr<MyClass> p(foo());

void CMyView::OnDraw (CDC *dc)
{
   CMemDC MemDC (dc); // See Keith Rule's class CMemDC article

   Graphics gfx (MemDC);

   // Do your GDI+ stuff, and let destructors tidy up after! Neat, eh?

  ....
}

void YourClass::OnPaint()
{
	CPaintDC dc(this);
	Graphics g(dc.m_hDC);
	CRect r;
	GetClientRect(r);
	Bitmap memBitmap(r.Width(), r.Height());
	Graphics memGraphics(&memBitmap);
	
	//Do all your drawing on the memGraphics object

	g.DrawImage(&memBitmap, 0, 0);
}