# extending dynamic memory

## Recommended Posts

staticVoid2    381
hi, I was wondering if there is anyway to extend an allocated array(in c++) without having to copy all the contents from one to the other to save references to the original array from being lost. eg.
UINT size = 50;
UINT current = 0;
int *array = new int[size];

{
if(current++ == size)
{
int *temp = new int[size*2];
copyarray(array, temp);
delete[] array;
array = temp;
}
}


any pointers to the original array will be lost after you create the new array, Is there any way around this?

##### Share on other sites
Crisium    100

int main(blabla)
{
std::vector<mypointer*> vec;

mypointer* p = new mypointer;
vec.push_back( p );

return 0;
}

now you can keep on adding without having to think about moving or reservering memory. The vector will resize itself when it needs more memory. Of course if you are planning on doing this in realtime then you should use the reserve method on the vector.

hope this helps,
Peter Wraae Marino

##### Share on other sites
Spoonbender    1258
Quote:
 Original post by staticVoid2any pointers to the original array will be lost after you create the new array, Is there any way around this?

Depends on exactly what the pointers point to.
If they simply point to the array, use a std::vector instead of raw arrays.
If they point into the array, to specific data elements, no. You'll have to use a different data structure if you want those to stay valid.

##### Share on other sites
the_edd    2109
Quote:
 Original post by staticVoid2hi, I was wondering if there is anyway to extend an allocated array(in c++) without having to copy all the contents from one to the other to save references to the original array from being lost.

If you use std::vector<> it takes care of the copying for you. It also helps to reduce the cost of copying by allocating more than you need initially.

Quote:
 any pointers to the original array will be lost after you create the new array, Is there any way around this?

Use a different data structure, such as a linked list (std::list<>), or use a smart pointer that refers to an index of an existing std::vector<>, something like:

// completely untestedtemplate<typename T>class vec_elem_ptr{public:    typedef std::vector<T>::size_type index_type;    vec_elem_ptr(std::vector<T> &v, index_type idx) :        v_(&v),        idx_(idx)    {    }    T &operator* () const { return v_->at(idx_); } // or assert() and []    T *operator-> () const { return &v_->at(idx_); } // ditto    // etc ...    // operators ++, -- etc would probably make sense here, tooprivate:    std::vector<T> *v_;    index_type idx_;};// Maybe a partial specialisation for <const T>...