partially initialized constructor

[John Goche]

Hello,

I would like fooBar to be initialized to zero in the following scenario
where there is not enough memory to complete construction after
an object of sizeof(FooBar) has been allocated on the heap. Is
the standard way to deal with this situation in plain old standard
C++ to use a try catch block in main() and a throw inside the
constructor after cleaning up or can anyone suggest alternatives?

Thanks,

JG

class FooBar {
public:
FooBar();
private:
Foo *foo;
Bar *bar;
}

FooBar::FooBar() {
foo = new Foo(); // successful
bar = new Bar(); // unsuccessful
}

int main() {
FooBar *fooBar = new FooBar();
//...
}

[peter koch]

John Goche skrev:

Hello,

I would like fooBar to be initialized to zero in the following scenario
where there is not enough memory to complete construction after
an object of sizeof(FooBar) has been allocated on the heap. Is
the standard way to deal with this situation in plain old standard
C++ to use a try catch block in main() and a throw inside the
constructor after cleaning up or can anyone suggest alternatives?

The first thing to do is ask yourself why you use raw pointers. You
should realise that as soon as you unconditionally delete the pointers
in the destructor is that the (implied) copy constructor and assignment
operator suddenly does not work. Assuming you disable these, one
solution could be std::auto_ptr:

>
Thanks,

JG

class FooBar {
public:
FooBar();
private:
Foo *foo;
Bar *bar;
}

FooBar::FooBar() {
foo = new Foo(); // successful
bar = new Bar(); // unsuccessful

std::auto_ptr<Fooautofoo(new Foo());
std::auto_ptr<Barautobar(new Bar());
foo = autofoo.reset();
bar = autobar.reset();

}

>
int main() {
FooBar *fooBar = new FooBar();

No reason to use new here. Watch out for the Java syndrome! Perhaps
pointers aren't really appropriate for your solution and again - if yo
need a pointer in your class, quite probably it should not be raw.

/Peter

[Kai-Uwe Bux]

John Goche wrote:

>
Hello,

I would like fooBar to be initialized to zero in the following scenario
where there is not enough memory to complete construction after
an object of sizeof(FooBar) has been allocated on the heap. Is
the standard way to deal with this situation in plain old standard
C++ to use a try catch block in main() and a throw inside the
constructor after cleaning up or can anyone suggest alternatives?

Yes. You want to throw in the constructor if construction does not succeed.
However, cleanup can be handled without try-throw-catch.

class FooBar {
public:
FooBar();
private:
Foo *foo;
Bar *bar;
}

FooBar::FooBar() {
foo = new Foo(); // successful
bar = new Bar(); // unsuccessful
}

int main() {
FooBar *fooBar = new FooBar();
//...
}

A standard idiom, is to use auto_ptr<>:

#include <memory>

typedef int Foo;
typedef int Bar;

class FooBar {
public:
FooBar();
private:
Foo *foo;
Bar *bar;
};

FooBar::FooBar() {
std::auto_ptr<Foofoo_a ( new Foo() );
std::auto_ptr<Barbar_a ( new Bar() );
foo = foo_a.release();
bar = bar_a.release();
}

int main() {
try {
FooBar *fooBar = new FooBar();
// ...
}
catch ( whatever_may_be_thrown ) {
}
}

This generalized easily to an arbitrary number of pointer members.

Best

Kai-Uwe Bux

[peter koch]

peter koch skrev:
[snip]

foo = autofoo.reset();
bar = autobar.reset();

Oops - should be release - not reset, of course.

/Peter

[Ivan Novick]

I would like fooBar to be initialized to zero in the following scenario

where there is not enough memory to complete construction after
an object of sizeof(FooBar) has been allocated on the heap.

I don't think you can force the new operator to return 0 based on logic
inside your constructor. However you can force new to return 0 if the
actual allocation of FooBar fails:

FooBar *fooBar = new(std::nothrow) FooBar();

Is the standard way to deal with this situation in plain old standard
C++ to use a try catch block in main() and a throw inside the
constructor after cleaning up or can anyone suggest alternatives?

Here is another common way, without using auto_ptr as other posters
have shown

FooBar::FooBar()
{
Foo* f = 0;
Bar* b = 0;
try
{
f = new Foo();
b = new Bar();
}
catch(std::bad_alloc b)
{
// rethrow the exception
throw;
}

foo = f;
bar = b;
}

-
Ivan
http://www.0x4849.net

[Michal Nazarewicz]

"Ivan Novick" <iv**@0x4849.netwrites:

>Is the standard way to deal with this situation in plain old standard
C++ to use a try catch block in main() and a throw inside the
constructor after cleaning up or can anyone suggest alternatives?

Here is another common way, without using auto_ptr as other posters
have shown

FooBar::FooBar()
{
Foo* f = 0;
Bar* b = 0;
try
{
f = new Foo();
b = new Bar();
}
catch(std::bad_alloc b)
{

You need to 'delete f;' here.

// rethrow the exception
throw;
}

foo = f;
bar = b;
}

--
Best regards, _ _
.o. | Liege of Serenly Enlightened Majesty of o' \,=./ `o
..o | Computer Science, Michal "mina86" Nazarewicz (o o)
ooo +--<mina86*tlen.pl>---<jid:mina86*chrome.pl>--ooO--(_)--Ooo--