复制阵列然后删除原始

Question

I have an array of a structure (with the parameters of name and number), and the initial array takes in elements from a document that I've made. The initial list size starts at 1000. When the list fills up, I call another method that I'm struggling with. I would like for it to copy the data into a new array that doubled the size, and then delete the old array.

If I name it: array1 and array2, I have my program use array1 throughout. I need help with the pointers that would get array2 to work as array1.

Is there a way to copy the array to a temp array of the same or new size, and then remake the initial array reassigning back to that? For this exercise, I can't use vectors. While I know how to use them, and that they solve this issue while being better, I'm trying to do it with only arrays.

using namespace std;

struct Information {
  char functionality;
  int SSN;
  string name;
};

int numPeople = 1000;

//Gets called if the initial array (whatever size) is filled
void doubleArray(Information *array){
  numPeople = numPeople * 2;
  //Will now be the doubled array size
  Information temp[numPeople]
  for(int i = 0; i < numArray; i++){
    temp[i].SSN = array[i].SSN;
    temp[i].name = array[i].name;
  }
  //Normally makes it crash
  delete[] array;
}

edit: This is what I currently have

void doubleArray(Information *person){
  numPeople = numPeople * 2;
  Information* temp = new Information[numPeople];
  memcpy(temp, person, numPeople);
  delete[] person;
  person = temp;
}

It gets to numPeople = 1000 (the initial list size) but then crashes shortly after. Is the doubling array correct?

Answer 1

Arrays are fixed size. You cannot change the capacity of the original array.

{ Use std::vector }

You can have a pointer to an array. And use the same pointer. When the array is full, you can allocate another array, copy old array items to new array, delete the old array and assign your array pointer to the new array.

{Did I mention std::vector ?}

By the way, there is a data structure that performs resizing as necessary. If I recall correctly, it is std::vector . Try it out. :-)

Answer 2

Assuming you are using std::array (which you should be), then copying the array is very easy.

std::array<myStruct, 1000> array1{};
std::array<myStruct, 2000> array2{};
// codes...
std::copy(array1.begin(), array1.end(), array2.begin())

However, this is a specific scenario in which you only use these two arrays. It will not dynamically double the size of the array as you simply cannot do this dynamically with stack-based arrays, just like c arrays[].

What you can, and should, be using is std::vector<myStruct> . This will dynamically grow as you need it. Until you provide us with code and a more specific issue, this is the best advice that I can offer with the information provided.

Answer 3

If you aren't allowed to use std::vector , as one of your comments stated, then you'll want to look at dynamic allocation.

size_t sz = [whatever];

// Dynamically allocate an array of size sz.
T* T_array = new T[sz];

// Do whatever...

delete[] T_array; // new[] needs to be paired with delete[].
T_array = nullptr; // Not strictly necessary, but a good idea if you have more code after.

As the size doesn't need to be constant for a dynamic array, this will allow you to allocate memory as necessary. You can then use std::copy() to copy data from one array to the other, as Goodies mentioned .

[For more information on dynamic allocation, see here .]