Problem of template and delete function

[Hajra]

Sponsored Links

I have a problem of memory management and I can not find the solution. I have a Array_1D class, which meets roughly the role of the standard Vector class. This class is a template, so I have a pointer to the memory block containing the data set:

template <class type>
class      Array_1D
{
private:
   int  number_of_elements;
   int  last_element;
   type* array;
      .............

To add items to the storage class, I extend_array a function taking as parameter the number of element to add:

template <class type>
type&
Array_1D<type>::extend_array(const int& number_of_elements_to_add)
{
   int  new_number_of_elements = number_of_elements + number_of_elements_to_add;
 if(new_number_of_elements > 0)
 {
  if(array != NULL)
  {
   type* buffer = new type[new_number_of_elements];
         memcpy(buffer, array, sizeof(type) * number_of_elements);
     delete[] array;
     array = buffer;
  }
  else
     array = new type[new_number_of_elements];
 }
     number_of_elements = new_number_of_elements;
     last_element = number_of_elements - 1;
     return array[last_element];
}

The problem is delete []. It planted my application. If I put comments in it works, but obviously I have big memory leaks. I do not understand where is the problem, do you have an idea?

[void]

1. Why not do use vector?
2. The copy constructor which are not executed, that can explain you many things
3. A crash problem with a delete, it is often a corrupt and it can have its cause and may close any time before.

[Hajra]

It is true that I have used vector, but for several reasons I chose my own coded class. Could you explain the concept of copy constructor if that's the case of interest? If I replace memcpy with a loop which copies elements 1 by 1, it works:

for(int i = 0;i < number_of_elements;i++)
    buffer[i] =array[i];

I do not understand why it works better, especially since the use of memcpy optimizes performance, and that's what I want ...

[!const]

1. memcpy copies lots of bytes
2. buffer [i] = array [i] calls the constructor type (const type &) ... So that's what you do. If you want better perfs then you can consider your template specialization for certain types or memcpy poses no problem
3. use vector

[Modifier]

It is true that I have used vector, but for several reasons I chose my own coded class.

For more you mean that your class is buggy, less efficient, less generic and less than interoperable std:: vector? or because you have nothing else to do with your time reinventing the cold water? or your are one of those who think the STL is wrong?