Re: allocate memory of derived class

From:

Salt_Peter <pj_hern@yahoo.com>

Newsgroups:

comp.lang.c++

Date:

Thu, 30 Oct 2008 15:00:18 -0700 (PDT)

Message-ID:

<330374ea-0e7e-4b4d-8aca-d63ac4af5572@d45g2000hsc.googlegroups.com>

On Oct 30, 3:07 pm, Salt_Peter <pj_h...@yahoo.com> wrote:

On Oct 30, 1:23 pm, Steven Powers <StevenAPow...@gmail.com> wrote:

Imagine the following setup

class Parent
{
virtual void doStuff();}

;

class Child : public Parent
{
virtual void doStuff();

}

;

and this function

bool foo(Parent *p)
{
if(!p)
p = new Parent();
p->doStuff();

}

I would like foo() to take a pointer and if it is null allocate the
memory for the class I pass in.

For example

Child * c = NULL;
foo(c);

would result in a Child() constructor and Child::doStuff() being
called.
The way it is now Parent() and Parent::doStuff() will get called.

How can this be done while keeping foo defined as foo(Parent *p) ????

I've thought of using templates like this:
template<class T>
bool foo(Parent* p)
{
if(!p) p = new T();
p->doStuff();

}

but I am unable to get the correct type from a second templated class
that has been passed T = Child* as its template type.

As a follow up can I get a template value T = Child* and somehow pass
foo T=Child ???

Pay attention, you will learn something today.

You said you don't want to change the function's signature so this
would work dandy except for a few problems, i'll try and point out
those to you below:

template<class T>

should really be:
template< typename T >

void foo(Parent* p)
{
  if(!p) p = new T();
  p->doStuff();

}

and you call it like so:

foo< Child >(pc);
or
foo< Parent >(pc);

___
Now, the important parts. In this language its bad news to distribute
allocation and deallocation, the above code is the perfect example why
that rule is so important. When you pass pointers like so:

Child* pc = 0;
foo< Child >(pc);

the pointer pc never gets modified in main, only its copy in foo does,
so once foo returns you've got a memory leak. And to compound the
issue, foo's Parent* p is no more and we can no longer release your
allocated Child. So if you were to:

if(!pc)
    delete pc;

you are in fact deleting nothing. Hence:

template<class T>

template< typename T >

void foo(Parent* p)
{
  if(!p) p = new T();
  p->doStuff();
  delete p; // required

}

Which then brings up another issue. virtual destructors.
Whenever you store derived allocations using a pointer to base, you
must declare you base d~tor virtual or you'll end up only deallocating
a portion of your objects.

class Parent
{
public:
  virtual ~Parent()
  {
    std::cout << "~Parent()\n";
  }
  virtual void doStuff()
  {
    std::cout << "Parent::doStuff()\n";
  }

};

test it, try the d~tor without 'virtual' and delete Parent* p = new
Child.

To solve the original problem involving distributed allocations, you
can pass a pointer by reference, use a smart pointer or some form of
factory that manages allocations and deallocations for you.
If Child is copyable and assigneable, std::vector< Child > or
std::deque< Child > would be the perfect solution. A factory composed
of std::vector< Parent* > would do nicely too.- Hide quoted text -

- Show quoted text -