Exceptions & Constructors

[jalqadir]

The constructor in MyClass instantiates many objects pointers through
'new', I would like to implement a way to make sure that the object
has been allocated in memory by catch(ing) the bad_alloc exception
error, but this means that I have to throw this error back from
MyClass constructor, how can I avoid this?

Thanks folks!

[=?ISO-8859-1?Q?Erik_Wikstr=F6m?=]

On 2007-07-30 13:15, ja******@gmail. com wrote:

The constructor in MyClass instantiates many objects pointers through
'new', I would like to implement a way to make sure that the object
has been allocated in memory by catch(ing) the bad_alloc exception
error, but this means that I have to throw this error back from
MyClass constructor, how can I avoid this?

Sure, add a flag to the class that tells if the object was constructed
correctly:

class Foo {
int* ptrarr[16];
public:
bool correct;
Foo() correct(true) {
try {
for (size_t i = 0; i < 16; ++i)
ptrarr[i] = new int();
} catch(bad_alloc &) {
correct = false;
}
}
};

int main() {
Foo f;
if (f.correct == false) {
// Opps, failed to allocate
}
}

--
Erik Wikström

[Jim Langston]

<ja******@gmail .comwrote in message
news:11******** **************@ l70g2000hse.goo glegroups.com.. .

The constructor in MyClass instantiates many objects pointers through
'new', I would like to implement a way to make sure that the object
has been allocated in memory by catch(ing) the bad_alloc exception
error, but this means that I have to throw this error back from
MyClass constructor, how can I avoid this?

Well, what do you want your code to do on failure?

Consider:

class Foo
{
// ...
};

int main()
{
Foo Bar;
}

What do you want to happen if Bar can not be instantized because of bad
allocation inside of Foo's constructor? And how do you want to check if it
was successful?

Some things I can think of off the top of my head.

1. Have Foo contain a private bool variable stating if all pointers have
been instantized correctly with newed instances. Alternative to this, is to
check any of the pointers itself for a NULL value which you would set in the
constructor if initializaiton of the variables failed. Foo could have a
method returning if it was initalized or not. Foo could have it's internal
methods checking initialzation.

2. Have Foo created only by a factory (I.E returning a pointer). If Foo can
not be instantized, the factory returns NULL which mainline can check.

3. Do nothing and have new's throw propogate up to mainline

I could think of a few other methods depending on what you would want done.
It is not a good thing to have an instance floating around that was not
properly instantized. How are you going to provent this if you don't allow
new's throw to propogate? How do you WANT to prevent it?

[Gianni Mariani]

Erik Wikström wrote:

On 2007-07-30 13:15, ja******@gmail. com wrote:

>The constructor in MyClass instantiates many objects pointers through
'new', I would like to implement a way to make sure that the object
has been allocated in memory by catch(ing) the bad_alloc exception
error, but this means that I have to throw this error back from
MyClass constructor, how can I avoid this?

Sure, add a flag to the class that tells if the object was constructed
correctly:

class Foo {
int* ptrarr[16];
public:
bool correct;
Foo() correct(true) {
try {
for (size_t i = 0; i < 16; ++i)
ptrarr[i] = new int();
} catch(bad_alloc &) {
correct = false;
}
}
};

int main() {
Foo f;
if (f.correct == false) {
// Opps, failed to allocate
}
}

That code leaks if it fails. Should you not have to delete all of them
or at lease assign a null pointer ?

[=?ISO-8859-1?Q?Erik_Wikstr=F6m?=]

On 2007-07-30 14:24, Gianni Mariani wrote:

Erik Wikström wrote:

>On 2007-07-30 13:15, ja******@gmail. com wrote:

>>The constructor in MyClass instantiates many objects pointers through
'new', I would like to implement a way to make sure that the object
has been allocated in memory by catch(ing) the bad_alloc exception
error, but this means that I have to throw this error back from
MyClass constructor, how can I avoid this?

