possible problems after resizing dynamic array

Got little problem here.

I created dynamic array:

   m_elements  = new struct element*[m_number_of_elements];
   for(int i = 0; i < m_number_of_elements; i++)
   {
       m_elements[i] = new struct element[m_element_size];
   }

then I tried to resize existing array:

   m_elements[m_number_of_elements] = create_more_elements();
   m_number_of_elements++;

create_more_elements() is a function:

   struct index* create_more_elements()
   {
   开发者_如何学C     struct element* tmp = new struct element[m_number_of_elements]
        return tmp;
   }

In general, this piece of code works, but sometimes I get segfaults in different places. Are segfaults connected with resizing? Any thoughts?

You should use std::vector for it, then you can with new allocate memory for new struct and push her pointer to vector, if you deleting you should delete on pointer.

Try this:

std::vector<element> m_elements;
m_elements.resize(m_number_of_elements);

Don't go the route of manually managing an array unless absolutely necessary - std::vector will do a far better job, is better tested, proven, standardized and understood by legions of C++ programmers. See my code example - not even a single new or delete statement, yet this code also contains all required memory management.

P.S.: Since this question is tagged as C++, you don't have to write struct element whereever you use it as a type, just element will suffice. This suggests you are coming from C, so my advice: learn about the STL before you continue what you're doing, a single hour spent learning how to use the standard container classes can save you many days of manual tweaking, debugging and bug-fixing. Especially since once you've learnt one, you already know like 80% about all the others. :)

m_elements[i] = new struct element[m_element_size];

This creates an array of element of size m_element_size

To dynamically create a struct, just use new struct element or new element.

If don't have to initialize values in your array, you may even be better not storing pointers but actual objects in your array:

m_elements = new element[m_number_of_elements];

To "resize" an array, you actually have to allocate a new bigger array, copy the content of current array in the new one, and delete the old array.

// Allocate new array
element* newArray = new element[m_number_of_elements + 1];
// Copy old array content into new one
memcpy(newArray, m_elements, m_number_of_elements * sizeof(element)];
// Delete old array
delete[] m_elements;
// Assign new array
m_elements = newArray;
// Keep new size
m_number_of_elements += 1;

But you should definitely use std::vector which is simpler and smarter than that:

std::vector<element> elements;

// Add an element
Element element;
...
elements.push_back(element);

It is a wonder that you code even works. Basically what you are doing is overwriting memory after your initially allocated array. In C++ you can't resize the array, you can only delete it and new up a new one.

element** tmp = new element*[m_number_of_elements];
for(int i = 0; i < m_number_of_elements; i++)
{
    tmp[i] = m_elements[i]
}
delete m_elements;
m_elements = tmp;

m_elements[m_number_of_elements] = create_more_elements();    
m_number_of_elements++;

But, that is really crufty. As Svisstack points out, you should use std::vector or any other suitable standard container.

std::vector<element*> m_elements;

// ...

m_elements.push_back(create_more_elements());