resource leak in this case?

Hello everyone,


Even if I have tested with MSVC 2008 that no resource leak, I want to confirm with you whether it is good code to maintain resource and avoid resource leak. Also whether the code is dependent on some non-Spec regulated points, e.g. MSVC 2008 specific things. :-)

The design pattern is, embed a sub-object into another object (e.g. embed Goo object g into Foo object), but in destructor of Foo, destructor of its sub-object (e.g. Goo object g) is not called explicitly.

I have tested destructor of Goo object g will be called in MSVC 2008, but I am not sure whether we could rely on this -- when object goes out of scope, its sub-object also goes out of scope and destructor always gets called?

Code:

#include <iostream>

using namespace std;

class Goo {
public:
	Goo()
	{
		cout << "constructing Goo" << endl;
	}
	virtual ~Goo()
	{
		cout << "destructing Goo " << endl;
	}
};

class Foo {
public:
	Goo g;
	
	Foo (Goo _g) : g (_g)
	{
		cout << "constructing Foo " << endl;
	}

	virtual ~Foo()
	{
		cout << "destructing Foo " << endl;
	}
};

int func()
{
	Goo g;
	Foo f (g);

	return 0;
}

int main()
{
	func();
	return 0;
}

thanks in advance,
George

All member variables are destroyed when an object is destroyed. An object that goes out of scope is destroyed.

This is just ordinary composition with C++'s deterministic destruction mechanism.

g, the variable local to func, is destroyed when func ends.

_g, the parameter to the Foo constructor, is destroyed when the constructor ends.

f.g, the member variable of the instance of Foo named f, is destroyed when f is destroyed, which is also when func ends.

There are actually three instances of Goo here, although the second copy might be skipped as an optimization. All are destroyed appropriately. This is basic C++ and is much more important to know than some of the other things you've asked about. That makes me wonder if you're question is about something deeper.

Thanks Daved and laserlight,


Question answered.

Originally Posted by Daved

g, the variable local to func, is destroyed when func ends.

_g, the parameter to the Foo constructor, is destroyed when the constructor ends.

f.g, the member variable of the instance of Foo named f, is destroyed when f is destroyed, which is also when func ends.

There are actually three instances of Goo here, although the second copy might be skipped as an optimization. All are destroyed appropriately. This is basic C++ and is much more important to know than some of the other things you've asked about. That makes me wonder if you're question is about something deeper.

regards,
George