Sure, add a flag to the class that tells if the object was constructed
correctly:

class Foo {
int* ptrarr[16];
public:
bool correct;
Foo() correct(true) {
try {
for (size_t i = 0; i < 16; ++i)
ptrarr[i] = new int();
} catch(bad_alloc &) {
correct = false;
}
}
};

int main() {
Foo f;
if (f.correct == false) {
// Opps, failed to allocate
}
}

That code leaks if it fails. Should you not have to delete all of them
or at lease assign a null pointer ?

Actually it does not even compile, I forgot the : in the initialisation
list and have not included the headers for bad_alloc etc. It was more to
show the OP the general idea then to give him/her code that worked, as
an example I don't expect that the OP has an array of pointers but
rather a number of pointers, which should then be initialised to null in
the initialisation list before allocating memory with new. Or perhaps
using some kind of smart pointer.

--
Erik Wikström

[Roy]

On Jul 30, 5:52 pm, Erik Wikström <Erik-wikst...@telia. comwrote:

On 2007-07-30 14:24, Gianni Mariani wrote:

Erik Wikström wrote:

On 2007-07-30 13:15, jalqa...@gmail. com wrote:
The constructor in MyClass instantiates many objects pointers through
'new', I would like to implement a way to make sure that the object
has been allocated in memory by catch(ing) the bad_alloc exception
error, but this means that I have to throw this error back from
MyClass constructor, how can I avoid this?

Sure, add a flag to the class that tells if the object was constructed
correctly:

class Foo {
int* ptrarr[16];
public:
bool correct;
Foo() correct(true) {
try {
for (size_t i = 0; i < 16; ++i)
ptrarr[i] = new int();
} catch(bad_alloc &) {
correct = false;
}
}
};

int main() {
Foo f;
if (f.correct == false) {
// Opps, failed to allocate
}
}

That code leaks if it fails. Should you not have to delete all of them
or at lease assign a null pointer ?

Actually it does not even compile, I forgot the : in the initialisation
list and have not included the headers for bad_alloc etc. It was more to
show the OP the general idea then to give him/her code that worked, as
an example I don't expect that the OP has an array of pointers but
rather a number of pointers, which should then be initialised to null in
the initialisation list before allocating memory with new. Or perhaps
using some kind of smart pointer.

--
Erik Wikström

