Adding pointer to container

[tech]

Hi, i have a std::vector of pointers to base classes say
std::vector<ele ment*m_elements ;
how do i make the followin exception safe

function()
{
element* e= new DerivedElement;
m_elements.push _back(element);
}

the push back operation can throw so i can leak element if it throws
i thought of doing this but it still has the same problem as e.get()
gets executed first
then if the push back throws i leak the pointer. How to solve?? I
can't use
Boost on this project so the shared_ptr is not an option

function()
{
std::auto_ptr <elemente(new DerivedElement) ;
m_elements.push _back(e.get());
}

[Ian Collins]

tech wrote:

Hi, i have a std::vector of pointers to base classes say
std::vector<ele ment*m_elements ;
how do i make the followin exception safe

function()
{
element* e= new DerivedElement;
m_elements.push _back(element);
}

the push back operation can throw so i can leak element if it throws
i thought of doing this but it still has the same problem as e.get()
gets executed first
then if the push back throws i leak the pointer. How to solve?? I
can't use
Boost on this project so the shared_ptr is not an option

Then roll your own simple shared_ptr pointer.

--
Ian Collins.

[Chris Thomasson]

"tech" <na************ @googlemail.com wrote in message
news:01******** *************** ***********@z66 g2000hsc.google groups.com...

Hi, i have a std::vector of pointers to base classes say
std::vector<ele ment*m_elements ;
how do i make the followin exception safe

function()
{
element* e= new DerivedElement;
m_elements.push _back(element);
}

the push back operation can throw so i can leak element if it throws
i thought of doing this but it still has the same problem as e.get()
gets executed first
then if the push back throws i leak the pointer. How to solve?? I
can't use
Boost on this project so the shared_ptr is not an option

function()
{
std::auto_ptr <elemente(new DerivedElement) ;
m_elements.push _back(e.get());
}

You could do something like:

function()
{
std::auto_ptr <elemente(new DerivedElement) ;
m_elements.push _back(e.get());
e.release();
}

[tech]

On Jun 11, 12:15*pm, "Chris Thomasson" <cris...@comcas t.netwrote:

"tech" <naumansulai... @googlemail.com wrote in message

news:01******** *************** ***********@z66 g2000hsc.google groups.com...

Hi, i have a std::vector of pointers to base classes *say
std::vector<ele ment*m_elements ;
how do i make the followin exception safe

function()
{
* *element* e= new DerivedElement;
* *m_elements.pus h_back(element) ;
}

the push back operation can throw so i can leak element if it throws
i thought of doing this but it still has the same problem as e.get()
gets executed first
then if the push back throws i leak the pointer. How to solve?? I
can't use
Boost on this project so the shared_ptr is not an option

function()
{
* std::auto_ptr <elemente(new DerivedElement) ;
* m_elements.push _back(e.get());
}

You could do something like:

function()
{
* *std::auto_ptr <elemente(new DerivedElement) ;
* *m_elements.pus h_back(e.get()) ;
* *e.release();

}- Hide quoted text -

- Show quoted text -- Hide quoted text -

- Show quoted text -

Replying to Chris Thomasson

std::auto_ptr <elemente(new DerivedElement) ;
m_elements.push _back(e.get());
e.release();

But this is what i had above without the e.release() at the
bottom, if m_elements.push _back(e.get()); this throws
as the e.get() has already given up the pointer then if the
push back throws surely i will leak the pointer.
Or are you saying the e.get() returns a copy of the pointer
and the auto_ptr still hangs onto it. In that case
it would work and thanks to you

[Paavo Helde]

tech <na************ @googlemail.com kirjutas:

Hi, i have a std::vector of pointers to base classes say
std::vector<ele ment*m_elements ;
how do i make the followin exception safe

function()
{
element* e= new DerivedElement;
m_elements.push _back(element);
}

the push back operation can throw so i can leak element if it throws
i thought of doing this but it still has the same problem as e.get()
gets executed first
then if the push back throws i leak the pointer. How to solve?? I
can't use
Boost on this project so the shared_ptr is not an option

What about:

void function()
{
m_elements.push _back(NULL);
element*& ref = m_elements.back ();
ref = new DerivedElement;
}

HTH
Paavo

[Daniel Pitts]

Alf P. Steinbach wrote:

* Paavo Helde:

>>
What about:

void function()
{
m_elements.push _back(NULL);
element*& ref = m_elements.back ();
ref = new DerivedElement;
}

If DerivedElement constructor throws, has already added nullpointer to
vector.
Cheers, & hth.,

- Alf

