Dynamic memory deletion within functions - c++

Question

this is my first post, so sorry if it is not asked well.
Basically I am having trouble with dynamic memory and i would like to know if it is me misunderstanding the concept, or at least one of the functions. Ok, so i'm using C++ where I need to manage an array that changes size within the main program loop but i keep getting a heap error when i try to delete the memory. (below is a simplified version of what i'm trying to do).
void main(void)
{
//Initialization
//main loop
while(true)
{
int* array;
function(&array);
printf("test %d",array[0]); //basically use the data
delete [] array;
}
}
//in separate file
void function(**int val)
{
*val=new int[size of array] // i pass the size of the array...
//to the function as well
//fill the array with data
return;
}
Ok so after this i can read the data so it must be attached to the pointer "array" but then why would it not allow me to delete the data as if it was already deleted?
Any advice would be much appreciated thanx.

Answer 1

Not the main problem but you actually have the syntax wrong here,
void function(**int val);
It should be:
void function(int **val);
But you don't need a double pointer as you can simply pass the pointer by-reference:
void function(int *&val);
It follows that your program should be like this:
int main() // main should return int
{
int *array;
function(array, 5);
printf("test %d", array[0]);
delete [] array;
}
void function(int *&val, int size)
{
val = new int[size];
}
You also didn't need the while (true) loop either.

Answer 2

You said that "any advice" was welcomed, so here's my advice:
Don't use C-style arrays in the first place, and this won't be a problem. Use a vector instead:
#include <vector>
#include <algorithm>
void main(void)
{
//Initialization
//main loop
while(true)
{
std::vector <int> array;
function (array);
printf ("test %d", array[0]);
}
}
//in separate file
void function(std::vector <int>& vec)
{
vec.push_back (1);
vec.push_back (2);
// ...etc...
}
Above is a basic and naive implementation that uses a vector instead of C-style arrays and dynamic memory management. There are many opportunities for improvement, but you get the idea.

Answer 3

Your code, in its current state, should work. However, it is very bad practice to use new and delete like that, especially with new/delete in different places.
You should use std::vector instead:
// main function
std::vector<int> array = function();
printf("test %d",array[0]); //basically use the data
And your function() would be:
std::vector<int> function()
{
std::vector<int> val(size);
//fill the array with data
return val;
}

Answer 4

Another idea. The value in passing things by reference is the copying cost of large objects. With pointers you don't need to worry about this. This code could be cleaned up like this as well.
int main() // main should return int
{
int *array = function(SOME_SIZE);
printf("test %d", array[0]);
delete [] array;
}
int * function(int size) //Just return the pointer
{
int *temp = new int[size];
return temp;
}
Since we're dealing with pointers... returning them isn't a big deal, and is typical practice when you need to "transfer" ownership of a dynamically allocated object. That being said, the post that references using vectors or other standard containers is the best approach. Avoiding use of new and delete makes code much safer.