the lost : in the initialization list had me confused ! :-( , thanks
for clearing this up !
What you have suggested is an elegant way of handling an exception ,
what else is bool used for ?

[=?ISO-8859-1?Q?Erik_Wikstr=F6m?=]

On 2007-07-30 15:09, Roy wrote:

On Jul 30, 5:52 pm, Erik Wikström <Erik-wikst...@telia. comwrote:

>On 2007-07-30 14:24, Gianni Mariani wrote:

Erik Wikström wrote:
On 2007-07-30 13:15, jalqa...@gmail. com wrote:
The constructor in MyClass instantiates many objects pointers through
'new', I would like to implement a way to make sure that the object
has been allocated in memory by catch(ing) the bad_alloc exception
error, but this means that I have to throw this error back from
MyClass constructor, how can I avoid this?

>Sure, add a flag to the class that tells if the object was constructed
correctly:

>class Foo {
int* ptrarr[16];
public:
bool correct;
Foo() correct(true) {
try {
for (size_t i = 0; i < 16; ++i)
ptrarr[i] = new int();
} catch(bad_alloc &) {
correct = false;
}
}
};

>int main() {
Foo f;
if (f.correct == false) {
// Opps, failed to allocate
}
}

That code leaks if it fails. Should you not have to delete all of them
or at lease assign a null pointer ?

Actually it does not even compile, I forgot the : in the initialisation
list and have not included the headers for bad_alloc etc. It was more to
show the OP the general idea then to give him/her code that worked, as
an example I don't expect that the OP has an array of pointers but
rather a number of pointers, which should then be initialised to null in
the initialisation list before allocating memory with new. Or perhaps
using some kind of smart pointer.

--
Erik Wikström

the lost : in the initialization list had me confused ! :-( , thanks
for clearing this up !
What you have suggested is an elegant way of handling an exception ,
what else is bool used for ?

For storing anything that can only have two different values. It is not
uncommon to get into a situation where you want to check something, and
the answer can then either be true or false, such as is a container
empty? Does the container contain a specific element? In all those cases
bool is a suitable return type.

It is also used to check conditions in loops and control-statements, the
==, !=, <, >, <=, and >= operators (along with some I probably forgot)
all return a value of type bool (or something convertible to bool). As
an example a while-loop loops as long as the condition is true, so an
infinite loop can be written like this:

while (true)
{
// ...
}

--
Erik Wikström

[tragomaskhalos]

On Jul 30, 12:15 pm, "jalqa...@gmail .com" <jalqa...@gmail .comwrote:

The constructor in MyClass instantiates many objects pointers through
'new', I would like to implement a way to make sure that the object
has been allocated in memory by catch(ing) the bad_alloc exception
error, but this means that I have to throw this error back from
MyClass constructor, how can I avoid this?

It's worth considering the role of the subordinate object ...
I know you said you wanted to avoid exceptions emerging from your
MyClass ctor, but if the subordinate objects are really an
indivisible part of the MyClass object, ie a MyClass doesn't make
any sense without them and isn't usable unless they are there,
then letting the exception propagate out of the ctor makes sense
and can make your code a lot cleaner. Eg:

MyClass x;
x.good_I_must_h ave_a_fully_con sed_MyClass_now ();

It's worth bearing in mind that many deem propagating exceptions from
ctors to be the correct way of handling this sort of situation, and
view setting a 'constructed ok' flag as a hack best avoided.

Alternatively if the MyClass instance is usable without a subordinate,
then you can absorb the bad_alloc in the MyClass ctor and flag the
absence of the subordinate object with a null pointer:

MyClass x;
if (x.ptr_to_nice_ to_have != 0) // nb should encapsulate properly
x.some_method_u sing_nice_to_ha ve();
Cheers.

[tragomaskhalos]

On Jul 30, 2:39 pm, tragomaskhalos <dave.du.verg.. [e-mail] >
wrote:

>
Alternatively if the MyClass instance is usable without a subordinate,
then you can absorb the bad_alloc in the MyClass ctor and flag the
absence of the subordinate object with a null pointer:

Er, or indeed use a nothrow new and get a null ptr without having to
worry
about bad_alloc at all.

But to amplify my previous point, exceptions are your friends: too
often
people want to catch exceptions as soon as they are thrown and
convert
them into flags or error codes, which obviates the whole purpose of
them,
which is to free a program's logic from endlessly having to check
niggling
little will-only-happen-in-extremely-rare-and-bad-situation failures.

[Xavier Serrand]

<ja******@gmail .coma écrit dans le message de
news:11******** **************@ l70g2000hse.goo glegroups.com.. .

The constructor in MyClass instantiates many objects pointers through
'new', I would like to implement a way to make sure that the object
has been allocated in memory by catch(ing) the bad_alloc exception
error, but this means that I have to throw this error back from
MyClass constructor, how can I avoid this?

Thanks folks!

If you mind, a static function could be used... returning NULL in case of
failure...

Just like that :

template <typename Tstatic Pile<T* createPile(int sz)
{
Pile<T* pp;
try
{
pp = new Pile<T>(sz);
return pp;
}
catch (std::bad_alloc &)
{
try
{
// clearing what can be cleared ...
// ...
// deleting the instance : the destructor has to be sure
// (may be hard to do...)
pp->~Pile<T>();
}
catch (std::exception & e)
{
// nothing to do
}
return NULL;
}
}

But remember what Alf P. Steinbach said !!

Xavier