How about using a try/catch.
void function() {
element * d = new DerivedElement;
try {
m_elements.push _back(d);
} catch (...) {
delete d;
throw;
}
}
--
Daniel Pitts' Tech Blog: <http://virtualinfinity .net/wordpress/>

[Paavo Helde]

"Alf P. Steinbach" <al***@start.no kirjutas:

* Paavo Helde:

>>
What about:

void function()
{
m_elements.push _back(NULL);
element*& ref = m_elements.back ();
ref = new DerivedElement;
}

If DerivedElement constructor throws, has already added nullpointer to
vector.

Yes, that's true. What I would do actually in this case, would be to use
the ScopeGuard from Andrei Alexandrescu. This is a case of glueing
together C-style interfaces (raw pointers!) and ScopeGuard comes quite
handy in such situations:

#include <ScopeGuard/ScopeGuard.h>

template <class T>
struct Delete {
void operator()(T *t) const { delete t;}
};
void function()
{
element* e = new DerivedElement;
ScopeGuard guard = MakeGuard(Delet e<element>(), e);
m_elements.push _back(e);
guard.Dismiss() ;
}

But this is only because I have the Delete template and ScopeGuard
includes already in place in the project anyway. std::auto_ptr would work
the same in this case (I suppose, never used myself) and would require
less code in this case.

Regards
Paavo

[Roland Pibinger]

On Sun, 15 Jun 2008 16:30:19 +0200, "Alf P. Steinbach" wrote:

>* Roland Pibinger:

>2. You cannot practically 'handle' Out-Of-Memory (OOM).

Well I think I've written something like that in the past.

Well, some years ago I thought that you could handle OOM ...

>But it's wrong.

Think about an application where the user attempts to load a very big image
file. If allocation fails, a good way to handle it is to inform the user that
sorry, that file was too big. A bad way to handle it would be to terminate...

In case of a file you know the file size in advance and know if the
size is within the limits of your function contract. The Java language
distinguishes between (recoverable) Exceptions and (fatal) Errors.
What can you do after OOM? Can you recover vital memory to proceed?
Hardly in practice. IMO, OOM is a fatal error (like stack overflow and
memory corruption) that should lead to more or less abrupt termination
of the program. This also means that you need not write your code as
if std::bad_alloc were a recoverable exception.
--
Roland Pibinger
"The best software is simple, elegant, and full of drama" - Grady Booch

[Kai-Uwe Bux]

Paavo Helde wrote:

rp*****@yahoo.c om (Roland Pibinger) kirjutas:

>On Wed, 11 Jun 2008 03:36:07 -0700 (PDT), tech rote:

>>>Hi, i have a std::vector of pointers to base classes say
std::vector< element*m_eleme nts;
how do i make the followin exception safe

function()
{
element* e= new DerivedElement;
m_elements.push _back(element);
}

You question includes more than one aspect:

1. STL is designend for values only (a.k.a. 'value semantics'), not
objects or pointers to objects. Put simply, STL doesn't work with
pointers.

It seems this is so ridiculous no one has bothered to answer. For innocent
bystanders I just remind that pointers are values in C++.

It is true, though, that pointers often require special handling when
dealing with containers. The most basic issue is illustrated by

std::map< char const *, some_type >

By default, the map will compare pointer values and not the strings they
represent. Very likely that is _not_ the desired behavior.
Best

Kai-Uwe Bux

[Paavo Helde]

Kai-Uwe Bux <jk********@gmx .netkirjutas:

Paavo Helde wrote:

>rp*****@yahoo.c om (Roland Pibinger) kirjutas:

>>On Wed, 11 Jun 2008 03:36:07 -0700 (PDT), tech rote:
Hi, i have a std::vector of pointers to base classes say
std::vector <element*m_elem ents;
how do i make the followin exception safe

function( )
{
element* e= new DerivedElement;
m_elements.push _back(element);
}

You question includes more than one aspect:

1. STL is designend for values only (a.k.a. 'value semantics'), not
objects or pointers to objects. Put simply, STL doesn't work with
pointers.

It seems this is so ridiculous no one has bothered to answer. For
innocent bystanders I just remind that pointers are values in C++.

It is true, though, that pointers often require special handling when
dealing with containers. The most basic issue is illustrated by

std::map< char const *, some_type >

By default, the map will compare pointer values and not the strings
they represent. Very likely that is _not_ the desired behavior.

If you specify the map keys as pointers, they will be compared as
pointers, that's it. I see nothing specific to STL here.

You could easily instruct the map to use the string comparison (if/when
needed) instead by providing an extra template argument for the map
declaration.

IOW, STL does what it is told to do. It does not attempt to read your
mind. This is a Good Thing IMO.

Regards
Paavo