realloc vs vector

[Andreas Bauer]

I've got an array in the vein of

MyType* array;
arry = new MyType[100];

This of course works fine, but I have the need to dynamically grow the
boundaries of that array at runtime. I can't seem to use std ::
vector or any other container, cause I've got two more "lists" which
keep pointers to the elements of `array'.

So, if I used std :: vector in order to resize `array', both lists of
pointers would contain garbage, given the resize operation of the
container would shift the memory around - something which I can hardly
check statically.

So what is a good way of dynamically resizing an array without having
to rearrange the internal memory representation? Or, am I on the
totally wrong track here... (might well be). I thought of using
malloc and realloc, but then these do not call the constructors and
destructors of MyType.

Andi.

[John Harrison]

"Andreas Bauer" <ba*****@mailbr oy.informatik.t u-muenchen.de> wrote in
message news:sl******** ************@lo calhost.localdo main...

I've got an array in the vein of

MyType* array;
arry = new MyType[100];

This of course works fine, but I have the need to dynamically grow the
boundaries of that array at runtime. I can't seem to use std ::
vector or any other container, cause I've got two more "lists" which
keep pointers to the elements of `array'.

So, if I used std :: vector in order to resize `array', both lists of
pointers would contain garbage, given the resize operation of the
container would shift the memory around - something which I can hardly
check statically.

So what is a good way of dynamically resizing an array without having
to rearrange the internal memory representation? Or, am I on the
totally wrong track here... (might well be). I thought of using
malloc and realloc, but then these do not call the constructors and
destructors of MyType.

Andi.

The answer is very simple, don't keep pointers to the 'array'. This will
cause problem whatever means of resizing the array you use, malloc/realloc,
new, vector, its all the same.

Instead keep integer indexes in your lists, these will always be valid.

john

[Michael Kurz]

"Andreas Bauer" <ba*****@mailbr oy.informatik.t u-muenchen.de> schrieb im
Newsbeitrag news:sl******** ************@lo calhost.localdo main...

I've got an array in the vein of

MyType* array;
arry = new MyType[100];
So, if I used std :: vector in order to resize `array', both lists of
pointers would contain garbage, given the resize operation of the
container would shift the memory around - something which I can hardly
check statically.

You could use a std::deque, where references to items are not invalid after
a growth.
Of course a deque is not an dynamic array its more a dynamic array of
pointers to the stored elements.
(Thats why the references to items can stay valid during growth)
Regards
Michael

[Andrew Koenig]

"Andreas Bauer" <ba*****@mailbr oy.informatik.t u-muenchen.de> wrote in
message news:sl******** ************@lo calhost.localdo main...

I've got an array in the vein of MyType* array;
arry = new MyType[100]; This of course works fine, but I have the need to dynamically grow the
boundaries of that array at runtime. I can't seem to use std ::
vector or any other container, cause I've got two more "lists" which
keep pointers to the elements of `array'. So, if I used std :: vector in order to resize `array', both lists of
pointers would contain garbage, given the resize operation of the
container would shift the memory around - something which I can hardly
check statically. So what is a good way of dynamically resizing an array without having
to rearrange the internal memory representation? Or, am I on the
totally wrong track here... (might well be). I thought of using
malloc and realloc, but then these do not call the constructors and
destructors of MyType.

It wouldn't work anyway, because realloc would invalidate those pointers as
surely as std::vector would.

If you must have pointers to your container elements, rather than integers
that represent array indices, have you considered std::deque instead? It
has the property of not moving elements around as long as you restrict
yourself to inserting and deleting elements at either end of the sequence,
rather than in the middle.

[Siemel Naran]

"Andreas Bauer" <ba*****@mailbr oy.informatik.t u-muenchen.de> wrote in
message

MyType* array;
arry = new MyType[100];

This of course works fine, but I have the need to dynamically grow the
boundaries of that array at runtime. I can't seem to use std ::
vector or any other container, cause I've got two more "lists" which
keep pointers to the elements of `array'.
In addition to std::deque as others pointed out, you can also try std::list.
This one lets you insert elements even in the middle of the list, and
pointers to existing elements remain valid!

So what is a good way of dynamically resizing an array without having
to rearrange the internal memory representation? Or, am I on the
totally wrong track here... (might well be). I thought of using
malloc and realloc, but then these do not call the constructors and
destructors of MyType.

Note that realloc is not garaunteed to work. If the array can be grown in
place, that is if the memory is available, then yes it will work (ie.
pointers to existing elements will remain valid). But if no space is
available, realloc does a malloc and copies elements from the old place to
the new. Besides, you can only use malloc etc with POD types (or just
bytes).

[Siemel Naran]

"John Harrison" <jo************ *@hotmail.com> wrote in message

"Andreas Bauer" <ba*****@mailbr oy.informatik.t u-muenchen.de> wrote in

MyType* array;
= new MyType[100];

This of course works fine, but I have the need to dynamically grow the
boundaries of that array at runtime. I can't seem to use std ::
vector or any other container, cause I've got two more "lists" which
keep pointers to the elements of `array'.

The answer is very simple, don't keep pointers to the 'array'. This will
cause problem whatever means of resizing the array you use, malloc/realloc, new, vector, its all the same.

Instead keep integer indexes in your lists, these will always be valid.

A very good solution too.

But what if the array of pointers has pointers to objects from different
array's? Then keeping the index is not enough. You need a struct that
contains a pointer to the array as well as an integer index.

[Ioannis Vranos]

Andreas Bauer wrote:

I've got an array in the vein of

MyType* array;
arry = new MyType[100];

This of course works fine, but I have the need to dynamically grow the
boundaries of that array at runtime. I can't seem to use std ::
vector or any other container, cause I've got two more "lists" which
keep pointers to the elements of `array'.

So, if I used std :: vector in order to resize `array', both lists of
pointers would contain garbage, given the resize operation of the
container would shift the memory around - something which I can hardly
check statically.

So what is a good way of dynamically resizing an array without having
to rearrange the internal memory representation? Or, am I on the
totally wrong track here... (might well be). I thought of using
malloc and realloc, but then these do not call the constructors and
destructors of MyType.

You can use vector::reserve () to reserve memory (but no objects get
created) for future expansion:
#include <vector>
int main()
{
using std::vector;
vector<int>some Vec;

// Reserves memory for 500 objects.
// Future expansion up to this number
// guarantees that no objects will be moved
// No objects get created
someVec.reserve (500);
// Other operations
// ...

someVec.resize( 100);

// ...
}

--
Ioannis Vranos

http://www23.brinkster.com/noicys