C++, Deleting dynamic arrays defined within functions/iterative processes - c++

Question

I'm working on an assignment which involves updating the size of a dynamic array to store repeated inputs, with a value of -1 signifying the end of input. When I use this code:
bool end = false;
int curr;
int n = 0;
int* currArr = new int[n];
int* temp = NULL;
while (end == false) {
cin >> curr;
if (curr == -1) {
end = true;
}
else {
n++;
int* temp = new int[n];
temp = currArr;
temp[n - 1] = curr;
currArr = temp;
}
}
delete[] currArr;
delete[] temp;
am I defining a memory address for temp, changing what is stored at that address during each iteration, then cleanly deleting the contents of that address at the end?
Or am I allocating a new dynamic array during each iteration, only deleting the array defined in the final iteration, and leaking the rest? If so, how would I avoid that?
Similarly, if I define a dynamic array within a function like so:
int* fxn(int size) {
int* x = new int[size];
return &x[0];
}
int main() {
int* y = fxn(size);
delete[] y;
return 0;
}
My understanding is that deleting y will delete the array because y is pointing to the same address that x pointed to within the function. If fxn were a void function, x would need to be deleted within fxn, because fxn would not output any information to the main with which to locate x.
Am I understanding it correctly?
Thanks!

Answer 1

Each time you allocate memory and assign your previous allocated pointer to the newly allocated memory, you should delete the previous one. Otherwise it results in a memory leak. In your case curArr keeps pointing to the new address in the loop but previous is never deleted. Then your delete of both curArr and temp will crash because they are pointing to the same location, so you're deleting the same pointer twice. And assinging temp to curArray after allocating it, you just lost the newly allocated pointer again. So the code is a giant mess that's full of leaks and crashes. You're also initially allocating a memory of size 0 which is undefined behavior.
#include <iostream>
#include <memory>
using namespace std;
int main(){
bool end = false;
int curr;
int n = 1;
int* currArr = new int[n];
while (end == false) {
cin >> curr;
if (curr == -1) {
end = true;
}
else {
currArr[n - 1] = curr;
int* temp = new int[n+1];
memcpy(temp, currArr, n*sizeof(int));
delete[] currArr;
currArr = temp;
++n;
}
}
for(int index = 0; index < n-1; ++index){
std::cout << currArr[index]<< std::endl;
}
delete[] currArr;
}
I got rid of redundancies in your code and fixed up the leaks.
The code will initially allocate memory with a size of n=1. Then whatever the user enters into curr will be placed at index n-1. Then new memory will be allocated using temp to size of n+1. The previous memory from curArr will be copied into the newly allocated region. The previous region of curArr will be deleted and the pointer will be assigned to the new region.
And yes. Your understanding of your second question is correct.

Answer 2

int* temp = new int[n];
This allocates a new int array, in dynamic scope, assigning the allocated array to temp. Immediately afterwards:
temp = currArr;
This takes the newly-allocated array, temp, and immediately overwrites this pointer with an existing pointer currArr. The newly-allocated memory is leaked, and when is all and said and done, both temp and currArr are now the same pointer value (the second assignment, two lines later, does not change this, it's already too late).
delete[] currArr;
delete[] temp;
Therefore, this ends up delete[] ing the same pointer value twice, resulting in undefined behavior, memory corruption, and a likely crash.
Additionally, even if the allocation in the loop is fixed so it doesn't get clobbered, since the loop can execute more than once, and this deletes anything only at the conclusion of the loop, there's no way to avoid leaking memory, in any case.
am I defining a memory address for temp, changing what is stored at
that address during each iteration, then cleanly deleting the contents
of that address at the end?
No, you're leaking memory, corrupting memory, and causing undefined behavior, and a likely crash.
You need to fix the initial allocation, so it doesn't get clobbered, and delete the previous buffer (currArray) immediately after allocating the new one (temp), and then, finally, assign temp to currArray (after copying its contents).